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---