Binary Tree Preorder Traversal & Binary Tree Inorder Traversal & Binary Tree Postorder Traversal

这一篇补充下leetcode上的二叉树的三种遍历的迭代实现。基本上是参照往上的来的。写的比较清晰 链接：https://segmentfault.com/a/1190000003532763 

自己都实现了一遍。这种基础的算法还是要牢固一些。

第一题前序遍历：

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].

思路是使用一个栈，先访问父节点，如果右孩子存在，把右孩子压入栈，如果左孩子存在，那么左孩子压入栈。因为栈是先进后出，所以先右孩子再左孩子。

代码：

 public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> result = new ArrayList<>();
        
        if(root != null) stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.right!= null) stack.push(node.right);//先进后出
            if(node.left!= null) stack.push(node.left);
        }
        return result;
    }

中序遍历：

Given a binary tree, return the inorder traversal of its nodes' values.

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

   1
    \
     2
    /
   3

这道题的思路是首先一路沿着左边依次压入栈。弹栈的时候，如果当前这个点存在右孩子，那么把这个点的右孩子以及右孩子的左边的节点都加入到栈。

代码：

public List<Integer> inorderTraversal(TreeNode root) {
         List<Integer> res = new LinkedList<Integer>();
         Stack<TreeNode> stack = new Stack<>();
         
         if(root != null){
             pushAllLeft(stack, root);
         }
         
         while(!stack.isEmpty()){
             TreeNode node = stack.pop();
             res.add(node.val);
             if(node.right != null){
                 pushAllLeft(stack, node.right);
             }
         }
         return res;
    }
    
    private void pushAllLeft(Stack<TreeNode> s, TreeNode  root){
        s.push(root);
        while(root.left != null){
            root = root.left;
            s.push(root);
        }
    }

后序遍历

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. 因为在迭代实现的时候，第一次访问根节点是不能够把根节点加入到结果集的，因为要把左右孩子全部访问到。所以需要封装一个新的类，包含一个boolean值，表示是与否已经访问过了。当为 true的时候，说明已经把它的左右节点都加入到stack里了，这个时候就可以把当前节点加入到结果集了。如果不加这个boolean值进行判断，那么当第二次访问到根节点的时候，你不知道跟节点的左右孩子是否已经访问过了，所以这个boolean是必须的。

2. 后续遍历的逆序。逆序的话就相对简单。先访问根节点，然后右孩子，再是左孩子。保存的结果使用linkedlist，这样每次插入都在头插入就可以了。

//    public List<Integer> postorderTraversal(TreeNode root) {
//        Stack<NTreeNode> stack = new Stack<>();
//        List<Integer> result = new ArrayList<>();
//        if(root != null){
//            stack.push(new NTreeNode(root, false));
//        }
//        while(!stack.isEmpty()){
//            NTreeNode node = stack.peek();
//            if(node.visited){
//                result.add(node.node.val);
//                stack.pop();
//            }else{
//                if(node.node.right != null) stack.push(new NTreeNode( node.node.right, false));
//                if(node.node.left != null) stack.push(new NTreeNode( node.node.left, false));
//                node.visited = true;
//            }
//        }
//        return result;
//    }

    
//    public List<Integer> postorderTraversal(TreeNode root) {
//        Stack<TreeNode> stack = new Stack<>();
//        List<Integer> result = new LinkedList<>();
//
//        if(root != null) stack.push(root);
//        while(!stack.isEmpty()){
//            TreeNode node = stack.pop();
//            if(node.left != null) stack.push(node.left);
//            if(node.right != null) stack.push(node.right);
//            result.add(0, node.val);
//        }
//        return result;
//    }

代码：