先放上資料結構中有關樹的一些定義：

1. 節點：節點包括一個數據元素及若干指向其子樹的分支

2. 節點的度：節點所擁有的子樹的個數成為該節點的度

3. 葉節點：度為0的節點稱為葉結點

4. 分支節點：度不為0的節點稱為分支節點

5. 樹的度：樹中所有節點的度的最大值

6. 二叉樹：是n(n>=0)個有限節點構成的集合。n=0的樹稱為空二叉樹；n=1的樹只有一個根結點；
   n>1的二叉樹由一個根節點和至多兩個互不相交的，分別稱為左子樹和右子樹的子二叉樹構成
   二叉樹不是有序樹，這是因為，二叉樹中某個節點即使只有一個子樹也要區分是左子樹還是右子樹；
   而對於有序樹來說，如果某個節點只有一個子樹就必定是第一個子樹

7. 二叉樹所有結點的形態有5種

   ：空節點，無左右子樹節點，只有左子樹節點，只有右子樹節點和左右子樹均存在的節點

8. 滿二叉樹：在一棵二叉樹中，如果所有分支節點都存在左子樹和右子樹，並且所有葉子節點都在同一層，則這樣的二叉樹稱作滿二叉樹
9. 完全二叉樹：如果一顆具有n個節點的二叉樹的結構與滿二叉樹的前n個節點的結構相同，這樣的二叉樹稱為完全二叉樹
10. 二叉樹的性質：

1)若規定根節點的層數為0，則一棵非空二叉樹的第i層上最多有2^i(i>=0)個節點
2)若規定只有根節點的二叉樹的深度為0，則深度為k的二叉樹的最大節點數是2^(k+1)-1(k>=-1)
3)對於一棵非空的二叉樹，如果葉節點個數為n0，度為2的節點個數為n2，則有n0=n2+1
4)具有n個節點的完全二叉樹的深度k為大於或等於ln(n+1)-1的最小整數
5)對於具有n個節點的完全二叉樹，如果按照從上至下和從左至右的順序對所有節點序號從0開始順序編號，則對於序號為i(0<=i< n)的節點有：
如果i>0，則序號為i節點的雙親節點的序號為(i-1)/2(/為整除)；如果i=0，則序號為i節點為根節點，無雙親節點 如果2i+1<
n,則序號為i節點的左孩子節點的序號為2i+1；如果2i+1>=n,則序號為i節點無左孩子 如果2i+2<
n,則序號為i節點的右孩子節點的序號為2i+2;如果2i+2>=n，則序號為i節點無右孩子

11.二叉樹的儲存結構

1.二叉樹的順序儲存結構 利用性質5，對於完全二叉樹可以利用一維陣列儲存，如果不是完全二叉樹，則可以補空節點，使成為完全二叉樹在進行儲存，
但是對於非完全二叉樹，可能要浪費很多的空間。
2.二叉樹的鏈式儲存結構 二叉樹的鏈式儲存結構就是用指標建立二叉樹中節點之間的關係，二叉樹最常用的鏈式儲存結構是二叉鏈。二叉樹的二叉鏈儲存結構是一種常用的
二叉樹儲存結構。二叉鏈存儲存結構的優點時，結構簡單，可以方便的構造任何形狀的二叉樹，並可以方便的實現二叉樹的大多數操作。
二叉鏈儲存結構的缺點是，查詢當前節點的雙親節點操作實現比較麻煩
3.二叉樹的模擬指標儲存結構 利用一維陣列和結構體實現，利用陣列的下標進行模擬指標進行二叉樹的操作

下面為具體程式碼實現：

package tree;

import java.util.LinkedList;
import java.util.List;
/** 
 *  
 * @author [email protected] @date: 2017-3-7 
 *  
 */  
public class BinTreeTraverse {
    private int arr[]={1,2,3,4,5,6,7};
    private static List<Node> nodeList=null;
    private static class Node{
        Node leftchild;
        Node rightchild;
        int data;
        Node(int newdata){
            leftchild=null;
            rightchild=null;
            data=newdata;
        }

    }
    public void createBintree(){//新建一個二叉樹
        nodeList=new LinkedList<Node>();
        for (int nodIndex = 0; nodIndex < arr.length; nodIndex++) {
            nodeList.add(new Node(arr[nodIndex]));
        }
        //以下定義主要依據上面講解的第五條的特性實現
        for (int parentIndex = 0; parentIndex < arr.length/2-1; parentIndex++) {
            //左孩子
            nodeList.get(parentIndex).leftchild=nodeList.get(parentIndex*2+1);
            //右孩子
            nodeList.get(parentIndex).rightchild=nodeList.get(parentIndex*2+2);
        }
        //最後一個父節點，因為最後一個父節點可能沒有右孩子，所以單獨拿出來處理
        int lastParentIndex=arr.length/2-1;
        //左孩子
        nodeList.get(lastParentIndex).leftchild=nodeList.get(lastParentIndex*2+1);
        if (arr.length%2==1) {
            nodeList.get(lastParentIndex).rightchild=nodeList.get(lastParentIndex*2+2);
        }
    }
     /** 
     * 先序遍歷 
     *  
     * 這三種不同的遍歷結構都是一樣的，只是先後順序不一樣而已 
     *  
     * @param node 
     * 遍歷的節點 
     */  
    public static void preOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        System.out.print(node.data + " ");  
        preOrderTraverse(node.leftchild);  
        preOrderTraverse(node.rightchild);  
    }  

    /** 
     * 中序遍歷 
     *  
     * 這三種不同的遍歷結構都是一樣的，只是先後順序不一樣而已 
     *  
     * @param node 
     *            遍歷的節點 
     */  
    public static void inOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        inOrderTraverse(node.leftchild);  
        System.out.print(node.data + " ");  
        inOrderTraverse(node.rightchild);  
    }  

    /** 
     * 後序遍歷 
     *  
     * 這三種不同的遍歷結構都是一樣的，只是先後順序不一樣而已 
     *  
     * @param node 
     *            遍歷的節點 
     */  
    public static void postOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        postOrderTraverse(node.leftchild);  
        postOrderTraverse(node.rightchild);  
        System.out.print(node.data + " ");  
    }  

    public static void main(String[] args) {  
        BinTreeTraverse binTree = new BinTreeTraverse();  
        binTree.createBintree();  
        // nodeList中第0個索引處的值即為根節點  
        Node root = nodeList.get(0);  

        System.out.println("先序遍歷：");  
        preOrderTraverse(root);  
        System.out.println();  

        System.out.println("中序遍歷：");  
        inOrderTraverse(root);  
        System.out.println();  

        System.out.println("後序遍歷：");  
        postOrderTraverse(root);  
    }  

}

輸出的結果為：

先序遍歷：
1 2 4 5 3 6 7 
中序遍歷：
4 2 5 1 6 3 7 
後序遍歷：
4 5 2 6 7 3 1