feat: add solutions to lc problems: No.0538,1038

Author: yanglbme

solution/0500-0599/0538.Convert BST to Greater Tree/README.md

@@ -61,12 +61,18 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+二叉搜索树的中序遍历（左根右）结果是一个单调递增的有序序列，我们反序进行中序遍历（右根左），即可以得到一个单调递减的有序序列。通过累加单调递减的有序序列，我们可以得到大于等于 node.val 的新值，并重新赋值给 node。
+
+关于反序中序遍历，有三种方法，一是递归遍历，二是栈实现非递归遍历，三是 Morris 遍历。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+递归遍历：
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -85,10 +91,45 @@ class Solution:
         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;
@@ -104,8 +145,58 @@ class Solution {
 }
 ```
 
+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.
@@ -133,6 +224,100 @@ public:
 };
 ```
 
+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
+}
+```
+
 ### **...**
 
 ```