二叉樹建立 ---層次遍歷方式

使用層次遍歷 採用遞歸的方式建立二叉樹：-1表示空結點

package TreeNode;

public class TreeCreate {

	public TreeNode root;
	
	public TreeCreate(int [] array)
	{
		root=CreateTree(array,0);
		
	}
	public TreeNode CreateTree(int [] array,int index)//對二叉樹採用層次遍歷遞歸方式
	{
		if(index>=array.length || array[index]==-1 )
			return null;
		TreeNode node=new TreeNode(array[index]);
		node.left=CreateTree(array,2*index+1);
		node.right=CreateTree(array,2*(index+1));
		
		return node;
	}
	 public void preShow(TreeNode node) { // 先序遍歷
	        if (node != null) {
	            System.out.print(node.val + " ");
	            preShow(node.left);
	            preShow(node.right);
	        }
	    }
	 
	 public static void main(String[] args) {
		 int array[]={1,2,3,4,-1,5,6,7,8,-1,-1,9,10};
		 TreeCreate Tree=new TreeCreate(array);
		 Tree.preShow(Tree.root);
	 }
}

如果在這個過程中採用的是先序遍歷遞歸的建立二叉樹

public TreeNode root;
	
	public TreeCreate(int [] array)
	{
		root=CreateTreePre(array);
		
		
	}
          int index=0;//index 作爲一個全局變量，根結點右邊子樹值在數組中是存放最末尾
	public TreeNode CreateTreePre(int [] array)
	{ 
		int val=array[index++];
		if(val==-1)
			return null;
		else {
			
			TreeNode node=new TreeNode(val);
			node.left=CreateTreePre(array);
			node.right=CreateTreePre(array);
			return node;
		}
	}
 public void preShow(TreeNode node) { // 先序遍歷
	        if (node != null) {
	            System.out.print(node.val + " ");
	            preShow(node.left);
	            preShow(node.right);
	        }
	    }
 public static void main(String[] args) {
		
		 int array1[]={1,2,-1,3,-1,-1,4,-1,-1};
		TreeCreate Tree1=new TreeCreate(array1);
		 System.out.println("通過前序遍歷得到二叉樹");
		 Tree1.preShow(Tree1.root);
	 }

結果顯示： 1 2 3 4 

package com.offer;

public class TreeNode {
	
int val = 0;
TreeNode left = null;
TreeNode right = null;

public TreeNode(int val)
{
	this.val=val;
}

public TreeNode()
{
	CreateBinaryTree();// 採用默認的
	//preShow(this.root);
}
public TreeNode(int array[])
{
   this.root=CreateBinaryTree(array);
}
public TreeNode root;  

public void CreateBinaryTree()
{
	int array[]={5,3,6,-1,-1,2,-1,-1,1,-1,-1};
	this.root=CreateBinaryTree(array);
}
public TreeNode CreateBinaryTree(int array[])
{
	
	/**第一種建立二叉樹方式採用先序遍歷建立二叉樹**/
	return CreateTreePre(array);
	
	/**第二種方式採用層次遍歷方式建立二叉樹*/
	//return CreteTreeLevel(array,0);
}

@SuppressWarnings("unused")
private TreeNode CreateTreeLevel(int[] array,int index) {
	if(index>=array.length || array[index]==-1)
		return null;
	TreeNode node=new TreeNode(array[index]);
	node.left=CreateTreeLevel(array,2*index+1);
	node.right=CreateTreeLevel(array,2*(index+1));
	return node;
}
private int index=0;

private TreeNode CreateTreePre(int array[])
{
      int val=array[index++];
      if(val==-1)
			return null;
		else
		{
			TreeNode node=new TreeNode(val);
			node.left=CreateTreePre(array);
			node.right=CreateTreePre(array);
			return node;
		}
}
	   
public void preShow(TreeNode node) { // 先序遍歷  
    if (node != null) {  
        System.out.print(node.val + " ");  
        preShow(node.left);  
        preShow(node.right);  
    }  
}  

 public static void main(String[] args)
 {
	TreeNode r=new TreeNode();}
}