Binary Tree Postorder Traversal

Author: int32bit

README.md

@@ -41,7 +41,9 @@
 + [98 Validate Binary Search Tree(BST, 中序遍历)](algorithms/ValidateBinarySearchTree)
 + [100 Same Tree(相同树，遍历)](algorithms/SameTree)
 + [101 Symmetric Tree(对称树)](algorithms/SymmetricTree)
++ [102 Binary Tree Level Order Traversal(层次遍历)](algorithms/BinaryTreeLevelOrderTraversal)
 + [104 Maximum Depth of Binary Tree(树深度)](algorithms/MaximumDepthofBinaryTree)
++ [107 Binary Tree Level Order Traversal II(层次遍历)](algorithms/BinaryTreeLevelOrderTraversal2)
 + [110 Balanced Binary Tree(平衡树)](algorithms/BalancedBinaryTree)
 + [111 Minimum Depth of Binary Tree](algorithms/MinimumDepthofBinaryTree)
 + [112 Path Sum(前序遍历)](algorithms/PathSum)
@@ -53,6 +55,7 @@
 + [141 Linked List Cycle(快慢指针法)](algorithms/LinkedListCycle)
 + [142 Linked List Cycle II](algorithms/LinkedListCycle2)
 + [144 Binary Tree Preorder Traversal(迭代法前序遍历](algorithms/BinaryTreePreorderTraversal)
++ [145 Binary Tree Postorder Traversal(后序遍历)](algorithms/BinaryTreePostorderTraversal)
 + [146 LRU Cache(空间换时间)](algorithms/LRUCache)
 + [147 Insertion Sort List(链表操作，插入排序)](algorithms/InsertionSortList)
 + [150 Evaluate Reverse Polish Notation(栈的应用)](algorithms/EvaluateReversePolishNotation)

algorithms/BinaryTreeLevelOrderTraversal/README.md

@@ -0,0 +1,56 @@
+## Binary Tree Level Order Traversal
+
+Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+
+For example:
+Given binary tree `{3,9,20,#,#,15,7}`,
+```
+    3
+   / \
+  9  20
+    /  \
+   15   7
+```
+return its level order traversal as:
+```
+[
+  [3],
+  [9,20],
+  [15,7]
+]
+```
+confused what "`{1,#,2,3}`" means? > read more on how binary tree is serialized on OJ.
+
+## Solution
+
+
+层次遍历，使用队列。
+
+需要保存层次，因此封装了一个桶用于保存处于的层次
+```cpp
+vector<vector<int>> levelOrder(TreeNode *root) {
+	vector<vector<int>> result;
+	if (root == nullptr)
+		return result;
+	queue<Bucket> q;
+	result.push_back(vector<int>());
+	int curLevel = 0;
+	q.push(Bucket(root, 0));
+	while (!q.empty()) {
+		Bucket bucket = q.front();
+		q.pop();
+		TreeNode *p = bucket.node;
+		int level = bucket.level;
+		if (level != curLevel) {
+			result.push_back(vector<int>());
+			curLevel++;
+		}
+		result[curLevel].push_back(p->val);
+		if (p->left)
+			q.push(Bucket(p->left, level + 1));
+		if (p->right)
+			q.push(Bucket(p->right, level + 1));
+	}
+	return result;
+}
+```

algorithms/BinaryTreeLevelOrderTraversal/tree.cpp

@@ -0,0 +1,77 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cstdio>
+#include <queue>
+#include <stack>
+using namespace std;
+struct TreeNode {
+	int val;
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode(int x) : val(x), left(nullptr), right(nullptr){}
+};
+struct Bucket {
+	TreeNode *node;
+	int level;
+	Bucket(TreeNode *p, int l) : node(p), level(l){}
+};
+class Solution {
+public:
+	vector<vector<int>> levelOrder(TreeNode *root) {
+		vector<vector<int>> result;
+		if (root == nullptr)
+			return result;
+		queue<Bucket> q;
+		result.push_back(vector<int>());
+		int curLevel = 0;
+		q.push(Bucket(root, 0));
+		while (!q.empty()) {
+			Bucket bucket = q.front();
+			q.pop();
+			TreeNode *p = bucket.node;
+			int level = bucket.level;
+			if (level != curLevel) {
+				result.push_back(vector<int>());
+				curLevel++;
+			}
+			result[curLevel].push_back(p->val);
+			if (p->left)
+				q.push(Bucket(p->left, level + 1));
+			if (p->right)
+				q.push(Bucket(p->right, level + 1));
+		}
+		return result;
+	}
+};
+TreeNode *mk_node(int val)
+{
+	return new TreeNode(val);
+}
+TreeNode *mk_child(TreeNode *root, TreeNode *left, TreeNode *right)
+{
+	root->left = left;
+	root->right = right;
+	return root;
+}
+TreeNode *mk_child(TreeNode *root, int left, int right)
+{
+	return mk_child(root, new TreeNode(left), new TreeNode(right));
+}
+TreeNode *mk_child(int root, int left, int right)
+{
+	return mk_child(new TreeNode(root), new TreeNode(left), new TreeNode(right));
+}
+int main(int argc, char **argv)
+{
+	Solution solution;
+	TreeNode *root = mk_child(1, 2, 3);
+	mk_child(root->left, 4, 5);
+	auto results = solution.levelOrder(root);
+	for (auto result : results) {
+		for_each(result.begin(), result.end(), [](int i){cout << i << " ";});
+		cout << endl;
+	}
+	return 0;
+}

algorithms/BinaryTreeLevelOrderTraversal2/README.md

@@ -0,0 +1,55 @@
+## Binary Tree Level Order Traversal II
+
+Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+
+For example:
+Given binary tree `{3,9,20,#,#,15,7}`,
+```
+    3
+   / \
+  9  20
+    /  \
+   15   7
+```
+return its bottom-up level order traversal as:
+```
+[
+  [15,7],
+  [9,20],
+  [3]
+]
+```
+confused what "`{1,#,2,3}`" means? > read more on how binary tree is serialized on OJ.
+
+## Solution
+
+思路就是常规的BFS，然后把结果reverse ?
+
+应该还有其他更优算法？
+```cpp
+vector<vector<int>> levelOrderBottom(TreeNode *root) {
+	vector<vector<int>> result;
+	if (root == nullptr)
+		return result;
+	queue<Bucket> q;
+	result.push_back(vector<int>());
+	int curLevel = 0;
+	q.push(Bucket(root, 0));
+	while (!q.empty()) {
+		Bucket bucket = q.front();
+		q.pop();
+		TreeNode *p = bucket.node;
+		int level = bucket.level;
+		if (level != curLevel) {
+			result.push_back(vector<int>());
+			curLevel++;
+		}
+		result[curLevel].push_back(p->val);
+		if (p->left)
+			q.push(Bucket(p->left, level + 1));
+		if (p->right)
+			q.push(Bucket(p->right, level + 1));
+	}
+	reverse(result.begin(), result.end());
+}
+```

algorithms/BinaryTreeLevelOrderTraversal2/tree.cpp

@@ -0,0 +1,77 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cstdio>
+#include <queue>
+#include <stack>
+using namespace std;
+struct TreeNode {
+	int val;
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode(int x) : val(x), left(nullptr), right(nullptr){}
+};
+struct Bucket {
+	TreeNode *node;
+	int level;
+	Bucket(TreeNode *p, int l) : node(p), level(l){}
+};
+class Solution {
+public:
+	vector<vector<int>> levelOrderBottom(TreeNode *root) {
+		vector<vector<int>> result;
+		if (root == nullptr)
+			return result;
+		queue<Bucket> q;
+		result.push_back(vector<int>());
+		int curLevel = 0;
+		q.push(Bucket(root, 0));
+		while (!q.empty()) {
+			Bucket bucket = q.front();
+			q.pop();
+			TreeNode *p = bucket.node;
+			int level = bucket.level;
+			if (level != curLevel) {
+				result.push_back(vector<int>());
+				curLevel++;
+			}
+			result[curLevel].push_back(p->val);
+			if (p->left)
+				q.push(Bucket(p->left, level + 1));
+			if (p->right)
+				q.push(Bucket(p->right, level + 1));
+		}
+		reverse(result.begin(), result.end());
+	}
+};
+TreeNode *mk_node(int val)
+{
+	return new TreeNode(val);
+}
+TreeNode *mk_child(TreeNode *root, TreeNode *left, TreeNode *right)
+{
+	root->left = left;
+	root->right = right;
+	return root;
+}
+TreeNode *mk_child(TreeNode *root, int left, int right)
+{
+	return mk_child(root, new TreeNode(left), new TreeNode(right));
+}
+TreeNode *mk_child(int root, int left, int right)
+{
+	return mk_child(new TreeNode(root), new TreeNode(left), new TreeNode(right));
+}
+int main(int argc, char **argv)
+{
+	Solution solution;
+	TreeNode *root = mk_child(1, 2, 3);
+	mk_child(root->left, 4, 5);
+	auto results = solution.levelOrderBottom(root);
+	for (auto result : results) {
+		for_each(result.begin(), result.end(), [](int i){cout << i << " ";});
+		cout << endl;
+	}
+	return 0;
+}

algorithms/BinaryTreePostorderTraversal/README.md

@@ -0,0 +1,73 @@
+## 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].
+
+## Solution 1
+
+递归法, 这个方法没有什么难度
+
+## Solution 2
+
+前序遍历，然后把结果reverse
+
+## Solution 3
+
+根据后序遍历的方式，最先访问的是左孩子节点的最左的最后一个节点,比如
+
+```
+
+              1
+             / \
+            2   3
+           / \
+          5   4
+	   \   \
+            6  7
+```
+显然最先访问的是6，因此需要把之前的节点压入栈。
+```cpp
+void pushLeftOrRight(TreeNode *p, stack<TreeNode*> &s) {
+	while (p) {
+		s.push(p);
+		p = p->left != nullptr ? p->left : p->right;
+	}
+}
+```
+
+显然先是从root开始，压入的顺序依次为`1 2 5 6`
+
+然后依次出栈就是访问顺序，当出栈前需要判断是否还有右孩子没有访问
+
+比如当前已访问2(2还没有出栈)，应该开始访问右孩子, 即调用`pushLeftOrRight(p->right, s)`
+
+那怎么知道有没有访问右孩子呢？我们发现我们有两次机会会到达2，一次是访问完左孩子，一次是访问完右孩子，即访问完5和4
+
+我们可以发现，只要2出栈前，看之前访问的是否是左孩子即可，若是左孩子，说明右孩子没有访问
+```cpp
+vector<int> postorderTraversal(TreeNode *root) {
+	vector<int> result;
+	if (root == nullptr)
+		return result;
+	stack<TreeNode*>s;
+	pushLeftOrRight(root, s);
+	while (!s.empty()) {
+		TreeNode *p = getAndPop(s); // s.top(), s.pop()
+		result.push_back(p->val);
+		TreeNode *next = s.empty() ? nullptr : s.top();
+		if (next && next->left == p)
+			pushLeftOrRight(next->right, s);
+	}
+	return result;
+}
+```