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

来源：互联网发布：英国大学排名知乎编辑：程序博客网时间：2024/06/05 14:42

写一个树的结点类：

         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();
   }

}