后序遍历二叉树

Author: DmrfCoder

LeetCode/Doc/使用插入排序对链表进行排序.md

@@ -1,6 +1,6 @@
 # insertion-sort-list(使用插入排序对链表进行排序)
 
-<center>知识点：</center>
+<center>知识点：排序，链表</center>
 
 
 ## 题目描述

LeetCode/Doc/后序遍历二叉树.md

@@ -0,0 +1,59 @@
+# binary-tree-postorder-traversal（后序遍历二叉树）
+
+<center>知识点：树</center>
+
+
+## 题目描述
+
+Given a binary tree, return the postorder traversal of its nodes' values.
+
+For example:
+Given binary tree{1,#,2,3},
+
+![image-20190413113855000](https://ws2.sinaimg.cn/large/006tNc79gy1g20usuv6s0j308y0860so.jpg)
+
+return[3,2,1].
+
+**Note:** Recursive solution is trivial, could you do it iteratively?
+
+给定一个二叉树，返回其后序遍历结果。
+
+提示：递归解决方案是不值一提的，你选择迭代。
+
+
+## 解题思路
+
+首先明确什么是后序遍历：对于二叉树访问顺序为左-右-根，即为后序遍历。
+
+递归方式很简单，这里说一下迭代的思路，考虑如下二叉树：
+
+![image-20190413125303689](https://ws1.sinaimg.cn/large/006tNc79gy1g20wxyvib7j30n80ggmyz.jpg)
+
+使用栈来解决非递归的后序遍历实现，重点在于以何种顺序入栈，由于是出栈的时候去遍历，所以按照后序遍历的顺序推导出入栈顺序应该是curNode、curNode.right、curNode.left，这样出栈的时候就能保证按照后序遍历的顺序了，另外需要使用一个preNode保存前一个遍历的节点，这样就能确定前一个被遍历的节点是否是当前节点的左/右子节点，如果是，说明其儿子已经被遍历了，这时就可以遍历自己了，否则不能遍历当前节点，需要先将当前节点的子节点入栈，最后的逻辑是：
+
+```
+初始：curNode=null，preNode=null，stack=new Stack()，stack.push(root)
+while(stack不为空)：
+		if curNode==null:
+				curNode=stack.peek()
+		if curNode 是叶子节点：
+				print curNode.val
+				preNode=curNode
+				stack.pop()
+				curNode=null
+		else if preNode是curNode的直接子节点：
+				print curNode.val
+				preNode=curNode
+				stack.pop()
+				curNode=null
+		else：
+				stack.push(curNode.right)
+				stack.push(curNode.left)
+				curNode=curNode.left
+```
+
+
+
+## 代码
+
+[这里](../src/n/Solution.java)

LeetCode/out/production/LeetCode/six/Solution.class

@@ -0,0 +1,88 @@
+package six;
+
+import java.util.ArrayList;
+import java.util.Stack;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}
+
+public class Solution {
+    public ArrayList<Integer> postorderTraversal(TreeNode root) {
+        Stack<TreeNode> treeNodeStack = new Stack<>();
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        if (root == null) {
+            return arrayList;
+        }
+
+        TreeNode preNode = null;
+        TreeNode curNode = null;
+
+        treeNodeStack.push(root);
+
+        while (!treeNodeStack.isEmpty()) {
+            if (curNode == null) {
+                curNode = treeNodeStack.peek();
+
+            }
+
+            if (curNode.left == null && curNode.right == null) {
+                preNode = curNode;
+                arrayList.add(curNode.val);
+                treeNodeStack.pop();
+                curNode = null;
+            } else if ((preNode == curNode.left && curNode.left != null) || (preNode == curNode.right && curNode.right != null)) {
+                preNode = curNode;
+                arrayList.add(curNode.val);
+                treeNodeStack.pop();
+                curNode = null;
+            } else {
+                if (curNode.right != null) {
+                    treeNodeStack.push(curNode.right);
+                }
+
+                if (curNode.left != null) {
+                    treeNodeStack.push(curNode.left);
+                }
+                curNode = curNode.left;
+            }
+
+
+        }
+        return arrayList;
+    }
+
+    public static void main(String args[]) {
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(3);
+        TreeNode node4 = new TreeNode(4);
+        TreeNode node5 = new TreeNode(5);
+        TreeNode node6 = new TreeNode(6);
+        TreeNode node7 = new TreeNode(7);
+
+        root.left = node2;
+//        root.right = node3;
+//        node2.left = node4;
+//        node2.right = node5;
+//        node3.left = node6;
+//        node3.right = node7;
+
+        Solution solution = new Solution();
+        ArrayList<Integer> arrayList = solution.postorderTraversal(root);
+        System.out.println(arrayList.toArray().toString());
+
+    }
+}

LeetCode/out/production/LeetCode/six/TreeNode.class

@@ -147,4 +147,5 @@
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
 - [sort-list(排序List)](./LeetCode/Doc/排序List.md)
 - [insertion-sort-list(使用插入排序对链表进行排序)](./LeetCode/Doc/使用插入排序对链表进行排序.md)
+- [binary-tree-postorder-traversal（后序遍历二叉树）](./LeetCode/Doc/后序遍历二叉树.md)