分別採用迭代和棧的方式對二叉樹進行遍歷。

import java.util.LinkedList;

public class MyTree {
    enum Order{
        PREORDER, INORDER, POSTORDER;
    }

    private class Node{
        Integer self;
        Node left;
        Node right;
        int hashCode;
        public Node(Integer i) {
            self = i;
            hashCode = i.intValue();
        }

        public Node(String s) {
            self = new Integer(s);
            hashCode = self.intValue();
        }

        public Node(int i) {
            self = new Integer(i);
            hashCode = self.intValue();
        }

        @Override
        public int hashCode() {
            return hashCode;
        }
    }

    private Node root;
    private int size=0;

    public static void main(String[] args) {
        MyTree tree = new MyTree();
        tree.add(10);
        tree.add(5);
        tree.add(15);
        tree.add(7);
        tree.add(6);
        tree.add(1);
        tree.add(11);
        tree.add(20);
        tree.add(14);
        tree.add(16);
        tree.traversal();

    }

    public void add(int i){
        doAddtoTree(new Node(i));
    }

    public void add(String s){
        doAddtoTree(new Node(s));
    }

    public void add(Integer i){
       doAddtoTree(new Node(i));
       size++;
    }
    
    public int size() {
    	return size;
    }

    public void traversal(){
        doTraversalPreOrder();
        doTraversalMidOrder();
        doTraversalPostOrder();
    }

    private void doAddtoTree(Node node){
        boolean bFound = false;
        Node curNode = root;

        if(addToRoot(node)) return;

        while(!bFound){
            if(curNode.hashCode() > node.hashCode()){
                if (curNode.left != null){
                    curNode = curNode.left;
                }else{
                    curNode.left = node;
                    bFound = true;
                }
            }else if(curNode.hashCode() < node.hashCode()){
                if (curNode.right != null){
                    curNode = curNode.right;
                }else {
                    curNode.right = node;
                    bFound = true;
                }
            }else {
                curNode.self = node.self;
                bFound = true;
            }
        }

    }

    private boolean addToRoot(Node node){
        if (root == null){
            root = node;
            return true;
        }else
            return false;
    }

    private void doTraversalPreOrder(){
        doRecursion(root, Order.PREORDER);
        System.out.println();
        doPreInStack(root, true);
        System.out.println();
    }

    private void doTraversalMidOrder(){
        doRecursion(root, Order.INORDER);
        System.out.println();
        doPreInStack(root, false);
        System.out.println();
    }

    private void doTraversalPostOrder(){
        doRecursion(root, Order.POSTORDER);
        System.out.println();
        doPostStack(root);
        System.out.println();
    }

    /*
        迭代遍歷。前序(PreOrder)：先自己（print），再找左子樹（有則迭代），無則再找右子樹（有則迭代，無則返回）
        中序（InOrder）：先找左子樹（有則迭代），無則自己（print），再找右子樹（有則迭代，無則返回）
        後序（PostOrder）：先找左子樹（有則迭代），無則再找右子樹（有則迭代），無則自己（print）
     */
    private void doRecursion(Node tree, Order ord){
        if (ord == Order.PREORDER) print(tree.self);

        if (tree.left != null){
            doRecursion(tree.left, ord);
        }

        if (ord == Order.INORDER) print(tree.self);

        if (tree.right != null){
            doRecursion(tree.right, ord);
        }
        
        if (ord == Order.POSTORDER) print(tree.self);
    }

    private void doPreInStack(Node tree, boolean bPre){
        LinkedList<Node> stack = new LinkedList<>();

        while((tree != null) || (!stack.isEmpty())){
            while(tree != null){
                stack.push(tree);
                if (bPre) print(tree.self);
                tree = tree.left;
            }

            while((tree==null) && (!stack.isEmpty())){
                tree = stack.pop();
                if (!bPre)print(tree.self);
                tree = tree.right;
            }
        }
    }
    /*
     * 使用棧後序遍歷：
     * 1、根壓棧
     * 2、如果有左孩子，左孩子入棧，如果有右孩子，右孩子入棧，迴圈直到葉子（左右孩子都沒有）
     * 3、葉子出棧（並訪問自己），訪問棧頂（這個葉子的父結點）的右孩子。
     * 3.1、如果有右孩子，重複2~3.
     * 3.2、如果沒有右孩子，繼續出棧。
     * 4、後序遍歷到根節點時棧為空，應結束
     */
    private void doPostStack(Node tree) {
    	Node root = tree;
    	LinkedList<Node> stack = new LinkedList<>();
    	
    	while((tree!=null) || (!stack.isEmpty())) {
    		while(tree!=null) {
    			stack.push(tree);
    			if(tree.left!=null) {
    				tree = tree.left;
    			}else {
    				tree = tree.right;
    			}
    		}
    		while((!stack.isEmpty()) && tree == stack.peek().right) {
    			tree = stack.pop();
    			print(tree.self);
    		}
    		if(!stack.isEmpty()) {
    			tree = stack.peek().right;
    		}else {
    			tree = null;
    		}
    		
    	}
    }

    private void print(Integer i){
        System.out.print(i+" ");
    }
}
 

前序：10 5 1 7 6 15 11 14 20 16
中序：1 5 6 7 10 11 14 15 16 20
後序：1 6 7 5 14 11 16 20 15 10