二叉樹的前序、中序、後序遍歷:

遞迴實現：不同順序改變遞迴就行。

前序：        

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        
        List<Integer> list = new ArrayList<Integer>();
        if(root == null){
            return list; 
        }else{
            list.add(root.val);
            list.addAll(preorderTraversal(root.left));
            list.addAll(preorderTraversal(root.right));
            
        }
        return list;
       }
}            
 

非遞迴實現：即用棧模擬系統遞迴的實現，為了更方便理解，將節點資訊封裝一下，這樣完全模擬系統遞迴了，其他順序也只需要像遞迴實現一樣改變順序就好了。這裡不同與書本的每種順序各有個的非遞迴實現。

//非遞迴遍歷二叉樹，用stack模擬系統棧，根據遞迴思路實現，前中後一樣。
public class L144BTreeTravesal {

	public  static List<Integer> preorderTraversal(TreeNode root) {		
		List<Integer> list = new ArrayList<Integer>();
		Stack<Command> stack = new Stack<Command>();
		if(root == null){
			return list;
		}
		stack.push(new Command(false, root));
		while(!stack.isEmpty()){
			
			Command curr = stack.pop();
			if(curr.isOut){
				list.add(curr.node.val);
			}else{
				if(curr.node.right != null){
					stack.push(new Command(false,curr.node.right));
				}
				if(curr.node.left != null){
					stack.push(new Command(false,curr.node.left));
				}
				stack.push(new Command(true, curr.node));
			}
		}	
		return list;
	}
}

class Command{
	boolean isOut;
	TreeNode node;
	public Command(boolean isOut, TreeNode node) {
		this.isOut = isOut;
		this.node = node;
	}
}

 

 非遞迴中序遍歷：

 public static List<Integer> solution(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        if (root == null) {
            return list;
        }
        TreeNode p = root;
        Stack stack = new Stack();
        stack.push(p);
        p = p.left;
        while (!stack.isEmpty()) {
            while (p != null) {
                stack.push(p);
                p = p.left;
            }
            if (!stack.isEmpty()) {
                TreeNode temp = (TreeNode) stack.pop();
                list.add(temp.val);
                p = temp.right;
            } else {
                return list;
            }

        }
        return list;
    }
 

非遞迴後序遍歷:

  public static List<Integer> solution(TreeNode root){
        Stack<TreeNode> stack = new Stack();
        Stack<TreeNode> outPut = new Stack();
        List<Integer> list =  new ArrayList<Integer>();
        if (root == null) {
            return list;
        }
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode p = stack.pop();
            outPut.push(p);
            if(p.left != null){
                stack.push(p.left);
            }
            if(p.right != null){
                stack.push(p.right);
            }
        }
        while (!outPut.isEmpty() ) {
            list.add(outPut.pop().val);
        }
        return list;
    }