<剑指offer 面试题7-1>构建二叉树以及实现遍历 Java

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
public class BinaryTree {
	
	private int[] array={1,2,3,4,5,6,7,8,9};
	private static List<Integer> resList=new ArrayList<Integer>();

	/**
	* 定义树节点
	*/
	public static class TreeNode{
		int val;
		TreeNode leftchild;
		TreeNode rightchild;
		public TreeNode(int data){
		this.val=data;
		}
	}
	/**
	* 创建二叉树
	* @return
	*/
	public TreeNode createBinaryTree(){
		TreeNode root=null;
		List<TreeNode> nodelist=new ArrayList<TreeNode>();
		for(int i=0;i<array.length;i++){
			nodelist.add(new TreeNode(array[i]));
		
		}
		for(int j=0;j<array.length/2-1;j++){
			nodelist.get(j).leftchild=nodelist.get(2*j+1);
			nodelist.get(j).rightchild=nodelist.get(2*j+2);
		}
		
		//为了防止个数是偶数的时候可能会溢出比如当array.length=10 10/2-1=4; 2*4+2=10>array.length-1
		int temp=array.length/2-1;
		nodelist.get(temp).leftchild=nodelist.get(2*temp+1);
		nodelist.get(temp).rightchild=nodelist.get(2*temp+2);
		root=nodelist.get(0);
		return root;
	}
	
	/**
	* 先序遍历(递归)
	* @param root
	* @return
	*/
	public List<Integer> preOrderTraverse(TreeNode root){
		if(root!=null){
			resList.add(root.val);
			System.out.print(root.val+",");
			preOrderTraverse(root.leftchild);
			preOrderTraverse(root.rightchild);
		}
		return resList;
	}
	/**
	* 先序遍历(非递归)
	* @param root
	* @return
	*/
	public List<Integer> preOrderTraverseNR(TreeNode root){
		Stack<TreeNode> nodestack=new Stack<TreeNode>();
		TreeNode node=root;
		while(node!=null || !nodestack.isEmpty()){
			while(node!=null )
			{
				resList.add(node.val);
				System.out.print(node.val+",");
				nodestack.push(node);
				node=node.leftchild;
			}
			node=nodestack.pop();
			node=node.rightchild;
		}
		return resList;
	}
	
	/**
	* 中序遍历(非递归)
	* @param root
	* @return
	*/
	public List<Integer> InOrderTraverse(TreeNode root){
		if(root!=null){
			InOrderTraverse(root.leftchild);
			resList.add(root.val);
			System.out.print(root.val+",");
			InOrderTraverse(root.rightchild);
		}
		return resList;
	}
	/**
	* 中序遍历(非递归)
	* @param root
	* @return
	*/
	public List<Integer> InOrderTraverseNR(TreeNode root){
		Stack<TreeNode> nodestack=new Stack<TreeNode>();
		TreeNode node=root;
		while(node!=null || !nodestack.isEmpty()){
			while(node!=null){
				nodestack.push(node);
				node=node.leftchild;
			}
			node=nodestack.pop();
			resList.add(node.val);
			System.out.print(node.val+",");
			node=node.rightchild;
		}
		return resList;
	}
	/**
	* 后序遍历(递归)
	* @param root
	* @return
	*/
	public List<Integer> postOrderTraverse(TreeNode root){
		if(root!=null){
			postOrderTraverse(root.leftchild);
			postOrderTraverse(root.rightchild);
			resList.add(root.val);
			System.out.print(root.val+",");
		}
		return resList;
	}
	/**
	* 后序遍历(非递归)
	* @param root
	* @return
	*/
	public List<Integer> postOrderTraverseNR(TreeNode root){
		Stack<TreeNode> nodestack=new Stack<TreeNode>();
		List<TreeNode> nodelist=new ArrayList<TreeNode>();
		TreeNode node=root;
		while(node!=null || !nodestack.isEmpty()){
			while(node!=null && !nodelist.contains(node)){
				nodestack.push(node);
				node=node.leftchild;
			}
			if(!nodestack.isEmpty()){
				node=nodestack.pop();
				resList.add(node.val);
				nodelist.add(node);
				System.out.print(node.val+",");
				if(!nodestack.isEmpty())
				{
					node=nodestack.peek();
					node=node.rightchild;
				}
			}
		}
		return resList;
	}
	/**
	* 层序遍历
	* @param root
	* @return
	*/
	public static List<Integer> levelTraverse(TreeNode root){
		Queue<TreeNode> nodequeue=new LinkedList<TreeNode>();
		if(root!=null)nodequeue.offer(root);
		while(root!=null ){
			if(root.leftchild!=null){
				nodequeue.offer(root.leftchild);
				}
			if(root.rightchild!=null){
				nodequeue.offer(root.rightchild);
				}
			TreeNode temp=nodequeue.poll();
			resList.add(temp.val);
			System.out.print(temp.val+",");
			if(!nodequeue.isEmpty())
				root=nodequeue.peek();
			else
				root=null;
			}
		return resList;
		}
	
	public static void main(String[] args){
		BinaryTree bt=new BinaryTree();
		TreeNode root=bt.createBinaryTree();
		System.out.println("层次遍历二叉树：");
		bt.levelTraverse(root);
		System.out.println("\n递归先序遍历二叉树：");
		bt.preOrderTraverse(root);
		System.out.println("\n非递归先序遍历二叉树：");
		bt.preOrderTraverseNR(root);
		System.out.println("\n递归中序遍历二叉树：");
		bt.InOrderTraverse(root);
		System.out.println("\n非递归中序遍历二叉树：");
		bt.InOrderTraverseNR(root);
		System.out.println("\n递归后序遍历二叉树：");
		bt.postOrderTraverse(root);
		System.out.println("\n非递归后序遍历二叉树：");
		bt.postOrderTraverseNR(root);
	}
}