通常二叉樹的建立，前序，中序，後序遍歷

二叉樹的前序，中序，後序遍歷順序，能夠理解成是以根節點的訪問順序來定義的，

好比：

前序遍歷：根節點，左子樹節點，右子樹節點，

中序遍歷：左子樹節點，根節點，右子樹節點，

後序遍歷：左子樹節點，右子樹節點，根節點，

 

先建立一個Node類來存儲節點的值，左子樹和右子樹

 1 package tree;
 2 
 3 public class Node {
 4     //也能夠將其節點定義爲內部類
 5             public Node right; //右子樹節點
 6             public Node left;    //左子樹節點
 7             public int date;    //該節點存放的值
 8             Node(int newdate){
 9                 right=null;
10                 left=null;
11                 date=newdate;
12             }
13 
14 }

通常二叉樹的實現類

  1 package tree;
  2 
  3 import java.util.LinkedList;
  4 import java.util.List;
  5 
  6 public class Tree {
  7     //給一個默認的數組來構建二叉樹
  8     private int[] array= {1,2,3,4,5,6,7,8,9};
  9     //聲明一個Node類型的list集合來存儲二叉樹的結構
 10     private static List<Node> nodelist=null;
 11 //    //將節點定義爲內部類，由於在其它類中也須要使用到這個Node類，爲了方便就不定義成內部類了
 12 //        private static class Node{
 13 //            Node right;
 14 //            Node left;
 15 //            int date;
 16 //            Node(int newdate){
 17 //                right=null;
 18 //                left=null;
 19 //                date=newdate;
 20 //            }
 21 //        }
 22     public void createTree() {
 23         //建立一個雙鏈表做爲隊列
 24         nodelist=new LinkedList<Node>();
 25         //將數組的值所有轉換爲Node節點
 26         for(int nodelistIndex=0;nodelistIndex<array.length;nodelistIndex++ ) {
 27             nodelist.add(new Node(array[nodelistIndex]));
 28         }
 29         /***
 30          *           1
 31          *         /   \
 32          *        2     3
 33          *       /\     /\
 34          *      4  5   6  7
 35          */
 36         for(int parentIndex=0;parentIndex<(array.length/2-1);parentIndex++) {
 37             //左孩子節點
 38             nodelist.get(parentIndex).left=nodelist.get(parentIndex*2+1);
 39             //右孩子節點
 40             nodelist.get(parentIndex).right=nodelist.get(parentIndex*2+2);
 41         }
 42         /***
 43          *           1
 44          *         /   \
 45          *        2     3
 46          *       /\     /\
 47          *      4  5   6  7
 48          *     / \
 49          *    8   9
 50          */
 51         //最後一個父節點可能只有左孩子節點沒有右孩子節點
 52         int lastParentIndex=array.length/2-1;
 53         nodelist.get(lastParentIndex).left=nodelist.get(lastParentIndex*2+1);
 54         //若是array的數組長度爲奇數，則最後一個父節點有右孩子節點
 55         if(array.length%2==1) {
 56             nodelist.get(lastParentIndex).right=nodelist.get(lastParentIndex*2+2);
 57         }
 58     }
 59     /**
 60      *     使用遞歸的方式來遍歷二叉樹
 61      * @param node
 62      */
 63     //先序遍歷---》根節點，左節點，右節點
 64     public static void preOrdertraverse(Node node){
 65         if(node==null) return;
 66         System.out.print(node.date+"-");
 67         preOrdertraverse(node.left);
 68         preOrdertraverse(node.right);
 69     }
 70     //中序遍歷---》左節點，根節點，右節點
 71     public static void inOrdertraverse(Node node) {
 72         if(node==null)return;
 73         inOrdertraverse(node.left);
 74         System.out.print(node.date+"-");
 75         inOrdertraverse(node.right);
 76     }
 77     //後序遍歷---》左節點，右節點，根節點
 78     public static void postOrdertraverse(Node node) {
 79         if(node==null) return;
 80         postOrdertraverse(node.left);
 81         postOrdertraverse(node.right);
 82         System.out.print(node.date+"-");
 83     }
 84     /**
 85      *     獲得二叉樹的根節點，用做遍歷的始節點
 86      *     
 87      * @return
 88      */
 89     public Node getNodelist() {
 90         return nodelist.get(0);
 91     }
 92     /**
 93      *     設置二叉樹的結構和值，構建時是傳入的數組會如下標從小到大按根，左，右順序構建，例如：
 94      *         {1,2,3,4,5,6,7,8,9}
 95      *             會被構建成
 96      *           1
 97      *         /   \
 98      *        2     3
 99      *       /\     /\
100      *      4  5   6  7
101      *     / \
102      *    8   9
103      * @param array
104      */
105     public void setArray(int[] array) {
106         this.array = array;
107     }
108 }

前中後序遍歷測試代碼：

@org.junit.Test
    public void BinTreeTest() {
        Tree tree=new Tree();
        tree.createTree();
        System.out.println("前序遍歷");
        Tree.preOrdertraverse(tree.getNodelist());
        System.out.println();
        System.out.println("中序遍歷");
        Tree.inOrdertraverse(tree.getNodelist());
        System.out.println();
        System.out.println("後序遍歷");
        Tree.postOrdertraverse(tree.getNodelist());
    }

測試結果：