feat: add solutions to lc problem: No.0094 (doocs#2333)

No.0094.Binary Tree Inorder Traversal

Author: yanglbme

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

@@ -13,25 +13,15 @@ class Solution {
 public:
     vector<int> inorderTraversal(TreeNode* root) {
         vector<int> ans;
-        while (root) {
-            if (!root->left) {
-                ans.push_back(root->val);
-                root = root->right;
-            } else {
-                TreeNode* prev = root->left;
-                while (prev->right && prev->right != root) {
-                    prev = prev->right;
-                }
-                if (!prev->right) {
-                    prev->right = root;
-                    root = root->left;
-                } else {
-                    ans.push_back(root->val);
-                    prev->right = nullptr;
-                    root = root->right;
-                }
+        function<void(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return;
             }
-        }
+            dfs(root->left);
+            ans.push_back(root->val);
+            dfs(root->right);
+        };
+        dfs(root);
         return ans;
     }
 };

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

@@ -6,26 +6,16 @@
  *     Right *TreeNode
  * }
  */
-func inorderTraversal(root *TreeNode) []int {
-	var ans []int
-	for root != nil {
-		if root.Left == nil {
-			ans = append(ans, root.Val)
-			root = root.Right
-		} else {
-			prev := root.Left
-			for prev.Right != nil && prev.Right != root {
-				prev = prev.Right
-			}
-			if prev.Right == nil {
-				prev.Right = root
-				root = root.Left
-			} else {
-				ans = append(ans, root.Val)
-				prev.Right = nil
-				root = root.Right
-			}
+func inorderTraversal(root *TreeNode) (ans []int) {
+	var dfs func(*TreeNode)
+	dfs = func(root *TreeNode) {
+		if root == nil {
+			return
 		}
+		dfs(root.Left)
+		ans = append(ans, root.Val)
+		dfs(root.Right)
 	}
-	return ans
+	dfs(root)
+	return
 }

solution/0000-0099/0094.Binary Tree Inorder Traversal/Solution.cpp

@@ -14,10 +14,9 @@
  * }
  */
 class Solution {
-    private List<Integer> ans;
+    private List<Integer> ans = new ArrayList<>();
 
     public List<Integer> inorderTraversal(TreeNode root) {
-        ans = new ArrayList<>();
         dfs(root);
         return ans;
     }

solution/0000-0099/0094.Binary Tree Inorder Traversal/Solution.go

@@ -11,13 +11,15 @@
  * @return {number[]}
  */
 var inorderTraversal = function (root) {
-    let ans = [];
-    function dfs(root) {
-        if (!root) return;
+    const ans = [];
+    const dfs = root => {
+        if (!root) {
+            return;
+        }
         dfs(root.left);
         ans.push(root.val);
         dfs(root.right);
-    }
+    };
     dfs(root);
     return ans;
 };

solution/0000-0099/0094.Binary Tree Inorder Traversal/Solution.java

@@ -19,19 +19,19 @@
 use std::rc::Rc;
 use std::cell::RefCell;
 impl Solution {
-    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, ans: &mut Vec<i32>) {
         if root.is_none() {
             return;
         }
         let node = root.as_ref().unwrap().borrow();
-        Self::dfs(&node.left, res);
-        res.push(node.val);
-        Self::dfs(&node.right, res);
+        Self::dfs(&node.left, ans);
+        ans.push(node.val);
+        Self::dfs(&node.right, ans);
     }
 
     pub fn inorder_traversal(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
-        let mut res = vec![];
-        Self::dfs(&root, &mut res);
-        res
+        let mut ans = vec![];
+        Self::dfs(&root, &mut ans);
+        ans
     }
 }

solution/0000-0099/0094.Binary Tree Inorder Traversal/Solution.js

@@ -13,8 +13,15 @@
  */
 
 function inorderTraversal(root: TreeNode | null): number[] {
-    if (root == null) {
-        return [];
-    }
-    return [...inorderTraversal(root.left), root.val, ...inorderTraversal(root.right)];
+    const ans: number[] = [];
+    const dfs = (root: TreeNode | null) => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left);
+        ans.push(root.val);
+        dfs(root.right);
+    };
+    dfs(root);
+    return ans;
 }

solution/0000-0099/0094.Binary Tree Inorder Traversal/Solution.rs

@@ -0,0 +1,30 @@
+/**
+ * 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:
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        stack<TreeNode*> stk;
+        while (root || stk.size()) {
+            if (root) {
+                stk.push(root);
+                root = root->left;
+            } else {
+                root = stk.top();
+                stk.pop();
+                ans.push_back(root->val);
+                root = root->right;
+            }
+        }
+        return ans;
+    }
+};

solution/0000-0099/0094.Binary Tree Inorder Traversal/Solution.ts

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func inorderTraversal(root *TreeNode) (ans []int) {
+	stk := []*TreeNode{}
+	for root != nil || len(stk) > 0 {
+		if root != nil {
+			stk = append(stk, root)
+			root = root.Left
+		} else {
+			root = stk[len(stk)-1]
+			stk = stk[:len(stk)-1]
+			ans = append(ans, root.Val)
+			root = root.Right
+		}
+	}
+	return
+}