feat: update solutions to lc problems: No.0094,2034

* No.0094.Binary Tree Inorder Traversal
* No.2034.Stock Price Fluctuation

Author: yanglbme

solution/0000-0099/0094.Binary Tree Inorder Traversal/README.md

@@ -70,7 +70,7 @@
 
 非递归的思路如下：
 
-1. 定义一个栈
+1. 定义一个栈 stk
 2. 将树的左节点依次入栈
 3. 左节点为空时，弹出栈顶元素并处理
 4. 重复 2-3 的操作
@@ -81,10 +81,10 @@ Morris 遍历无需使用栈，空间复杂度为 O(1)。核心思想是：
 
 遍历二叉树节点，
 
-1. 若当前节点 root 的左子树为空，**将当前节点值添加至结果列表 res** 中，并将当前节点更新为 `root.right`
-2. 若当前节点 root 的左子树不为空，找到左子树的最右节点 pre（也即是 root 节点在中序遍历下的前驱节点）：
-    - 若前驱节点 pre 的右子树为空，将前驱节点的右子树指向当前节点 root，并将当前节点更新为 `root.left`。
-    - 若前驱节点 pre 的右子树不为空，**将当前节点值添加至结果列表 res** 中，然后将前驱节点右子树指向空（即解除 pre 与 root 的指向关系），并将当前节点更新为 `root.right`。
+1. 若当前节点 root 的左子树为空，**将当前节点值添加至结果列表 ans** 中，并将当前节点更新为 `root.right`
+2. 若当前节点 root 的左子树不为空，找到左子树的最右节点 prev（也即是 root 节点在中序遍历下的前驱节点）：
+    - 若前驱节点 prev 的右子树为空，将前驱节点的右子树指向当前节点 root，并将当前节点更新为 `root.left`。
+    - 若前驱节点 prev 的右子树不为空，**将当前节点值添加至结果列表 ans** 中，然后将前驱节点右子树指向空（即解除 prev 与 root 的指向关系），并将当前节点更新为 `root.right`。
 3. 循环以上步骤，直至二叉树节点为空，遍历结束。
 
 <!-- tabs:start -->
@@ -103,17 +103,18 @@ Morris 遍历无需使用栈，空间复杂度为 O(1)。核心思想是：
 #         self.left = left
 #         self.right = right
 class Solution:
-    def inorderTraversal(self, root: TreeNode) -> List[int]:
-        res = []
-
-        def inorder(root):
-            if root:
-                inorder(root.left)
-                res.append(root.val)
-                inorder(root.right)
-
-        inorder(root)
-        return res
+    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        def dfs(root):
+            if root is None:
+                return
+            dfs(root.left)
+            nonlocal ans
+            ans.append(root.val)
+            dfs(root.right)
+
+        ans = []
+        dfs(root)
+        return ans
 ```
 
 栈实现非递归：
@@ -126,17 +127,17 @@ class Solution:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def inorderTraversal(self, root: TreeNode) -> List[int]:
-        res, s = [], []
-        while root or s:
+    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        ans, stk = [], []
+        while root or stk:
             if root:
-                s.append(root)
+                stk.append(root)
                 root = root.left
             else:
-                root = s.pop()
-                res.append(root.val)
+                root = stk.pop()
+                ans.append(root.val)
                 root = root.right
-        return res
+        return ans
 ```
 
 Morris 遍历:
@@ -149,24 +150,24 @@ Morris 遍历:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def inorderTraversal(self, root: TreeNode) -> List[int]:
-        res = []
+    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        ans = []
         while root:
             if root.left is None:
-                res.append(root.val)
+                ans.append(root.val)
                 root = root.right
             else:
-                pre = root.left
-                while pre.right and pre.right != root:
-                    pre = pre.right
-                if pre.right is None:
-                    pre.right = root
+                prev = root.left
+                while prev.right and prev.right != root:
+                    prev = prev.right
+                if prev.right is None:
+                    prev.right = root
                     root = root.left
                 else:
-                    res.append(root.val)
-                    pre.right = None
+                    ans.append(root.val)
+                    prev.right = None
                     root = root.right
-        return res
+        return ans
 ```
 
 ### **Java**
@@ -192,18 +193,21 @@ class Solution:
  * }
  */
 class Solution {
+    private List<Integer> ans;
+
     public List<Integer> inorderTraversal(TreeNode root) {
-        List<Integer> res = new ArrayList<>();
-        inorder(root, res);
-        return res;
+        ans = new ArrayList<>();
+        dfs(root);
+        return ans;
     }
 
-    private void inorder(TreeNode root, List<Integer> res) {
-        if (root != null) {
-            inorder(root.left, res);
-            res.add(root.val);
-            inorder(root.right, res);
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
         }
+        dfs(root.left);
+        ans.add(root.val);
+        dfs(root.right);
     }
 }
 ```
