java实现二叉树的建立及遍历方法

写一个树的结点类：

         public class TreeNode {
    private Object value;//结点取值
    private TreeNode lChild;//结点的左子树
    private TreeNode rChild;//结点的右子树

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public TreeNode getLChild() {
        return lChild;
    }

    public void setLChild(TreeNode child) {
        lChild = child;
    }

    public TreeNode getRChild() {
        return rChild;
    }

    public void setRChild(TreeNode child) {
        rChild = child;
    }

}

构建二叉树及遍历方法的类如下：

public class MakeTree {
/**
 * 构造二叉树的方法
 *
 */
    public TreeNode makeTree(char[] str){//str是传进来的表示二叉树的表达式的char数组    表达式为括号表示法
        TreeNode[] stack=new TreeNode[str.length];//用一个数组来做栈
        int top=-1;
        int k=0,j=0;//k=1表示是左孩子，k=2表示是右孩子
        char ch=str[j];//对数组中的值进行判断
        TreeNode b=null;
        TreeNode p=null;
        while((Character)ch!=null){//char是基本数据类型，char属于基本类型，不是类，只有类才能置成null，基本类型的初始化值只能是0  
            switch (ch) {
            case '(':top++;stack[top]=p;k=1;break;//表示是左子数
            case ',':k=2;break;//表示是右子树
            case ')':top--;break;//
            default: p=new TreeNode();
                     p.setValue(ch);
                     p.setLChild(null);
                     p.setRChild(null);
            if(b==null){//p为根节点
                b=p;
            }else{
                switch (k) {
                case 1:stack[top].setLChild(p);break;//
                case 2:stack[top].setRChild(p);break;//
                }
            }
            }
            if(j<str.length-1){
            ch=str[++j];
            }else{
                break;
            }
        }
        return b;
        
    }
    
    
    /**
     * 递归先序遍历
     */
    public void preOrder(TreeNode root){
        
        if(root!=null){
            System.out.print(root.getValue()+" ");//先序遍历是先遍历根结点再遍历左子树最后遍历右子树  所以先输出根结点
            preOrder(root.getLChild());
            preOrder(root.getRChild());
        }
        
    }
    
    
    /**
     * 非递归实现先序遍历
     */
    
    public void preOrder1(TreeNode root){
        TreeNode[] tn=new TreeNode[50];//将数组假设为栈，即使数组有栈的特性，只在一端进行操作，并且先进后出
        TreeNode p=null;
        int top=-1;
        if(root!=null){
            top++;
            tn[top]=root;
            while(top>-1){
                p=tn[top];
                top--;
                System.out.print(p.getValue()+" ");
                if(p.getRChild()!=null){//先序遍历是先遍历根结点再遍历左子树最后遍历右子树  所以这里先把右子树入栈
                    top++;
                    tn[top]=p.getRChild();
                }
                
                if(p.getLChild()!=null){
                    top++;
                    tn[top]=p.getLChild();
                }
                
                
                
            }
        }
    }
    
    /**
     * 中序递归遍历二叉树
     */
    public void inOrder(TreeNode root){
        if(root!=null){
            inOrder(root.getLChild());
            System.out.print(root.getValue()+" ");//先序遍历是先遍历左子树再遍历根结点最后遍历右子树  所以先输出左子树结点
            inOrder(root.getRChild());
        }
    }
    /**
     * 中序非递归遍历二叉树
     */
    
    public void inOrder1(TreeNode root){
        TreeNode[] tn=new TreeNode[50];
        TreeNode p=null;
        int top=-1;
        if(root!=null){
            p=root;
            while(top>-1||p!=null){
                while(p!=null){//扫描p的所有左结点并进栈
                    top++;
                    tn[top]=p;
                    p=p.getLChild();
                }
                
                if(top>-1){
                    p=tn[top];//出栈p结点
                    top--;
                    System.out.print(p.getValue()+" ");//访问
                    p=p.getRChild();//扫描p结点的所有右孩子
                }
            }
        }
    }
    
    /**
     * 后序递归遍历
     *
     */
    public void postOrder(TreeNode root){
        if(root!=null){
            postOrder(root.getLChild());
            postOrder(root.getRChild());
            System.out.print(root.getValue()+" ");
        }
    }
    
    
    /**
     * 后序非递归遍历
     */
    
    public void postOrder1(TreeNode root){
        TreeNode[] tn=new TreeNode[50];
        TreeNode p=null;
        int top=-1;
        int flag=0;
        if(root!=null){
        do{
            while(root!=null){
                top++;
                tn[top]=root;
                root=root.getLChild();
            }
            
            p=null;
            flag=1;
            while(top!=-1&&flag==1){
                root=tn[top];
                if(root.getRChild()==p){
                    System.out.print(root.getValue()+" ");
                    top--;
                    p=root;
                }else{
                    root=root.getRChild();
                    flag=0;
                }
            }
            
        }while(top!=-1);
    }
    }
    
    /**
     * @主函数
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MakeTree makeTree=new MakeTree();
        String str="A(B(D(,G)),C(E,F))";
        char[] ch=str.toCharArray();
        TreeNode treeNode=makeTree.makeTree(ch);
        System.out.println("二叉树先序递归遍历结果：");
        makeTree.preOrder(treeNode);
        System.out.println();
        
        System.out.println("二叉树先序非递归遍历结果：");
        makeTree.preOrder1(treeNode);
        System.out.println();
        
        
        System.out.println("二叉树中序递归遍历结果：");
        makeTree.inOrder(treeNode);
        System.out.println();
        
        System.out.println("二叉树中序非递归遍历结果：");
        makeTree.inOrder1(treeNode);
        System.out.println();
        
        System.out.println("二叉树后序递归遍历结果：");
        makeTree.postOrder(treeNode);
        System.out.println();
        
        System.out.println("二叉树后序非递归遍历结果：");
        makeTree.postOrder1(treeNode);
        System.out.println();
    }

}