145.Binary Tree Postorder Traversal---二叉树后序非递归遍历

题目链接

题目大意：后序遍历二叉树。

法一：普通递归，只是这里需要传入一个list来存储遍历结果。代码如下（耗时1ms）：

     public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<Integer>();
         list = dfs(root, list);
         return list;
     }
     public static List<Integer> dfs(TreeNode root, List<Integer> list) {
         if(root == null) {
             return list;
         }
         else {
             list = dfs(root.left, list);
             list = dfs(root.right, list);
             list.add(root.val);
             return list;
         }
     }

法二（借鉴）：后序遍历顺序是“左右根”，这里将其反过来遍历，也就是“根右左”，然后将遍历结果反转返回即可。这里用到了LinkedList.addFirst()方法，即将值插到链表头部。（addLast()方法与add()方法一样是插到链表尾部）。这里也可以用ArrayList.add()，在最后再调用Collections.reverse(list)方法即可。此方法代码简单，但不是很好想。代码如下（耗时1ms）：

     public List<Integer> postorderTraversal(TreeNode root) {
         LinkedList<Integer> list = new LinkedList<Integer>();
         if(root == null) {
             return list;
         }
         Stack<TreeNode> stack = new Stack<TreeNode>();
         stack.push(root);
         TreeNode tmp = null;
         while(!stack.isEmpty()) {
             tmp = stack.pop();
             list.addFirst(tmp.val);
             if(tmp.left != null) {
                 stack.push(tmp.left);
             }
             if(tmp.right != null) {
                 stack.push(tmp.right);
             }
         }
         return list;
     }

法三（借鉴）：普通后序非递归遍历，这里用一个辅助栈来标记结点是否已经访问右结点，如果已经访问右结点，则将根值加入list中，否则访问右结点压栈。因为有两个栈要压栈出栈，耗时较长。也可以在TreeNode结点中加入一个标记属性flag来标记是否访问过右结点，这样就不需要辅助栈了，时间应该会快一些。代码如下（耗时2ms）：

     public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<Integer>();
         if(root == null) {
             return list;
         }
         Stack<TreeNode> stackNode = new Stack<TreeNode>();
         //0表示右结点未访问，1表示右结点已访问
         Stack<Integer> stackFlag = new Stack<Integer>();
         stackNode.push(root);
         stackFlag.push(0);
         TreeNode tmp = root.left;//已压栈，则访问其左结点
         while(!stackNode.isEmpty()) {
             while(tmp != null) {
                 stackNode.push(tmp);
                 stackFlag.push(0);
                 tmp = tmp.left;
             }
             if(stackFlag.peek() == 0) {
                 //右结点未访问，则访问右结点
                 tmp = stackNode.peek().right;
                 stackFlag.pop();
                 stackFlag.push(1);//将访问右结点状态置1
             }
             else {
                 //右结点已访问，则将根结点加入list队列，并将根节点弹出
                 list.add(stackNode.pop().val);
                 stackFlag.pop();//弹出根节点状态值
             }
         }
         return list;
     }

法四（借鉴）：保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存 在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了 每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。这个比法二还要难理解，特别是要先压right再压left。代码如下（耗时2ms）：

     public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<Integer>();
         if(root == null) {
             return list;
         }
         Stack<TreeNode> stack = new Stack<TreeNode>();
         stack.push(root);
         TreeNode pre = null, cur = null;
         while(!stack.isEmpty()) {
             cur = stack.peek();//判断当前结点情况，所以用peek不用pop
             if((cur.left == null && cur.right == null) ||
                 (pre != null && (pre == cur.left || pre == cur.right))) {
                 //如果当前结点没有左右孩子则直接弹出当前结点
                 //如果当前结点的左右孩子都已经访问完则弹出当前结点
                 list.add(cur.val);
                 pre = cur;
                 stack.pop();
             }
             else {
                 //注意这里一定要先压right再压left，因为栈的先进后出的原则，到时候会先弹出left再弹出right，这样的顺序才正确。
                 if(cur.right != null) {
                     stack.push(cur.right);
                 }
                 if(cur.left != null) {
                     stack.push(cur.left);
                 }
             }
         }
         return list;
     }

法五（借鉴）：最接近先序、中序非递归遍历的方法，先压左结点再判断栈顶元素。代码如下（耗时2ms）：

 public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<Integer>();
         if(root == null) {
             return list;
         }
         Stack<TreeNode> stack = new Stack<TreeNode>();
         stack.push(root);
         TreeNode pre = null, cur = root.left;
         while(!stack.isEmpty()) {
             while(cur != null) {
                 stack.push(cur);
                 cur = cur.left;
             }
             //判断栈顶结点
             cur = stack.peek();
             //判断是否访问栈顶结点
             if(cur.right != null && pre != cur.right) {
                 //如果不是从右孩子返回，即还未访问右孩子，则访问
                 cur = cur.right;
             }
             else {
                 //如果没有右孩子或右孩子已经访问过，则直接弹出当前节点进行访问
                 list.add(cur.val);
                 stack.pop();
                 //记录当前访问的结点
                 pre = cur;
                 //将当前结点赋空
                 cur = null;
             }
         }
         return list;
     }