二叉树、树、森林

A tree is a (possibly non-linear) data structure made up of nodes or vertices 
and edges without having any cycle. The tree with no nodes is called the null 
or empty tree. A tree that is not empty consists of a root node and potentially 
many levels of additional nodes that form a hierarchy.

A simple unordered tree; in this diagram, the node labeled 7 has two children, 
labeled 2 and 6, and one parent, labeled 2. The root node, at the top, 
has no parent. 上图是一棵无序的树示例。在上图中，标号为7的结点有两个孩子，分别是标号为2和6的结点。
根结点，在最顶端，它没有双亲。

A Perfect Binary Tree(PBT) is a tree with all leaf nodes at the same depth. 
All internal nodes have degree 2.

A Complete Binary Tree （CBT) is a binary tree in which every level, 
except possibly the last, is completely filled, and all nodes 
are as far left as possible.

A Full Binary Tree (FBT) is a tree in which every node other than the leaves has two children.

package BinaryTree;



//二叉树及线索二叉树实现
public class BinaryTree {

    public static String[] treeNodes;  //初始化数组
    public static Node root;  //根结点
    public static int index;  //初始化结点
    public static Node preNode=null;  //线索化时记录前一个结点
    
    
    public void initByDLR(String tree)
    {
        treeNodes=tree.split("");
        index=0;
        root=new Node();
        createTreeByDLR(root);
    }
    
    
    //先序创建(用#替代NUll结点,输入错误会数组溢出)
    public static Node createTreeByDLR(Node node)
    {
        String data=treeNodes[index];
        index++;
        if(data.equals("#"))
        {
            return null;
        }
        else
        {
            node.setData(data);
            node.setLeftChild(createTreeByDLR(new Node()));
            node.setRightChild(createTreeByDLR(new Node()));
            return node;
        }
    }
    
    //返回根结点ROOT
    public Node getRoot()
    {
        return root;
    }
    
    
    //先序遍历
    public void traversalByDLR(Node node)
    {
        
        if(node==null)
        {
            return;
        }
            System.out.print(node.getData());
            traversalByDLR(node.getLeftChild());
            traversalByDLR(node.getRightChild());
    }
    
    
    //中序遍历
    public void traversalByLDR(Node node)
    {
        if(node==null)
        {
            return;
        }
        traversalByLDR(node.getLeftChild());
        System.out.print(node.getData());
        traversalByLDR(node.getRightChild());
    }
    
    
    //后序遍历
    public void traversalByLRD(Node node)
    {
        if(node==null)
        {
            return;
        }
        traversalByLRD(node.getLeftChild());
        traversalByLRD(node.getRightChild());
        System.out.print(node.getData());
    }
    
    //中序线索化二叉树
    public void inThreadByLDR(Node node)
    {
        
        if(node==null)
        {
            return;
        }
        
        inThreadByLDR(node.leftChild);//递归左子树线索化
        
        if(node.leftChild==null)
        {
            node.LTag=true;  //前驱线索
            node.leftChild=preNode; //左子树指向前驱
        }
        if(preNode!=null&&preNode.rightChild==null)
        {
            preNode.RTag=true;//设置后驱线索
            preNode.rightChild=node;//右子树指向本结点
        }
        
        preNode=node;
        inThreadByLDR(node.rightChild);
    }
    
    //中序遍历线索二叉树
    public void traversalByThreadedLDR(Node node)
    {
        //查找最左边结点
        while(node.leftChild!=null||node.LTag!=true)
        {
            node=node.leftChild;
        }
        while(node!=null)
        {
            System.out.println(node.getData());
            //如果后驱为索引
            if(node.RTag)
            {
                node=node.rightChild;
            }
            else
            {
                node=node.rightChild;
                while(node!=null&&node.LTag!=true)
                {
                    node=node.leftChild;
                }
            }
        }
    }
    
}



//二叉树结点(线索化)
class Node {

    public String data;
    public Node leftChild;
    public Node rightChild;
    public boolean LTag;
    public boolean RTag;
    
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public Node getLeftChild() {
        return leftChild;
    }
    public void setLeftChild(Node leftChild) {
        this.leftChild = leftChild;
    }
    public Node getRightChild() {
        return rightChild;
    }
    public void setRightChild(Node rightChild) {
        this.rightChild = rightChild;
    }
    public boolean isLTag() {
        return LTag;
    }
    public void setLTag(boolean lTag) {
        LTag = lTag;
    }
    public boolean isRTag() {
        return RTag;
    }
    public void setRTag(boolean rTag) {
        RTag = rTag;
    }
}

package BinaryTree;

public class App {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //"AB#D##C##"
        //ABDH#KECFI#G#J
        //ABDH#K###E##CFI###G#J##
        BinaryTree bt=new BinaryTree();
        bt.initByDLR("ABDH#K###E##CFI###G#J##");
        System.out.println("先序遍历:");
        bt.traversalByDLR(bt.getRoot());
        System.out.println("\n中序遍历:");
        bt.traversalByLDR(bt.getRoot());
        System.out.println("\n后序遍历:");
        bt.traversalByLRD(bt.getRoot());
//        bt.inThreadByLDR(bt.getRoot());
//        bt.traversalByThreadedLDR(bt.getRoot());
    }
}

先序遍历:
ABDHKECFIGJ
中序遍历:
HKDBEAIFCGJ
后序遍历:
KHDEBIFJGCA

//中序线索化二叉树
    public void inThreadByLDR(Node node)
    {
        
        if(node==null)
        {
            return;
        }
        
        inThreadByLDR(node.leftChild);//递归左子树线索化
        
        if(node.leftChild==null)
        {
            node.LTag=true;  //前驱线索
            node.leftChild=preNode; //左子树指向前驱
        }
        if(preNode!=null&&preNode.rightChild==null)
        {
            preNode.RTag=true;//设置后驱线索
            preNode.rightChild=node;//右子树指向本结点
        }
        
        preNode=node;
        inThreadByLDR(node.rightChild);
    }

bt.inThreadByLDR(bt.getRoot()); //线索化
System.out.println("\n中序遍历线索二叉树:");
bt.traversalByThreadedLDR(bt.getRoot());