JAVA二叉树递归构造、二叉树普通遍历及递归遍历

二叉树类：

package com.antis.tree;

public class BinaryTree {
     
     int data;      //根节点数据
     BinaryTree left;    //左子树
     BinaryTree right;   //右子树
     
     public BinaryTree(int data)    //实例化二叉树类
     {
      this.data = data;
      left = null;
      right = null;
     }
     /**
      * 向二叉树中插入子节点
      * @param root
      * @param data
      */
     public void insert(BinaryTree root,int data){ 
        //二叉树的左节点都比根节点小
      if(data>root.data)                               
      {
       if(root.right==null){
        root.right = new BinaryTree(data);
       }else{
        this.insert(root.right, data);
       }
      }else{ 
        //二叉树的右节点都比根节点大
       if(root.left==null){
        root.left = new BinaryTree(data);
       }else{
        this.insert(root.left, data);
       }
      }
     }

}

 二叉树遍历代码：

package com.antis.tree;

import java.util.Stack;

public class BinaryTreeTraversal {
    
     /**
      * 先序遍历--先根遍历递归
      * @param root
      */
     public static void preOrder(BinaryTree root){  //先根遍历
         if (root==null) {
                return;
         }
         System.out.print(root.data+"-");
         preOrder(root.left);
         preOrder(root.right);
     }
     /**
      * 中序遍历--中根遍历递归
      * @param root
      */
     public static void inOrder(BinaryTree root){     //中根遍历
         if (root==null) {
                return;
         }
         inOrder(root.left);
         System.out.print(root.data+"--");
         inOrder(root.right);
     }
     /**
      * 后序遍历--后根遍历递归
      * @param root
      */
     public static void postOrder(BinaryTree root){    //后根遍历
         if (root==null) {
                return;
         }
         postOrder(root.left);
         postOrder(root.right);
         System.out.print(root.data+"---");
     }
     // 先序遍历非递归      
        public static void preOrder2(BinaryTree t) {    
            Stack<BinaryTree> s = new Stack<BinaryTree>();    
            while (t != null || !s.empty()) {    
                while (t != null) {    
                    System.out.print(t.data+"-");    
                    s.push(t);    
                    t = t.left;    
                }    
                if (!s.empty()) {    
                    t = s.pop();    
                    t = t.right;    
                }    
            }    
        }   
        // 中序遍历非递归     
        public static void InOrder2(BinaryTree t) {    
            Stack<BinaryTree> s = new Stack<BinaryTree>();    
            while (t != null || !s.empty()) {    
                while (t != null) {    
                    s.push(t);    
                    t = t.left;    
                }    
                if (!s.empty()) {    
                    t = s.pop();    
                    System.out.print(t.data+"--");    
                    t = t.right;    
                }    
            }    
        }    
        
        // 后序遍历非递归  
        public static void PostOrder2(BinaryTree t) {    
            Stack<BinaryTree> s = new Stack<BinaryTree>();
            Stack<Integer> s2=new Stack<Integer>();
            Integer i=new Integer(1);
            while (t != null || !s.empty()) {    
                while (t != null) {    
                    s.push(t); 
                    s2.push(new Integer(0));
                    t = t.left;    
                }    
                while (!s.empty() && s2.peek().equals(i)) { 
                    s2.pop();
                    System.out.print(s.pop().data+"---");    
                }    
        
                if (!s.empty()) {
                    s2.pop();
                    s2.push(new Integer(1));
                    t = s.peek();    
                    t = t.right;    
                }    
            }    
        }    
     public static void main(String[] str){
          int[] array = {12,76,35,22,16,48,90,46,9,40};
          BinaryTree root = new BinaryTree(array[0]);   //创建二叉树
          for(int i=1;i<array.length;i++){
              root.insert(root, array[i]);       //向二叉树中插入数据
          }
          System.out.println("先根遍历：");
          preOrder(root);
          System.out.println();
          System.out.println("先根遍历：");
          preOrder2(root);
          System.out.println();
          System.out.println("中根遍历：");
          inOrder(root);
          System.out.println();
          System.out.println("中根遍历：");
          InOrder2(root);
          System.out.println();
          System.out.println("后根遍历：");
          postOrder(root);
          System.out.println();
          System.out.println("后根遍历：");
          PostOrder2(root);
     }
}

运行结果：

先根遍历：
12-9-76-35-22-16-48-46-40-90-
先根遍历：
12-9-76-35-22-16-48-46-40-90-
中根遍历：
9--12--16--22--35--40--46--48--76--90--
中根遍历：
9--12--16--22--35--40--46--48--76--90--
后根遍历：
9---16---22---40---46---48---35---90---76---12---
后根遍历：
9---16---22---40---46---48---35---90---76---12---