二叉樹的常用遍歷演算法有前序，中序，後序三種遍歷方法，可用遞迴及非遞迴方法實現，程式碼如下：

public class BSTTraversal {

	public static class Node{
		private int value;
		private Node leftNode;
		private Node rightNode;
		public Node(int value, Node leftNode, Node rightNode){
			this.value = value;
			this.leftNode = leftNode;
			this.rightNode = rightNode;
		}
	}
	
	//遞迴先序遍歷
	public void preOrder(Node node){
		if(node==null) return;
		printNode(node);
		if(node.leftNode!=null) preOrder(node.leftNode);
		if(node.rightNode!=null) preOrder(node.rightNode);
	}
	
	//遞迴中序遍歷
	public void inOrder(Node node){
		if(node==null) return;
		if(node.leftNode!=null) inOrder(node.leftNode);
		printNode(node);
		if(node.rightNode!=null) inOrder(node.rightNode);
	}
	
	//遞迴後序遍歷
	public void postOrder(Node node){
		if(node==null) return;
		if(node.leftNode!=null) postOrder(node.leftNode);		
		if(node.rightNode!=null) postOrder(node.rightNode);
		printNode(node);
	}
	
	//非遞迴先序遍歷
	public void preOrderNoRecursion(Node node){
		if(node==null) return;
		Stack<Node> stack = new Stack<Node>();
		stack.push(node);
		while(!stack.isEmpty()){
			Node t = stack.pop();
			printNode(t);
			if(t.rightNode!=null) stack.push(t.rightNode);
			if(t.leftNode!=null) stack.push(t.leftNode);			
		}
	}
	
	//非遞迴中序遍歷
	public void inOrderNoRecursion(Node node){
		if(node==null) return;
		Stack<Node> stack = new Stack<Node>();
		Node p = node;
		while(p!=null||!stack.isEmpty()){
			if(p!=null){
				stack.push(p);
				p = p.leftNode;
			}else{
				p = stack.pop();
				printNode(p);
				p = p.rightNode;
			}
		}
	}
	
	//非遞迴後序遍歷
	public void postOrderNoRecursion(Node node){
		if(node==null) return;
		Stack<Node> stack = new Stack<Node>();
		//這裡flag來標記是棧頂出棧或者左孩子進棧
		boolean flag = true;
		Node p = node;
		//這裡pre來記錄最近出棧的節點（用於判斷pre是否是p的右孩子，如果是，才可訪問p節點）
		Node pre = p;
		while(p!=null||!stack.isEmpty()){
			if(p!=null&&flag){
				stack.push(p);
				p = p.leftNode;
			}else{
				if(stack.isEmpty()) return;
				p = stack.peek();
				if(p.rightNode!=null&&p.rightNode!=pre){
					p = p.rightNode;
					flag = true;
				}else{
					p = stack.pop();
					printNode(p);
					flag = false;
					pre = p;
				}
			}
		}
	}
	
	private void printNode(Node node) {
		System.out.print(node.value+" ");
	}

	public static void main(String[] args) {
		Node node1 = new Node(4,null,null);
		Node node2 = new Node(8,null,null);
		Node node3 = new Node(12,null,null);
		Node node4 = new Node(16,null,null);
		Node node5 = new Node(6,node1,node2);
		Node node6 = new Node(14,node3,node4);
		Node node7 = new Node(10,node5,node6);
		BSTTraversal bst = new BSTTraversal();
		System.out.print("先序遞迴:");bst.preOrder(node7);
		System.out.print("先序非遞迴:");bst.preOrderNoRecursion(node7);
		System.out.print("中序遞迴:");bst.inOrder(node7);
		System.out.print("中序非遞迴:");bst.inOrderNoRecursion(node7);
		System.out.print("後序遞迴:");bst.postOrder(node7);
		System.out.print("後序非遞迴:");bst.postOrderNoRecursion(node7);
	}

}