二叉樹的創建和遍歷方法（上）

二叉樹可以用一維數組或者鏈表來存儲，兩者各有利弊。用數組表示二叉樹容易實現，訪問簡單，但是浪費空間，尤其是存儲歪二叉樹時，並且增刪數據比較麻煩。本文介紹用一維數組創建二叉樹，並遍歷二叉樹的方法。

以初始數據int[] a ={6, 3, 5, 9, 7, 8, 4, 2}爲節點創建二叉樹。二叉樹遵循小於父節點的值放在左子節點，大於父節點的值放在右子節點的原則。從樹根開始，按階層依次存入數組中。

用0表示空節點，則該二叉樹可表示如下：

用一維數組存儲爲：{6, 3, 9, 2, 5, 7, 0, 0, 0, 4, 0, 0, 8, 0, 0}。

前序遍歷該二叉樹，節點順序爲：{6, 3, 2, 0, 0, 5, 4, 0, 9, 7, 0, 8, 0, 0, 0}

中序遍歷該二叉樹，節點順序爲：{0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 8, 9, 0, 0, 0}

後序遍歷該二叉樹，節點順序爲：{0, 0, 2, 4, 0, 5, 3, 0, 8, 7, 0, 0, 0, 9, 6}

實現代碼如下：

import java.util.*;  
public class TreeArray {  
	public static ArrayList<Integer> cachePre = new ArrayList<>();//存儲前序遍歷的結果
	public static ArrayList<Integer> cacheIn = new ArrayList<>();//存儲中序遍歷的結果
	public static ArrayList<Integer> cachePost = new ArrayList<>();//存儲後序遍歷的結果
    public static void main(String[] args){  
        //int[] data =  {5, 9, 1, 3, 12, 21, 8, 2, 7, 9, 15, 17, 6, 4, 18, 25};  
        int[] data = {6, 3, 5, 9, 7, 8, 4, 2};  //初始數據
    	//int[] data = {7, 4, 1, 5, 16, 8, 11, 12, 15, 9, 2};
        int index;  
        int[] treeArray = new int[15];  //存儲二叉樹的數組
        int[] state = new int[treeArray.length];  //state[i]用來判斷treeArray[i]是否已被填充，0表示未，1表示已
        Arrays.fill(state, 0);  
        for(int i=0; i<data.length; i++){  
            index = 0;  
            while(index<state.length&&state[index]!=0){  //比較初始數據和treeArray中的值
                if(data[i]>treeArray[index]){index = index*2+2;}  
                else{index = index*2+1;}  
            }  
            if(index<treeArray.length){  
                treeArray[index] = data[i];  
                state[index] = 1;  
            }  
        }  
        System.out.println("The initial data: ");  
        for(int i=0; i<data.length; i++){  
            System.out.print(data[i]+" ");  
        }  
        System.out.println();  
        System.out.println("The binary tree saved in array: ");  
        for(int i=0; i<treeArray.length; i++){  
            System.out.print(treeArray[i]+" ");  
        }  
        System.out.println();  
        
        preOrder(treeArray, 0);
        inOrder(treeArray, 0);
        postOrder(treeArray, 0);
        
        System.out.println("前序遍歷：");
        for(int i:cachePre){
        	System.out.print(i+" ");
        }
        System.out.println();
        
        System.out.println("中序遍歷：");
        for(int i:cacheIn){
        	System.out.print(i+" ");
        }
        System.out.println();
        
        System.out.println("後序遍歷：");
        for(int i:cachePost){
        	System.out.print(i+" ");
        }
        System.out.println();
    }  
    
    public static void preOrder(int[] tree, int index){//前序遍歷
    	if(index<tree.length){
    		cachePre.add(tree[index]);
    		preOrder(tree, index*2+1);
    		preOrder(tree, index*2+2);
    	}    	
    }
    
    public static void inOrder(int[] tree, int index){//中序遍歷
    	if(index<tree.length){
    		inOrder(tree, index*2+1);
    		cacheIn.add(tree[index]);
    		inOrder(tree, index*2+2);
    	}
    }
    
    public static void postOrder(int[] tree, int index){//後序遍歷
    	if(index<tree.length){
    		postOrder(tree, index*2+1);
    		postOrder(tree, index*2+2);
    		cachePost.add(tree[index]);
    	}
    }
}  

輸出：

The initial data: 
6 3 5 9 7 8 4 2 
The binary tree saved in array: 
6 3 9 2 5 7 0 0 0 4 0 0 8 0 0 
前序遍歷：
6 3 2 0 0 5 4 0 9 7 0 8 0 0 0 
中序遍歷：
0 2 0 3 4 5 0 6 0 7 8 9 0 0 0 
後序遍歷：
0 0 2 4 0 5 3 0 8 7 0 0 0 9 6