@@ -228,19 +232,19 @@ class Solution {
  */
 class Solution {
     public List<Integer> inorderTraversal(TreeNode root) {
-        List<Integer> res = new ArrayList<>();
-        Deque<TreeNode> s = new LinkedList<>();
-        while (root != null || !s.isEmpty()) {
+        List<Integer> ans = new ArrayList<>();
+        Deque<TreeNode> stk = new ArrayDeque<>();
+        while (root != null || !stk.isEmpty()) {
             if (root != null) {
-                s.offerLast(root);
+                stk.push(root);
                 root = root.left;
             } else {
-                root = s.pollLast();
-                res.add(root.val);
+                root = stk.pop();
+                ans.add(root.val);
                 root = root.right;
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -265,27 +269,27 @@ Morris 遍历:
  */
 class Solution {
     public List<Integer> inorderTraversal(TreeNode root) {
-        List<Integer> res = new ArrayList<>();
+        List<Integer> ans = new ArrayList<>();
         while (root != null) {
             if (root.left == null) {
-                res.add(root.val);
+                ans.add(root.val);
                 root = root.right;
             } else {
-                TreeNode pre = root.left;
-                while (pre.right != null && pre.right != root) {
-                    pre = pre.right;
+                TreeNode prev = root.left;
+                while (prev.right != null && prev.right != root) {
+                    prev = prev.right;
                 }
-                if (pre.right == null) {
-                    pre.right = root;
+                if (prev.right == null) {
+                    prev.right = root;
                     root = root.left;
                 } else {
-                    res.add(root.val);
-                    pre.right = null;
+                    ans.add(root.val);
+                    prev.right = null;
                     root = root.right;
                 }
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -308,16 +312,15 @@ class Solution {
  * @return {number[]}
  */
 var inorderTraversal = function (root) {
-    let res = [];
-    function inorder(root) {
-        if (root) {
-            inorder(root.left);
-            res.push(root.val);
-            inorder(root.right);
-        }
+    let ans = [];
+    function dfs(root) {
+        if (!root) return;
+        dfs(root.left);
+        ans.push(root.val);
+        dfs(root.right);
     }
-    inorder(root);
-    return res;
+    dfs(root);
+    return ans;
 };
 ```
 
@@ -337,19 +340,59 @@ var inorderTraversal = function (root) {
  * @return {number[]}
  */
 var inorderTraversal = function (root) {
-    let res = [];
-    let s = [];
-    while (root || s.length > 0) {
+    let ans = [],
+        stk = [];
+    while (root || stk.length > 0) {
         if (root) {
-            s.push(root);
+            stk.push(root);
             root = root.left;
         } else {
-            root = s.pop();
-            res.push(root.val);
+            root = stk.pop();
+            ans.push(root.val);
             root = root.right;
         }
     }
-    return res;
+    return ans;
+};
+```
+
+Morris 遍历:
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var inorderTraversal = function (root) {
+    let ans = [];
+    while (root) {
+        if (!root.left) {
+            ans.push(root.val);
+            root = root.right;
+        } else {
+            let prev = root.left;
+            while (prev.right && prev.right != root) {
+                prev = prev.right;
+            }
+            if (!prev.right) {
+                prev.right = root;
+                root = root.left;
+            } else {
+                ans.push(root.val);
+                prev.right = null;
+                root = root.right;
+            }
+        }
+    }
+    return ans;
 };
 ```
 
@@ -370,33 +413,35 @@ var inorderTraversal = function (root) {
 class Solution {
 public:
     vector<int> inorderTraversal(TreeNode* root) {
-        vector<int> res;
+        vector<int> ans;
         while (root)
         {
-            if (root->left == nullptr)
+            if (!root->left)
             {
-                res.push_back(root->val);
+                ans.push_back(root->val);
                 root = root->right;
-            } else {
-                TreeNode* pre = root->left;
-                while (pre->right && pre->right != root)
+            }
+            else
+            {
+                TreeNode* prev = root->left;
+                while (prev->right && prev->right != root)
                 {
-                    pre = pre->right;
+                    prev = prev->right;
                 }
-                if (pre->right == nullptr)
+                if (!prev->right)
                 {
-                    pre->right = root;
+                    prev->right = root;
                     root = root->left;
                 }
                 else
                 {
-                    res.push_back(root->val);
-                    pre->right = nullptr;
+                    ans.push_back(root->val);
+                    prev->right = nullptr;
                     root = root->right;
                 }
             }
         }
-        return res;
+        return ans;
     }
 };
 ```
@@ -413,27 +458,27 @@ public:
  * }
  */
 func inorderTraversal(root *TreeNode) []int {
-	var res []int
+	var ans []int
 	for root != nil {
 		if root.Left == nil {
-			res = append(res, root.Val)
+			ans = append(ans, root.Val)
 			root = root.Right
 		} else {
-			pre := root.Left
-			for pre.Right != nil && pre.Right != root {
-				pre = pre.Right
+			prev := root.Left
+			for prev.Right != nil && prev.Right != root {
+				prev = prev.Right
 			}
-			if pre.Right == nil {
-				pre.Right = root
+			if prev.Right == nil {
+				prev.Right = root
 				root = root.Left
 			} else {
-				res = append(res, root.Val)
-				pre.Right = nil
+				ans = append(ans, root.Val)
+				prev.Right = nil
 				root = root.Right
 			}
 		}
 	}
-	return res
+	return ans
 }
 ```