feat: update solutions to lc problem: No.0144

No.0144.Binary Tree Preorder Traversal

Author: yanglbme

solution/0100-0199/0144.Binary Tree Preorder Traversal/README.md

@@ -70,7 +70,7 @@
 
 非递归的思路如下：
 
-1. 定义一个栈，先将根节点压入栈
+1. 定义一个栈 stk，先将根节点压入栈
 2. 若栈不为空，每次从栈中弹出一个节点
 3. 处理该节点
 4. 先把节点右孩子压入栈，接着把节点左孩子压入栈（如果有孩子节点）
@@ -83,10 +83,10 @@ Morris 遍历无需使用栈，空间复杂度为 O(1)。核心思想是：
 
 遍历二叉树节点，
 
-1. 若当前节点 root 的左子树为空，**将当前节点值添加至结果列表 res** 中，并将当前节点更新为 `root.right`
-2. 若当前节点 root 的左子树不为空，找到左子树的最右节点 pre（也即是 root 节点在中序遍历下的前驱节点）：
-    - 若前驱节点 pre 的右子树为空，**将当前节点值添加至结果列表 res** 中，然后将前驱节点的右子树指向当前节点 root，并将当前节点更新为 `root.left`。
-    - 若前驱节点 pre 的右子树不为空，将前驱节点右子树指向空（即解除 pre 与 root 的指向关系），并将当前节点更新为 `root.right`。
+1. 若当前节点 root 的左子树为空，**将当前节点值添加至结果列表 ans** 中，并将当前节点更新为 `root.right`
+2. 若当前节点 root 的左子树不为空，找到左子树的最右节点 prev（也即是 root 节点在中序遍历下的前驱节点）：
+    - 若前驱节点 prev 的右子树为空，**将当前节点值添加至结果列表 ans** 中，然后将前驱节点的右子树指向当前节点 root，并将当前节点更新为 `root.left`。
+    - 若前驱节点 prev 的右子树不为空，将前驱节点右子树指向空（即解除 prev 与 root 的指向关系），并将当前节点更新为 `root.right`。
 3. 循环以上步骤，直至二叉树节点为空，遍历结束。
 
 <!-- tabs:start -->
@@ -105,17 +105,18 @@ Morris 遍历无需使用栈，空间复杂度为 O(1)。核心思想是：
 #         self.left = left
 #         self.right = right
 class Solution:
-    def preorderTraversal(self, root: TreeNode) -> List[int]:
-        res = []
-
-        def preorder(root):
-            if root:
-                res.append(root.val)
-                preorder(root.left)
-                preorder(root.right)
-
-        preorder(root)
-        return res
+    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        def dfs(root):
+            if root is None:
+                return
+            nonlocal ans
+            ans.append(root.val)
+            dfs(root.left)
+            dfs(root.right)
+        
+        ans = []
+        dfs(root)
+        return ans
 ```
 
 栈实现非递归：
@@ -128,18 +129,19 @@ class Solution:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def preorderTraversal(self, root: TreeNode) -> List[int]:
-        res = []
-        if root:
-            s = [root]
-            while s:
-                node = s.pop()
-                res.append(node.val)
-                if node.right:
-                    s.append(node.right)
-                if node.left:
-                    s.append(node.left)
-        return res
+    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        ans = []
+        if root is None:
+            return ans
+        stk = [root]
+        while stk:
+            node = stk.pop()
+            ans.append(node.val)
+            if node.right:
+                stk.append(node.right)
+            if node.left:
+                stk.append(node.left)
+        return ans
 ```
 
 Morris 遍历：
@@ -152,24 +154,24 @@ Morris 遍历：
 #         self.left = left
 #         self.right = right
 class Solution:
