feat: add solutions to lcci problem: No.04.06

04.06.Successor

Author: YangFong

lcci/04.06.Successor/README.md

@@ -37,6 +37,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -143,6 +145,39 @@ public:
 };
 ```
 
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *inorderSuccessor(TreeNode *root, TreeNode *p) {
+        stack<TreeNode *> stk;
+        TreeNode *cur = root;
+        while (cur != nullptr || !stk.empty()) {
+            if (cur == nullptr) {
+                cur = stk.top();
+                stk.pop();
+                if (cur->val > p->val) {
+                    return cur;
+                }
+                cur = cur->right;
+            } else {
+                stk.push(cur);
+                cur = cur->left;
+            }
+        }
+        return cur;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -173,6 +208,69 @@ func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @return {TreeNode}
+ */
+var inorderSuccessor = function (root, p) {
+    if (root == null) {
+        return root
+    }
+    const { val, left, right } = root
+    const res = inorderSuccessor(left, p)
+    if (res != null) {
+        return res
+    }
+    if (val > p.val) {
+        return root
+    }
+    return inorderSuccessor(right, p)
+};
+```
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @return {TreeNode}
+ */
+var inorderSuccessor = function (root, p) {
+    const stack = [];
+    let cur = root;
+    while (cur != null || stack.length !== 0) {
+        if (cur == null) {
+            cur = stack.pop();
+            if (cur.val > p.val) {
+                return cur;
+            }
+            cur = cur.right;
+        } else {
+            stack.push(cur);
+            cur = cur.left;
+        }
+    }
+    return cur;
+};
+```
+
 ### **...**
 
 ```

lcci/04.06.Successor/README_EN.md

@@ -156,6 +156,39 @@ public:
 };
 ```
 
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *inorderSuccessor(TreeNode *root, TreeNode *p) {
+        stack<TreeNode *> stk;
+        TreeNode *cur = root;
+        while (cur != nullptr || !stk.empty()) {
+            if (cur == nullptr) {
+                cur = stk.top();
+                stk.pop();
+                if (cur->val > p->val) {
+                    return cur;
+                }
+                cur = cur->right;
+            } else {
+                stk.push(cur);
+                cur = cur->left;
+            }
+        }
+        return cur;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -186,6 +219,69 @@ func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @return {TreeNode}
+ */
+var inorderSuccessor = function (root, p) {
+    if (root == null) {
+        return root
+    }
+    const { val, left, right } = root
+    const res = inorderSuccessor(left, p)
+    if (res != null) {
+        return res
+    }
+    if (val > p.val) {
+        return root
+    }
+    return inorderSuccessor(right, p)
+};
+```
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @return {TreeNode}
+ */
+var inorderSuccessor = function (root, p) {
+    const stack = [];
+    let cur = root;
+    while (cur != null || stack.length !== 0) {
+        if (cur == null) {
+            cur = stack.pop();
+            if (cur.val > p.val) {
+                return cur;
+            }
+            cur = cur.right;
+        } else {
+            stack.push(cur);
+            cur = cur.left;
+        }
+    }
+    return cur;
+};
+```
+
 ### **...**
 
 ```

lcci/04.06.Successor/Solution.js

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @return {TreeNode}
+ */
+var inorderSuccessor = function (root, p) {
+    if (root == null) {
+        return root;
+    }
+    const { val, left, right } = root;
+    const res = inorderSuccessor(left, p);
+    if (res != null) {
+        return res;
+    }
+    if (val > p.val) {
+        return root;
+    }
+    return inorderSuccessor(right, p);
+};