二叉树部分：二叉树的深度，二叉树的前序遍历、二叉树的中序遍历、二叉树的后序遍历、求叶子结点的个数

第一：定义二叉树的结点： 

	/**
 * 链式二叉树结点
 * @author Administrator
 *
 */
public class Node {
	int value;
	Node leftChild;
	Node rightChild;

	public Node(int value) {
		this.value = value;
	}

	public Node(int value, Node leftChild, Node rightChild) {
		super();
		this.value = value;
		this.leftChild = leftChild;
		this.rightChild = rightChild;
	}
}

第二：定义二叉树中的接口： 

public interface BinaryTree {
	/**
	 * 是否空树
	 * @return
	 */
	public boolean isEmpty();
	/**
	 * 树结点数量
	 * @return
	 */
	public int size();
	
	/**
	 * 获取二叉树的高度
	 * @return
	 */
	public int getHeight();
	/**
	 * 查询指定值的结点
	 * @param value
	 * @return
	 */
	public Node findKey(int value); // 查找
	/**
	 * 前序递归遍历
	 */
	public void preOrderTraverse(); 
	/**
	 * 中序遍历递归操作
	 */
	public void inOrderTraverse();  	
	/**
	 * 后序遍历递归操作
	 */
	public  void postOrderTraverse();
	/**
	 * 后序遍历递归操作
	 * @param node  树根结点
	 */
	public  void postOrderTraverse(Node node); 
	/**
	 * 前序遍历非递归操作
	 * 1）对于任意节点current，若该节点不为空则将该节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 * 2）若左子树为空，栈顶节点出栈，访问节点后将该节点的右子树置为current
	 * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	 */
	public void inOrderByStack();
	/**
	 *   中序遍历非递归操作
	 *   1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 *   2）若左子树为空，栈顶节点出栈，将该节点的右子树置为current 
	 *   3) 重复1、2步操作，直到current为空且栈内节点为空。
	 */
	public  void preOrderByStack(); 
	/**
	 * 后序遍历非递归操作
	 * 1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 * 2）若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点 
	 * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	 */
	public  void postOrderByStack(); 
	
	/**
	 * 按照层次遍历二叉树
	 */
	public void levelOrderByStack();
}

第三：二叉树接口的实现类：

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
/**
 * 二叉链树
 * 
 * @author Administrator
 *
 */
public class LinkedBinaryTree implements BinaryTree {
	Node root = null;

	public LinkedBinaryTree(int value) {
		root = new Node(value);
		root.leftChild = null;
		root.rightChild = null;
	}

	public LinkedBinaryTree(Node root) {
		this.root = root;
	}

	@Override
	public boolean isEmpty() {
		return root == null;
	}

	@Override
	public int size() {
		int nl = 0;// number left
		int nr = 0;// number right
		// 中序遍历左子树
		if (root.leftChild != null) {
			BinaryTree leftTree = new LinkedBinaryTree(root.leftChild);
			nl = leftTree.size();
		}
		// 中序遍历右子树
		if (root.rightChild != null) {
			BinaryTree rightTree = new LinkedBinaryTree(root.rightChild);
			nr = rightTree.size();
		}
		return nl + 1 + nr;// 左子树结点数+根节点1个+右子树结点数
	}

	@Override
	public Node findKey(int value) {
		return this.findKey(value, root);
		
	
	} 

	public Node findKey(int value,Node root) {
		if(root == null){
			return null;
		}else if(root != null && root.value == value){
			return root;
		}else {
			Node node1 = this.findKey(value, root.leftChild);
			Node node2 = this.findKey(value, root.rightChild);
			if(node1 != null && node1.value == value){
				return node1;
			}else if(node2 != null && node2.value == value){
				return node2;
			}else{
				return null;
			}
		}
		
	} 
	
	
	public Node findKey2(int value) {
		Node node = null;
		// 中序遍历左子树
		if (root.leftChild != null) {
			BinaryTree leftTree = new LinkedBinaryTree(root.leftChild);
			node = leftTree.findKey(value);
		}
		if (node != null) {
			return node;
		} else {
			// 判断根是否等于要查询值
			if (root.value == value) {
				return root;
			} else {
				// 中序遍历右子树
				if (root.rightChild != null) {
					BinaryTree rightTree = new LinkedBinaryTree(root.rightChild);
					node = rightTree.findKey(value);
					if (node != null) {
						return node;
					} else {
						return null;
					}
				}
			}
		}
		return null;
	} 
	@Override
	public void inOrderTraverse() {
		// 中序遍历左子树
		if (root.leftChild != null) {
			BinaryTree leftTree = new LinkedBinaryTree(root.leftChild);
			leftTree.inOrderTraverse();
		}

		// 输出根
		System.out.print(root.value + "  ");

		// 中序遍历右子树
		if (root.rightChild != null) {
			BinaryTree rightTree = new LinkedBinaryTree(root.rightChild);
			rightTree.inOrderTraverse();
		}

	} // 中序遍历递归操作