-    def preorderTraversal(self, root: TreeNode) -> List[int]:
-        res = []
+    def preorderTraversal(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:
-                    res.append(root.val)
-                    pre.right = root
+                prev = root.left
+                while prev.right and prev.right != root:
+                    prev = prev.right
+                if prev.right is None:
+                    ans.append(root.val)
+                    prev.right = root
                     root = root.left
                 else:
-                    pre.right = None
+                    prev.right = None
                     root = root.right
-        return res
+        return ans
 ```
 
 ### **Java**
@@ -195,18 +197,21 @@ class Solution:
  * }
  */
 class Solution {
+    private List<Integer> ans;
+
     public List<Integer> preorderTraversal(TreeNode root) {
-        List<Integer> res = new ArrayList<>();
-        preorder(root, res);
-        return res;
+        ans = new ArrayList<>();
+        dfs(root);
+        return ans;
     }
 
-    private void preorder(TreeNode root, List<Integer> res) {
-        if (root != null) {
-            res.add(root.val);
-            preorder(root.left, res);
-            preorder(root.right, res);
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
         }
+        ans.add(root.val);
+        dfs(root.left);
+        dfs(root.right);
     }
 }
 ```
@@ -231,22 +236,23 @@ class Solution {
  */
 class Solution {
     public List<Integer> preorderTraversal(TreeNode root) {
-        List<Integer> res = new ArrayList<>();
-        if (root != null) {
-            Deque<TreeNode> s = new LinkedList<>();
-            s.offerLast(root);
-            while (!s.isEmpty()) {
-                TreeNode node = s.pollLast();
-                res.add(node.val);
-                if (node.right != null) {
-                    s.offerLast(node.right);
-                }
-                if (node.left != null) {
-                    s.offerLast(node.left);
-                }
+        List<Integer> ans = new ArrayList<>();
+        if (root == null) {
+            return ans;
+        }
+        Deque<TreeNode> stk = new ArrayDeque<>();
+        stk.push(root);
+        while (!stk.isEmpty()) {
+            TreeNode node = stk.pop();
+            ans.add(node.val);
+            if (node.right != null) {
+                stk.push(node.right);
+            }
+            if (node.left != null) {
+                stk.push(node.left);
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -271,27 +277,27 @@ Morris 遍历：
  */
 class Solution {
     public List<Integer> preorderTraversal(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) {
-                    res.add(root.val);
-                    pre.right = root;
+                if (prev.right == null) {
+                    ans.add(root.val);
+                    prev.right = root;
                     root = root.left;
                 } else {
-                    pre.right = null;
+                    prev.right = null;
                     root = root.right;
                 }
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -314,17 +320,54 @@ class Solution {
  */
 
 function preorderTraversal(root: TreeNode | null): number[] {
-    if (root == null) return [];
-    let stack = [];
     let ans = [];
-    while (root || stack.length) {
-        while (root) {
+    if (!root) return ans;
+    let stk = [root];
+    while (stk.length) {
+        let node = stk.pop();
+        ans.push(node.val);
+        if (node.right) stk.push(node.right);
+        if (node.left) stk.push(node.left);
+    }
+    return ans;
+}
+```
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function preorderTraversal(root: TreeNode | null): number[] {
+    let ans = [];
+    while (root) {
+        if (!root.left) {
             ans.push(root.val);
-            stack.push(root);
-            root = root.left;
+            root = root.right;
+        } else {
+            let prev = root.left;
+            while (prev.right && prev.right != root) {
+                prev = prev.right;
+            }
+            if (!prev.right) {
+                ans.push(root.val);
+                prev.right = root;
+                root = root.left;
+            } else {
+                prev.right = null;
+                root = root.right;
+            }
         }
-        root = stack.pop();
-        root = root.right;
     }
     return ans;
 }
@@ -346,36 +389,36 @@ function preorderTraversal(root: TreeNode | null): number[] {
  */
 class Solution {
 public:
-    vector<int> preorderTraversal(TreeNode *root) {
-        vector<int> res;
+    vector<int> preorderTraversal(TreeNode* root) {
+        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)
+                TreeNode* prev = root->left;
+                while (prev->right && prev->right != root)
                 {
-                    pre = pre->right;
+                    prev = prev->right;
                 }
-                if (pre->right == nullptr)
+                if (!prev->right)
                 {
-                    res.push_back(root->val);
-                    pre->right = root;
+                    ans.push_back(root->val);
+                    prev->right = root;
                     root = root->left;
                 }
                 else
                 {
-                    pre->right = nullptr;
+                    prev->right = nullptr;
                     root = root->right;
                 }
             }
         }
-        return res;
+        return ans;
     }
 };
 ```
@@ -392,27 +435,27 @@ public:
  * }
  */
 func preorderTraversal(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 {
-				res = append(res, root.Val)
-				pre.Right = root
+			if prev.Right == nil {
+				ans = append(ans, root.Val)
+				prev.Right = root
 				root = root.Left
 			} else {
-				pre.Right = nil
+				prev.Right = nil
 				root = root.Right
 			}
 		}
 	}
-	return res
+	return ans
 }
 ```