vault backup: 2022-07-04 15:50:54

CS notes/pages/Leetcode Binary-Tree-Inorder-Traversal.md

@@ -0,0 +1,98 @@
+# Leetcode Binary-Tree-Inorder-Traversal
+
+#### 2022-07-04 15:42
+
+> ##### Algorithms:
+> #algorithm #DFS #DFS_inorder
+> ##### Data structures:
+> #DS #binary_tree 
+> ##### Difficulty:
+> #coding_problem #difficulty-easy
+> ##### Additional tags:
+> #leetcode
+> ##### Revisions:
+> N/A
+
+##### Related topics:
+```expander
+tag:#DFS
+```
+ 
+- [[Leetcode Binary-Tree-Preorder-Traversal]]
+ 
+
+##### Links:
+- [Link to problem](https://leetcode.com/problems/binary-tree-inorder-traversal/)
+___
+### Problem
+Given the `root` of a binary tree, return _the inorder traversal of its nodes' values_.
+
+#### Examples
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg)
+
+**Input:** root = [1,null,2,3]
+**Output:** [1,3,2]
+
+**Example 2:**
+
+**Input:** root = []
+**Output:** []
+
+**Example 3:**
+
+**Input:** root = [1]
+**Output:** [1]
+
+#### Constraints
+-   The number of nodes in the tree is in the range `[0, 100]`.
+-   `-100 <= Node.val <= 100`
+
+### Thoughts
+
+> [!summary]
+> This is a #DFS traversal problem
+
+Many of them are same to [[Leetcode Binary-Tree-Preorder-Traversal]]
+### Solution
+
+Recursion
+```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 {
+  void inorder(TreeNode *root, vector<int> &answer) {
+    if (!root) {
+      return;
+    }
+
+    inorder(root->left, answer);
+    answer.push_back(root->val);
+    inorder(root->right, answer);
+  }
+
+public:
+  vector<int> inorderTraversal(TreeNode *root) {
+    // Recursion.
+    vector<int> answer;
+    inorder(root, answer);
+    return answer;
+  }
+};
+```
+
+Iteration
+```cpp
+
+```

CS notes/pages/Leetcode Binary-Tree-Preorder-Traversal.md

@@ -3,21 +3,22 @@
 #### 2022-07-04 14:51
 
 > ##### Algorithms:
-> #algorithm #DFS #DFS_preorder
+> #algorithm #DFS #DFS_preorder #Morris_traversal
 > ##### Data structures:
 > #DS #binary_tree
 > ##### Difficulty:
 > #coding_problem #difficulty-easy
 > ##### Additional tags:
-> #leetcode
+> #leetcode #CS_list_need_understanding
 > ##### Revisions:
 > N/A
 
 ##### Related topics:
 ```expander
-tag:#
+tag:#DFS
 ```
  
+- [[Leetcode Binary-Tree-Inorder-Traversal]]
  
 
 ##### Links:
@@ -62,6 +63,7 @@ The recursion version is easy to implement.
 Use Stacks for the iteration method, because stacks are FILO, the **subtree will get traversed first.**
 And remember to push **right subtree** first, so that the left one will be traversed first.
 
+The Morris traversal needs more understandings.
 
 ### Solution
 Iteration