java版 二叉树 所有递归和非递归遍历算法

通过数组构造二叉树，所有遍历算法以及求二叉树深度的递归算法

import java.util.LinkedList;


public class BinaryTree {
	//根节点
	private Node root;
		
	//二叉树中节点数量
	private int size;
	
	//无参构造器
	public BinaryTree() {
		root = new Node();
	} 
		
	//数组构造器
	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> queue = new LinkedList>();
		root = new Node(values[0]);
		queue.addLast(root);
		Node parent = null;
		Node current = null;
		for (int i=1; i(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> queue = new LinkedList>();
		queue.addLast(root);
		Node 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 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 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 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> stack = new LinkedList>();
		stack.push(root);
		Node 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> stack = new LinkedList>();
		Node 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 rNode = null;
		Node current = root;
		LinkedList> stack = new LinkedList>();
		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{
	private V  value;
	private Node leftChild;
	private Node rightChild;
	
	public Node(){
	};
	
	public Node(V value) {
		this.value = value;
		leftChild = null;
		rightChild = null;
	}
	
	public void setLeftChild(Node lNode) {
		this.leftChild = lNode;
	}
	
	public void setRightChild(Node rNode) {
		this.rightChild = rNode;
	}

	public V getValue() {
		return value;
	}

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

	public Node getLeftChild() {
		return leftChild;
	}

	public Node getRightChild() {
		return rightChild;
	}
	
	
}