[LeetCode-Tree]Binary Tree Inorder & Preorder Traversal

Binary Tree Inorder Traversal
Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree [1,null,2,3],
1

\
 2
/

3
return [1,3,2].

1.解题思路

这里我们选用迭代来解题，借用压栈出栈来实现。
1）中序遍历，左节点，根，右节点，所以每次遇到root节点，我们就将其压入栈中，然后在判断它有没有左节点，有的话也压入栈中，直到树的最左边的叶子节点，第一步就结束了；
2）现在我们开始出栈，每次出栈的节点肯定不会再有左孩子了，但我们需要判断它是否有右孩子，如果有，我们要针对右节点再做step1的操作。

2.代码

public class Solution {
    Stack<TreeNode> s=new Stack<TreeNode>();
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res =new ArrayList<Integer>();
        if(root==null) return res;
        pushLeft(root);
        while(!s.empty()){
            TreeNode pnode=s.pop();
            res.add(pnode.val);
            if(pnode.right!=null){
                pushLeft(pnode.right);
            }
        }
        return res;
    }
    private void pushLeft(TreeNode root){
        TreeNode node=root.left;
        s.push(root);
        while(node!=null){
            s.push(node);
            node=node.left;
        }
    }
}

Binary Tree Preorder Traversal
Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},
   1
    \
     2
    /
   3
return [1,2,3].

Note: Recursive solution is trivial, could you do it iteratively?

1.解题思路

先序遍历，同样用迭代实现，借助栈。
1） 先将根节点入栈
2）先序遍历，所以直接Pop出根节点
3）因为顺序是根，左节点，右节点，所以我们在压栈的时候要先压右节点，再压左节点。

public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<Integer>();
        if(root==null) return res;
        Stack<TreeNode> s=new Stack<TreeNode>();
        s.push(root);
        while(!s.empty()){
            TreeNode node=s.pop();
            res.add(node.val);
            if(node.right!=null)
                s.push(node.right);
            if(node.left!=null)
                s.push(node.left);
        }
        return res;
    }
}

Binary Tree Postorder Traversal
Given a binary tree, return the postorder traversal of its nodes' values.

For example:

Given binary tree {1,#,2,3},
   1
    \
     2
    /
   3

return [3,2,1].

1.解题思路
后序遍历，本题比前两题稍微复杂一点，因为后序遍历，必然根节点会被访问到两次，一次是入栈，并访问其左节点，但还要考虑其是否有右节点，如果有右节点必须先输出右节点，所以我们不能马上将根节点立即出栈。
所以我们自定义了一个类，添加了isVisited的属性，来表明该节点是否已经被访问过了。

2.代码

public class Solution {
    Stack<DefinedTreeNode> s=new Stack<DefinedTreeNode>();
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<Integer>();
        if(root==null) return res;
        
        pushLeft(new DefinedTreeNode(root,false));
        while(!s.empty()){
            DefinedTreeNode dt=s.peek();
            if(dt.node.right==null||dt.isVisited){
                s.pop();
                res.add(dt.node.val);
            }
            else{
                dt.isVisited=true;
                pushLeft(new DefinedTreeNode(dt.node.right,false));
            }
            
            
        }
        return res;
    }
    private void pushLeft(DefinedTreeNode root){
        s.push(root);
        DefinedTreeNode dt=new DefinedTreeNode(root.node.left,false);
        while(dt.node!=null){
            s.push(dt);
            dt=new DefinedTreeNode(dt.node.left,false);
        }
    }
    class DefinedTreeNode {
        TreeNode node;
        boolean isVisited;
        DefinedTreeNode(TreeNode node, boolean isVisited){
            this.node=node;
            this.isVisited=isVisited;
        }
    }
}