Flatten Binary Tree to Linked List

Author: int32bit

Diff for: README.md

@@ -34,6 +34,7 @@
 + [111 Minimum Depth of Binary Tree](algorithms/MinimumDepthofBinaryTree)
 + [112 Path Sum(前序遍历)](algorithms/PathSum)
 + [113 Path Sum II(前序遍历)](algorithms/PathSum2)
++ [114 Flatten Binary Tree to Linked List](algorithms/FlattenBinaryTreetoLinkedList)
 + [136 Single Number(位运算)](algorithms/SingleNumber)
 + [141 Linked List Cycle(快慢指针法)](algorithms/LinkedListCycle)
 + [142 Linked List Cycle II](algorithms/LinkedListCycle2)

Diff for: algorithms/FlattenBinaryTreetoLinkedList/README.md

@@ -0,0 +1,101 @@
+## Flatten Binary Tree to Linked List
+
+Given a binary tree, flatten it to a linked list in-place.
+
+For example,
+
+Given
+```
+
+         1
+        / \
+       2   5
+      / \   \
+     3   4   6
+```
+The flattened tree should look like:
+```
+   1
+    \
+     2
+      \
+       3
+        \
+         4
+          \
+           5
+            \
+             6
+```
+Hints:
+
+If you notice carefully in the flattened tree, each node's right child points to the next node of a pre-order traversal.
+
+## Solution 1
+
+递归方法，首先flatten左子树，然后flatten右子树，此时左子树和右子树都已经是一个链表了，
+```
+            1
+           / \
+          2   5
+           \   \
+            3   6
+             \
+              4
+```
+此时只需要合并左右子树即可,即把右子树接到左子树的最右节点，即把5接到4后面，最后把右子树指向左子树即可
+
+** 处理完后，必须把左子树设为`NULL`，否则出现`RunTime ERROR` **
+
+## Code
+```cpp
+void flatten(TreeNode *root) {
+	if (root == nullptr)
+		return ;
+	flatten(root->left);
+	flatten(root->right);
+	if (root->right == nullptr) {
+		root->right = root->left;
+		root->left = nullptr; // 不能少这个，否则RE
+		return;
+	}
+	TreeNode *p = root->left;
+	if (p) {
+		while (p->right) {
+			p = p->right;
+		}
+		p->right = root->right;
+		root->right = root->left;
+	}
+	root->left = nullptr; // 不能少，否则RE
+}
+```
+
+## Solution 2
+
+使用循环，从root开始，找到root的左子树的最右节点，然后把右子树接到最右节点，右子树指向左子树，左子树设为`NULL`，然后处理右子树即可
+
+* `root == NULL`, 返回。否则`left = root->left`
+* 若`left != NULL`, 找到left的最右子树p,
+```
+p->right = root->right;
+root->right = root->left;
+root->left = NULL;
+```
+* `root = root->right`, 回到最开始。
+
+## Code
+```cpp
+void flatten(TreeNode *root) {
+	while (root) {
+		if (root->left) {
+			TreeNode *left = root->left;
+			while (left->right) left = left->right;
+			left->right = root->right;
+			root->right = root->left;
+			root->left = nullptr;
+		}
+		root = root->right;
+	}
+}
+```

Diff for: algorithms/FlattenBinaryTreetoLinkedList/solve.cpp

@@ -0,0 +1,86 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+using namespace std;
+struct TreeNode {
+	int val;
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode(int x) : val(x), left(nullptr), right(nullptr){}
+};
+class Solution {
+public:
+	void flatten(TreeNode *root) {
+		slowFlatten(root);
+	}
+private:
+	void slowFlatten(TreeNode *root) {
+		if (root == nullptr)
+			return ;
+		flatten(root->left);
+		flatten(root->right);
+		if (root->right == nullptr) {
+			root->right = root->left;
+			root->left = nullptr; // 不能少这个，否则RE
+			return;
+		}
+		TreeNode *p = root->left;
+		if (p) {
+			while (p->right) {
+				p = p->right;
+			}
+			p->right = root->right;
+			root->right = root->left;
+		}
+		root->left = nullptr;
+	}
+	void fastFlatten(TreeNode *root) {
+		while (root) {
+			if (root->left) {
+				TreeNode *left = root->left;
+				while (left->right) left = left->right;
+				left->right = root->right;
+				root->right = root->left;
+				root->left = nullptr;
+			}
+			root = root->right;
+		}
+	}
+};
+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));
+}
+void print_list(TreeNode *root)
+{
+	TreeNode *p = root;
+	while (p) {
+		cout << p->val << " ";
+		p = p->right;
+	}
+	cout << endl;
+}
+int main(int argc, char **argv)
+{
+	Solution solution;
+	TreeNode *root = mk_child(mk_node(1), nullptr, mk_node(2));
+	//mk_child(root->left, 3, 4);
+	//mk_child(root->right, nullptr, mk_node(6));
+	solution.flatten(root);
+	print_list(root);
+	return 0;
+}

Diff for: algorithms/Template/list/list.c

@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+struct ListNode {
+	int val;
+	struct ListNode *next;
+};
+int getLength(struct ListNode *head)
+{
+	int len = 0;
+	struct ListNode *p = head;
+	while (p) {
+		++len;
+		p = p->next;
+	}
+	return len;
+}
+void print(struct ListNode *ha, struct ListNode *hb)
+{
+	struct ListNode *p = getIntersectionNode(ha, hb);
+	if (p == NULL)
+		printf("NULL\n");
+	else
+		printf("%d\n", p -> val);
+}
+struct ListNode * mk_list(struct ListNode **ha, int a[], int n)
+{
+	struct ListNode *p = malloc(sizeof(*p));
+	p->val = a[0];
+	p->next = NULL;
+	*ha = p;
+	for (int i = 1; i < n; ++i) {
+		struct ListNode *q = malloc(sizeof(*q));
+		q->val = a[i];
+		q->next = NULL;
+		p->next = q;
+		p = q;
+	}
+	return p;
+}
+int main(int argc, char **argv)
+{
+	return 0;
+}

Diff for: algorithms/Template/tree/tree.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+using namespace std;
+struct TreeNode {
+	int val;
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode(int x) : val(x), left(nullptr), right(nullptr){}
+}
+class Solution {
+public:
+	void foo() {
+
+	}
+
+};
+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;
+	return 0;
+}