update iOS interview questions #3

Author: codedeman

DFS/Readme.md

@@ -0,0 +1,99 @@
+Preorder, inorder, and postorder are three common ways to traverse a binary tree. Each traversal has a specific order in which it visits the nodes in the tree, focusing on when it visits the root (or "current") node relative to its children (left and right).
+
+Here's how each traversal works:
+
+### 1. Preorder Traversal (Root -> Left -> Right)
+- **Process:** Visit the root node first, then recursively visit the left subtree, followed by the right subtree.
+- **Order:** Root -> Left -> Right.
+- **Example:** For a tree structured like this:
+  ```
+        1
+       / \
+      2   3
+     / \
+    4   5
+  ```
+  The preorder traversal would visit nodes in this order: **1, 2, 4, 5, 3**.
+
+- **Use Case:** Often used when you want to explore the root or parent nodes before inspecting leaves. It can be useful in scenarios like **copying** a tree or **serializing** it for storage.
+
+### 2. Inorder Traversal (Left -> Root -> Right)
+- **Process:** Visit the left subtree first, then the root node, and finally the right subtree.
+- **Order:** Left -> Root -> Right.
+- **Example:** For the same tree:
+  ```
+        1
+       / \
+      2   3
+     / \
+    4   5
+  ```
+  The inorder traversal would visit nodes in this order: **4, 2, 5, 1, 3**.
+
+- **Use Case:** Inorder traversal is especially useful in **binary search trees (BSTs)** because it visits nodes in **ascending order** (if the tree is a BST). It’s also helpful when you want to access nodes in a sorted sequence.
+
+### 3. Postorder Traversal (Left -> Right -> Root)
+- **Process:** Visit the left subtree first, then the right subtree, and finally the root node.
+- **Order:** Left -> Right -> Root.
+- **Example:** For the same tree:
+  ```
+        1
+       / \
+      2   3
+     / \
+    4   5
+  ```
+  The postorder traversal would visit nodes in this order: **4, 5, 2, 3, 1**.
+
+- **Use Case:** Postorder traversal is useful when you want to deal with the **child nodes before the parent**. It’s commonly used for tasks like **deleting** or **freeing nodes** in memory and evaluating expression trees.
+
+### Summary Table
+
+| Traversal    | Order                | Example Order for Above Tree (Root: 1) | Common Uses                                      |
+|--------------|----------------------|-----------------------------------------|--------------------------------------------------|
+| **Preorder** | Root -> Left -> Right | `1, 2, 4, 5, 3`                       | Serialization, copying trees                     |
+| **Inorder**  | Left -> Root -> Right | `4, 2, 5, 1, 3`                       | Accessing sorted data in BSTs                    |
+| **Postorder**| Left -> Right -> Root | `4, 5, 2, 3, 1`                       | Deleting nodes, evaluating expression trees      |
+
+These traversal orders allow us to explore and process trees in different ways, depending on the needs of our algorithm or application.
+
+Certainly! Here’s a list of some popular DFS problems on LeetCode, covering various data structures and applications of DFS such as tree traversal, graph traversal, and backtracking:
+
+### Binary Tree DFS Problems
+1. **[144. Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/)**
+2. **[94. Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)**
+3. **[145. Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/)**
+4. **[104. Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)**
+5. **[112. Path Sum](https://leetcode.com/problems/path-sum/)**
+6. **[113. Path Sum II](https://leetcode.com/problems/path-sum-ii/)**
+7. **[124. Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/)**
+8. **[236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)**
+
+### Graph DFS Problems
+1. **[200. Number of Islands](https://leetcode.com/problems/number-of-islands/)**
+2. **[130. Surrounded Regions](https://leetcode.com/problems/surrounded-regions/)**
+3. **[797. All Paths From Source to Target](https://leetcode.com/problems/all-paths-from-source-to-target/)**
+4. **[733. Flood Fill](https://leetcode.com/problems/flood-fill/)**
+5. **[695. Max Area of Island](https://leetcode.com/problems/max-area-of-island/)**
+6. **[417. Pacific Atlantic Water Flow](https://leetcode.com/problems/pacific-atlantic-water-flow/)**
+7. **[547. Number of Provinces](https://leetcode.com/problems/number-of-provinces/)**
+8. **[785. Is Graph Bipartite?](https://leetcode.com/problems/is-graph-bipartite/)**
+
+### Backtracking DFS Problems
+1. **[46. Permutations](https://leetcode.com/problems/permutations/)**
+2. **[78. Subsets](https://leetcode.com/problems/subsets/)**
+3. **[39. Combination Sum](https://leetcode.com/problems/combination-sum/)**
+4. **[77. Combinations](https://leetcode.com/problems/combinations/)**
+5. **[51. N-Queens](https://leetcode.com/problems/n-queens/)**
+6. **[52. N-Queens II](https://leetcode.com/problems/n-queens-ii/)**
+7. **[212. Word Search II](https://leetcode.com/problems/word-search-ii/)**
+8. **[22. Generate Parentheses](https://leetcode.com/problems/generate-parentheses/)**
+
+### Advanced DFS and Path-Finding Problems
+1. **[329. Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)**
+2. **[1245. Tree Diameter](https://leetcode.com/problems/tree-diameter/)**
+3. **[399. Evaluate Division](https://leetcode.com/problems/evaluate-division/)**
+4. **[684. Redundant Connection](https://leetcode.com/problems/redundant-connection/)**
+5. **[1376. Time Needed to Inform All Employees](https://leetcode.com/problems/time-needed-to-inform-all-employees/)**
+
+These problems showcase DFS’s versatility, from simple traversals and connectivity checks to more complex recursive backtracking challenges. Let me know if you’d like more information on any of these!