	@Override
	public void inOrderByStack() {
		System.out.print("中序非递归遍历:");
		// 创建栈
		Deque<Node> stack = new LinkedList<Node>();
		Node current = root;
		while (current != null || !stack.isEmpty()) {
			while (current != null) {
				stack.push(current);
				current = current.leftChild;
			}

			if (!stack.isEmpty()) {
				current = stack.pop();
				System.out.print(current.value + " ");
				current = current.rightChild;
			}
		}
		System.out.println();

	}

	@Override
	public void preOrderTraverse() {
		// 输出根
		System.out.print(root.value + "  ");

		// 前序遍历左子树
		if (root.leftChild != null) {
			BinaryTree leftTree = new LinkedBinaryTree(root.leftChild);
			leftTree.preOrderTraverse();
		}
		// 前序遍历右子树
		if (root.rightChild != null) {
			BinaryTree rightTree = new LinkedBinaryTree(root.rightChild);
			rightTree.preOrderTraverse();
		}

	}

	@Override
	public void preOrderByStack() {

	}

	@Override
	public void postOrderTraverse() {
		System.out.println("后序遍历");
		this.postOrderTraverse(root);
		System.out.println();

	}

	@Override
	public void postOrderTraverse(Node node) {
		if (node != null) {
			// 后序遍历左子树
			this.postOrderTraverse(node.leftChild);
			// 后序遍历右子树
			this.postOrderTraverse(node.rightChild);
			// 输出根
			System.out.print(node.value + "  ");
		}
	}

	@Override
	public void postOrderByStack() {

	}

	@Override
	public int getHeight() {
		return this.getHeight(root);
	}

	private int getHeight(Node node) {
		if (node == null)
			return 0;// 递归结束：空树高度为0
		else {
			int i = getHeight(node.leftChild);
			int j = getHeight(node.rightChild);
			return (i < j) ? (j + 1) : (i + 1);
		}
	}
	
	public void levelOrderByStack(){
		this.levelOrderByStack(root);
	}
	/**
	 * 将每个节点放入对列中。依据对列先进先出的特点，顺序遍历树。直到队列为空
	 * @param root
	 */
	private void levelOrderByStack(Node root){
		if(root == null) return;
	    Queue<Node> queue = new LinkedList<Node>() ;
	    queue.add(root);
	    while(queue.size() != 0)
	    {
	        int len = queue.size();
	        for(int i=0;i <len; i++)
	        {
	        	Node temp = queue.poll();
	            System.out.print(temp.value+" ");
	            if(temp.leftChild != null)  queue.add(temp.leftChild);
	            if(temp.rightChild != null) queue.add(temp.rightChild);
	        }
	    }
	}

}

第四：二叉树的测试类：

public class Test {

	public static void main(String[] args) {
		//创建一棵二叉树
		Node node5 = new Node(5, null, null);
		Node node4 = new Node(4, null, node5);
		
		Node node7 = new Node(7, null, null);
		Node node3 = new Node(3, null, null);
		Node node6 = new Node(6, null, node7);
		
		Node node2 = new Node(2,node3,node6);
		
		Node root = new Node(1,node4,node2);
		
		LinkedBinaryTree  btree = new LinkedBinaryTree(root);
		
		//先序遍历   1  4  5  2  3  6  7 
		btree.preOrderTraverse();
		System.out.println();
		//中序遍历   4   5    1  3  2  6  7
		btree.inOrderTraverse();
		System.out.println();
		//后序遍历  5  4   3  7  6  2  1
		btree.postOrderTraverse(btree.root);
		System.out.println();
		btree.postOrderTraverse();
		
		btree.inOrderByStack();
		//判断二叉树是否为空
		System.out.println(btree.isEmpty());
		
		//输出二叉树结点数量
		System.out.println(btree.size());
		
		//在二叉树中查找指定内容
		Node node = btree.findKey(4);
		if(node != null){
			System.out.println(node.value);
		}else{
			System.out.println("没有找到");
		}	
		
		//测试树的高度
		System.out.println(btree.getHeight());
		//层次遍历
		btree.levelOrderByStack();
				
	}
}