二叉树的三种遍历方式（java实现）

public abstract class BSATree<T extends Comparable<T>> {

	protected BSTNode<T> aRoot; // 根结点

	/**
	 * 节点
	 * 
	 * @timestamp Mar 5, 2016 2:48:29 PM
	 * @author smallbug
	 * @param <E>
	 */
	protected class BSTNode<E> {
		E key; // 关键字(键值)
		BSTNode<E> left; // 左孩子
		BSTNode<E> right; // 右孩子
		BSTNode<E> parent; // 父结点

		public BSTNode(E key, BSTNode<E> parent, BSTNode<E> left, BSTNode<E> right) {
			this.key = key;
			this.parent = parent;
			this.left = left;
			this.right = right;
		}

		public BSTNode(E key, BSATree<T>.BSTNode<E> parent) {
			super();
			this.key = key;
			this.parent = parent;
		}

	}

	/**
	 * 创建二叉树
	 * 
	 * @timestamp Mar 5, 2016 2:48:37 PM
	 */
	protected abstract void createBSTree();

	/**
	 * 记录节点
	 * 
	 * @timestamp Mar 5, 2016 2:49:07 PM
	 * @param key
	 */
	private void takeNode(T key) {
		System.out.print(key + " ");
	}

	/**
	 * 前序遍历
	 * 
	 * @timestamp Mar 5, 2016 2:48:44 PM
	 * @param node
	 */
	private void preOrder(BSTNode<T> node) {
		if (node != null) {
			takeNode(node.key);
			preOrder(node.left);
			preOrder(node.right);
		}
	}

	protected void preOrder() {
		preOrder(aRoot);
	}

	/**
	 * 中序遍历
	 * 
	 * @timestamp Mar 5, 2016 2:48:52 PM
	 * @param node
	 */
	private void inOrder(BSTNode<T> node) {
		if (node != null) {
			inOrder(node.left);
			takeNode(node.key);
			inOrder(node.right);
		}
	}

	protected void inOrder() {
		inOrder(aRoot);
	}

	/**
	 * 后续遍历
	 * 
	 * @timestamp Mar 5, 2016 2:51:19 PM
	 * @param node
	 */
	private void postOrder(BSTNode<T> node) {
		if (node != null) {
			postOrder(node.left);
			postOrder(node.right);
			takeNode(node.key);
		}
	}

	protected void postOrder() {
		postOrder(aRoot);
	}
}

 实现：

public class BSTree extends BSATree<String> {

	@Override
	public void createBSTree() {
		aRoot = new BSTNode<String>("A", null);
		BSTNode<String> bNode = new BSTNode<String>("B", aRoot);
		BSTNode<String> cNode = new BSTNode<String>("C", aRoot);
		BSTNode<String> dNode = new BSTNode<String>("D", bNode);
		BSTNode<String> eNode = new BSTNode<String>("E", bNode);
		BSTNode<String> fNode = new BSTNode<String>("F", cNode);
		BSTNode<String> gNode = new BSTNode<String>("G", cNode);
		BSTNode<String> hNode = new BSTNode<String>("H", dNode);
		BSTNode<String> iNode = new BSTNode<String>("I", dNode);
		BSTNode<String> jNode = new BSTNode<String>("J", eNode);
		BSTNode<String> kNode = new BSTNode<String>("K", fNode);
		aRoot.left = bNode;
		aRoot.right = cNode;
		bNode.left = dNode;
		bNode.right = eNode;
		cNode.left = fNode;
		cNode.right = gNode;
		dNode.left = hNode;
		dNode.right = iNode;
		eNode.right = jNode;
		fNode.right = kNode;
	}

	public static void main(String[] args) {
		BSTree b = new BSTree();
		b.createBSTree();
		System.out.println("********************** 前序遍历 **********************");
		b.preOrder();
		System.out.println();
		System.out.println("********************** 中序遍历 **********************");
		b.inOrder();
		System.out.println();
		System.out.println("********************** 后序遍历 **********************");
		b.postOrder();
		System.out.println();
	}
}

 输出：

********************** 前序遍历 **********************
A B D H I E J C F K G 
********************** 中序遍历 **********************
H D I B E J A F K C G 
********************** 后序遍历 **********************
H I D J E B K F G C A 

 前序遍历：

 

 中序遍历：

 

 后序遍历：