通過陣列構造二叉樹，所有遍歷演算法以及求二叉樹深度的遞迴演算法

import java.util.LinkedList;


public class BinaryTree {
	//根節點
	private Node<Integer> root;
		
	//二叉樹中節點數量
	private int size;
	
	//無參構造器
	public BinaryTree() {
		root = new Node<Integer>();
	} 
		
	//陣列構造器
	public BinaryTree(int[] values) {
		System.out.print("新建binaryTree:");
		for (int i : values) {
			System.out.print(i);
		}
		System.out.println();
		boolean isLeft = true;
		int len = values.length;
		if (len == 0)
			return ;
		LinkedList<Node<Integer>> queue = new LinkedList<Node<Integer>>();
		root = new Node<Integer>(values[0]);
		queue.addLast(root);
		Node parent = null;
		Node current = null;
		for (int i=1; i<len; i++) {
			current = new Node<Integer>(values[i]);
			queue.addLast(current);
			if (isLeft)
				parent = queue.getFirst();
			else
				parent = queue.removeFirst();
			if (isLeft) {
				parent.setLeftChild(current);
				isLeft = false;
			}else {
				parent.setRightChild(current);
				isLeft = true;
			}
		}
	} 


	
	//遞迴中序遍歷
	public void inorder() {
		System.out.print("binaryTree遞迴中序遍歷:");
		inorderTraverseRecursion(root);
		System.out.println();
	}
	
	//層次遍歷
	public void layerorder() {
		System.out.print("binaryTree層次遍歷:");
		LinkedList<Node<Integer>> queue = new LinkedList<Node<Integer>>();
		queue.addLast(root);
		Node<Integer> current = null;
		while(!queue.isEmpty()) {
			current = queue.removeFirst();
			if (current.getLeftChild() != null)
				queue.addLast(current.getLeftChild());
			if (current.getRightChild() != null)
				queue.addLast(current.getRightChild());
			System.out.print(current.getValue());
		}
		System.out.println();
	}

	
	//獲得二叉樹深度	
	public int getDepth() {
		return getDepthRecursion(root);
	}
	
	private int getDepthRecursion(Node<Integer> node){
		if (node == null)
			return 0;
		int llen = getDepthRecursion(node.getLeftChild());
		int rlen = getDepthRecursion(node.getRightChild());
		int maxlen = Math.max(llen, rlen);
		return maxlen + 1;
	}
	//遞迴先序遍歷	
	public void preorder() {
		System.out.print("binaryTree遞迴先序遍歷:");
		preorderTraverseRecursion(root);
		System.out.println();
	}
	
	

	private void inorderTraverseRecursion(Node<Integer> node) {
		// TODO Auto-generated method stub
		if (node.getLeftChild() != null)
			inorderTraverseRecursion(node.getLeftChild());
		System.out.print(node.getValue());
		if (node.getRightChild() != null)
			inorderTraverseRecursion(node.getRightChild());
	}
	

	private void preorderTraverseRecursion(Node<Integer> node){
		System.out.print(node.getValue());
		if (node.getLeftChild() != null)
			preorderTraverseRecursion (node.getLeftChild());
		if (node.getRightChild() != null)
			preorderTraverseRecursion (node.getRightChild());
	}
	
	//非遞迴先序遍歷	
	public void preorderNoRecursion() {
		System.out.print("binaryTree非遞迴先序遍歷:");
		LinkedList<Node<Integer>> stack = new LinkedList<Node<Integer>>();
		stack.push(root);
		Node<Integer> current = null;
		while (!stack.isEmpty()) {
			current = stack.pop();
			System.out.print(current.getValue());
			if (current.getRightChild() != null)
				stack.push(current.getRightChild());
			if (current.getLeftChild() != null)
				stack.push(current.getLeftChild());
		}
		System.out.println();
	}
	
	/**
	 * 非遞迴中序遍歷
	 * 棧內儲存將要訪問的元素
	 */
	public void inorderNoRecursion() {
		System.out.print("binaryTree非遞迴中序遍歷:");
		LinkedList<Node<Integer>> stack = new LinkedList<Node<Integer>>();
		Node<Integer> current = root;
		while (current != null || !stack.isEmpty()) {
			while(current != null) {
				stack.push(current);
				current = current.getLeftChild();
			}
			if (!stack.isEmpty()) {
				current = stack.pop();
				System.out.print(current.getValue());
				current = current.getRightChild();
			}
		}
		System.out.println();
	}
	
	/**
	 * 非遞迴後序遍歷

	 * 當上一個訪問的結點是右孩子或者當前結點沒有右孩子則訪問當前結點
	 */
	public void postorderNoRecursion() {
		System.out.print("binaryTree非遞迴後序遍歷:");
		Node<Integer> rNode = null;
		Node<Integer> current = root;
		LinkedList<Node<Integer>> stack = new LinkedList<Node<Integer>>();
		while(current != null || !stack.isEmpty()) {
			while(current != null) {
				stack.push(current);
				current = current.getLeftChild();
			}
			current = stack.pop();
			while (current != null && (current.getRightChild() == null ||current.getRightChild() == rNode)) {
				System.out.print(current.getValue());
				rNode = current;
				if (stack.isEmpty()){
					System.out.println();
					return;
				}
				current = stack.pop();
			}
			stack.push(current);
			current = current.getRightChild();
		}
		
	}
	
	public static void main(String[] args) {
		BinaryTree bt = new BinaryTree(new int[]{1,2,3,4,5,6,7,8});
		bt.inorder();
		bt.preorder();
		bt.layerorder();
		bt.preorderNoRecursion();
		bt.inorderNoRecursion();
		bt.postorderNoRecursion();
		System.out.println("深度為：" + bt.getDepth());
	}
}

class Node<V>{
	private V  value;
	private Node<V> leftChild;
	private Node<V> rightChild;
	
	public Node(){
	};
	
	public Node(V value) {
		this.value = value;
		leftChild = null;
		rightChild = null;
	}
	
	public void setLeftChild(Node<V> lNode) {
		this.leftChild = lNode;
	}
	
	public void setRightChild(Node<V> rNode) {
		this.rightChild = rNode;
	}

	public V getValue() {
		return value;
	}

	public void setValue(V value) {
		this.value = value;
	}

	public Node<V> getLeftChild() {
		return leftChild;
	}

	public Node<V> getRightChild() {
		return rightChild;
	}
	
	
}