feat: add solutions to lcof2 problem: No.054

yanglbme · yanglbme · commit 6102880c26cb · 2021-08-21T11:50:32.000+08:00
diff --git a/README.md b/README.md
@@ -21,8 +21,11 @@
 ## 站点
 
 - Netlify: https://lc.netlify.app
+- ~~Gitee Pages: https://doocs.gitee.io/leetcode~~
 - GitHub Pages: https://doocs.github.io/leetcode
 
+注：Gitee Pages 站点被 Gitee 官方误判为“包含违禁违规内容”，惨遭下线。
+
 ## LeetCode 全解
 
 - [LeetCode](./solution/README.md)
diff --git a/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/README.md b/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/README.md
@@ -68,27 +68,278 @@
 	<li>本题与主站 1038&nbsp;题相同：<a href="https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/">https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/</a></li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+二叉搜索树的中序遍历（左根右）结果是一个单调递增的有序序列，我们反序进行中序遍历（右根左），即可以得到一个单调递减的有序序列。通过累加单调递减的有序序列，我们可以得到大于等于 node.val 的新值，并重新赋值给 node。
+
+关于反序中序遍历，有三种方法，一是递归遍历，二是栈实现非递归遍历，三是 Morris 遍历。
+
+Morris 遍历无需使用栈，空间复杂度为 O(1)。核心思想是：
+
+定义 s 表示二叉搜索树节点值累加之和。遍历二叉树节点，
+
+1. 若当前节点 root 的右子树为空，**将当前节点值添加至 s** 中，更新当前节点值为 s，并将当前节点更新为 `root.left`。
+2. 若当前节点 root 的右子树不为空，找到右子树的最左节点 next（也即是 root 节点在中序遍历下的后继节点）：
+   - 若后继节点 next 的左子树为空，将后继节点的左子树指向当前节点 root，并将当前节点更新为 `root.right`。
+   - 若后继节点 next 的左子树不为空，**将当前节点值添加 s** 中，更新当前节点值为 s，然后将后继节点左子树指向空（即解除 next 与 root 的指向关系），并将当前节点更新为 `root.left`。
+3. 循环以上步骤，直至二叉树节点为空，遍历结束。
+4. 最后返回二叉搜索树根节点即可。
+
+> Morris 反序中序遍历跟 Morris 中序遍历思路一致，只是将中序遍历的“左根右”变为“右根左”。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+递归遍历：
+
 ```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    add = 0
+    def convertBST(self, root: TreeNode) -> TreeNode:
+        if root:
+            self.convertBST(root.right)
+            root.val += self.add
+            self.add = root.val
+            self.convertBST(root.left)
+        return root
+```
 
+Morris 遍历：
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def convertBST(self, root: TreeNode) -> TreeNode:
+        s = 0
+        node = root
+        while root:
+            if root.right is None:
+                s += root.val
+                root.val = s
+                root = root.left
+            else:
+                next = root.right
+                while next.left and next.left != root:
+                    next = next.left
+                if next.left is None:
+                    next.left = root
+                    root = root.right
+                else:
+                    s += root.val
+                    root.val = s
+                    next.left = None
+                    root = root.left
+        return node
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+递归遍历：
+
+```java
+class Solution {
+    int add = 0;
+    public TreeNode convertBST(TreeNode root) {
+        if (root != null) {
+            convertBST(root.right);
+            root.val += add;
+            add = root.val;
+            convertBST(root.left);
+        }
+        return root;
+    }
+}
+```
+
+Morris 遍历：
+
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode convertBST(TreeNode root) {
+        int s = 0;
+        TreeNode node = root;
+        while (root != null) {
+            if (root.right == null) {
+                s += root.val;
+                root.val = s;
+                root = root.left;
+            } else {
+                TreeNode next = root.right;
+                while (next.left != null && next.left != root) {
+                    next = next.left;
+                }
+                if (next.left == null) {
+                    next.left = root;
+                    root = root.right;
+                } else {
+                    s += root.val;
+                    root.val = s;
+                    next.left = null;
+                    root = root.left;
+                }
+            }
+        }
+        return node;
+    }
+}
+```
+
+### **C++**
+
+递归遍历：
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int add = 0;
+    TreeNode* convertBST(TreeNode* root) {
+        if (root) {
+            convertBST(root->right);
+            root->val += add;
+            add = root->val;
+            convertBST(root->left);
+        }
+        return root;
+    }
+};
+```
+
+Morris 遍历：
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *convertBST(TreeNode *root) {
+        int s = 0;
+        TreeNode *node = root;
+        while (root)
+        {
+            if (root->right == nullptr)
+            {
+                s += root->val;
+                root->val = s;
+                root = root->left;
+            }
+            else
+            {
+                TreeNode *next = root->right;
+                while (next->left && next->left != root)
+                {
+                    next = next->left;
+                }
+                if (next->left == nullptr)
+                {
+                    next->left = root;
+                    root = root->right;
+                }
+                else
+                {
+                    s += root->val;
+                    root->val = s;
+                    next->left = nullptr;
+                    root = root->left;
+                }
+            }
+        }
+        return node;
+    }
+};
+```
 
+### **Go**
+
+Morris 遍历：
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func convertBST(root *TreeNode) *TreeNode {
+	s := 0
+	node := root
+	for root != nil {
+		if root.Right == nil {
+			s += root.Val
+			root.Val = s
+			root = root.Left
+		} else {
+			next := root.Right
+			for next.Left != nil && next.Left != root {
+				next = next.Left
+			}
+			if next.Left == nil {
+				next.Left = root
+				root = root.Right
+			} else {
+				s += root.Val
+				root.Val = s
+				next.Left = nil
+				root = root.Left
+			}
+		}
+	}
+	return node
+}
 ```
 
 ### **...**
diff --git a/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.cpp b/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.cpp
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *convertBST(TreeNode *root) {
+        int s = 0;
+        TreeNode *node = root;
+        while (root)
+        {
+            if (root->right == nullptr)
+            {
+                s += root->val;
+                root->val = s;
+                root = root->left;
+            }
+            else
+            {
+                TreeNode *next = root->right;
+                while (next->left && next->left != root)
+                {
+                    next = next->left;
+                }
+                if (next->left == nullptr)
+                {
+                    next->left = root;
+                    root = root->right;
+                }
+                else
+                {
+                    s += root->val;
+                    root->val = s;
+                    next->left = nullptr;
+                    root = root->left;
+                }
+            }
+        }
+        return node;
+    }
+};
diff --git a/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.go b/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.go
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func convertBST(root *TreeNode) *TreeNode {
+	s := 0
+	node := root
+	for root != nil {
+		if root.Right == nil {
+			s += root.Val
+			root.Val = s
+			root = root.Left
+		} else {
+			next := root.Right
+			for next.Left != nil && next.Left != root {
+				next = next.Left
+			}
+			if next.Left == nil {
+				next.Left = root
+				root = root.Right
+			} else {
+				s += root.Val
+				root.Val = s
+				next.Left = nil
+				root = root.Left
+			}
+		}
+	}
+	return node
+}
diff --git a/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.java b/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.java
diff --git a/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.py b/lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.py
