二叉树的创建和遍历方法（上）

二叉树可以用一维数组或者链表来存储，两者各有利弊。用数组表示二叉树容易实现，访问简单，但是浪费空间，尤其是存储歪二叉树时，并且增删数据比较麻烦。本文介绍用一维数组创建二叉树，并遍历二叉树的方法。

以初始数据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