[Algorithm]九章必背程序--stack：Non Recursion

66. Binary Tree Preorder Traversal ：点击打开链接

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Preorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> preorderTraversal(TreeNode root) { //前序：根-左-右
        ArrayList<Integer> result=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        
        if(root==null){
            return result;
        }
        
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();
            result.add(cur.val);
            
            if(cur.right!=null){                                 //一定要先右再左的判断，因为pop的时候要先pop左
                stack.push(cur.right);
            }
            if(cur.left!=null){
                stack.push(cur.left);
            }
            
        }
        return result;
    }   
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {                                            //Divide and Conquer
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        
        List<Integer> leftTree=preorderTraversal(root.left);       //Divide
        List<Integer> rightTree=preorderTraversal(root.right);
        
        result.add(root.val);                                      //Conquer
        result.addAll(leftTree);
        result.addAll(rightTree);
        return result;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {                                           //traverse
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result=new ArrayList<>();
        traverse(root,result);
        return result;
    }
    
    private void traverse(TreeNode root,List<Integer> result){
        if(root==null){
            return;
        }
        result.add(root.val);
        traverse(root.left, result);
        traverse(root.right, result);
    }
}

67.Binary Tree Inorder Traversal：点击打开链接

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Inorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> inorderTraversal(TreeNode root) { //中序：左-根-右
        ArrayList<Integer> result=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        
        if(root==null){
            return result;
        }
        
        TreeNode cur=root;
        while(cur!=null || !stack.isEmpty()){
            while(cur!=null){                                   //里层while只管左和根
                stack.push(cur);
                cur=cur.left;
            }
            
            cur=stack.pop();
            result.add(cur.val);
            cur=cur.right;                                      //然后再管右
        }
        return result;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result=new ArrayList<>();
        traverse(root,result);
        return result;        
    }
    
    private void traverse(TreeNode root,List<Integer> result){
        if(root==null){
            return;
        }
        traverse(root.left,result);
        result.add(root.val);
        traverse(root.right,result);       
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        
        List<Integer> left=inorderTraversal(root.left);
        List<Integer> right=inorderTraversal(root.right);
        result.addAll(left);
        result.add(root.val);
        result.addAll(right);
        return result;
    }
}

68. Binary Tree Postorder Traversal: 点击打开链接

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {    //后序：左-右-根
        LinkedList<Integer> result = new LinkedList<>();        //如果给的是List,可以用LinkedList接口
        Stack<TreeNode> stack = new Stack<>();
    	if(root == null){
    		return result;
    	}
    	
    	TreeNode cur=root;
    	while(cur != null || !stack.empty()){
    		while(cur != null){                             //虽然里层while里只管根和右，但是要往头位置add，因此左会在最前
    			stack.push(cur);                            //stack里push进去的和result里addFirst的同步
    			result.addFirst(cur.val);                   //就可以使用addFirst方法
    			cur = cur.right;
    		}
    		cur = stack.pop();
    		cur = cur.left;
    	}
    	
    	return result;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        
        List<Integer> left=postorderTraversal(root.left);
        List<Integer> right=postorderTraversal(root.right);
        
        result.addAll(left);
        result.addAll(right);
        result.add(root.val);
        return result;
    }
}

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Postorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result=new ArrayList<>();
        traverse(root,result);
        return result;
    }
    
    private void traverse(TreeNode root,ArrayList<Integer> result){
        if(root==null){
            return;
        }
        
        traverse(root.left,result);
        traverse(root.right,result);
        result.add(root.val);
    }
}

Binary Search Tree Iterator:  点击打开链接

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 * Example of iterate a tree:
 * BSTIterator iterator = new BSTIterator(root);
 * while (iterator.hasNext()) {
 *    TreeNode node = iterator.next();
 *    do something for node
 * } 
 */
public class BSTIterator {                                     //其实就是inorder的拆开形式
    Stack<TreeNode> stack;
    //@param root: The root of binary tree.
    public BSTIterator(TreeNode root) {
        stack=new Stack<>();
        AddNodeToStack(root);
    }

    //@return: True if there has next node, or false
    public boolean hasNext() {
        return !stack.isEmpty();
    }
    
    //@return: return next node
    public TreeNode next() {
        TreeNode cur=stack.pop();
        AddNodeToStack(cur.right);
        return cur;
    }
    
    private void AddNodeToStack(TreeNode root){
        while(root!=null){
            stack.push(root);
            root=root.left;
        }
    }
    
}