@@ -0,0 +1,69 @@
+# Understanding the Fast & Slow Pointers Concept
+
+Think of the Fast & Slow Pointers technique like two runners on a track. One is a sprinter (Fast), moving two steps at a time, and the other is a jogger (Slow), moving one step at a time. If the track is a straight line, the fast runner will reach the finish line when the slow runner is exactly at the halfway mark. If the track is a circle (a cycle), the fast runner will eventually lap the slow runner and they will meet.
+
+This technique, also known as Floyd's Cycle-Finding Algorithm or the "Hare & Tortoise" algorithm, is used primarily to traverse linked lists and arrays where loops or middle points need to be identified without using extra memory.
+
+There are two primary uses:
+1. **Finding a Cycle** (Determining if a loop exists).
+2. **Finding the Middle** (Locating the midpoint of a list).
+
+## Type 1: Finding a Cycle
+We initialize two pointers, `Slow` and `Fast`, at the head of the data structure. `Slow` moves one step, and `Fast` moves two steps. If there is a cycle, the `Fast` pointer will loop around and eventually point to the same node as the `Slow` pointer.
+
+### The Process Step-by-Step
+**Goal:** Detect if a cycle exists in the linked list `1 -> 2 -> 3 -> 4 -> 5 -> 3` (where 5 points back to 3).
+
+```plaintext
+Data:  1 -> 2 -> 3 -> 4 -> 5
+                 ^         |
+                 |---------| (Cycle back to 3)
+
+Step 1: [1] -> 2 -> 3 -> 4 -> 5
+        ^S
+        ^F                      (Start: Both at 1)
+
+Step 2:  1 -> [2] -> [3] -> 4 -> 5
+               ^S     ^F        (Slow moves to 2, Fast moves to 3)
+
+Step 3:  1 -> 2 -> [3] -> 4 -> [5]
+                    ^S          ^F (Slow moves to 3, Fast moves to 5)
+
+Step 4:  1 -> 2 -> 3 -> [4] -> 5
+                         ^S (Fast loops to 3, moves to 4. Slow moves to 4)
+                         ^F
+
+Result: Slow and Fast are both at 4. A cycle is detected!
+```
+
+## Type 2: Finding the Middle
+Here, we also start both pointers at the head. We let the `Fast` pointer run until it hits the end of the list (or `null`). By the time `Fast` reaches the end, `Slow` will be exactly in the middle.
+
+### The Process Step-by-Step
+**Goal:** Find the middle element of the linked list `1 -> 2 -> 3 -> 4 -> 5`.
+
+```plaintext
+Data:  1 -> 2 -> 3 -> 4 -> 5 -> null
+
+Step 1: [1] -> 2 -> 3 -> 4 -> 5 -> null
+        ^S
+        ^F
+
+Step 2:  1 -> [2] -> [3] -> 4 -> 5 -> null
+               ^S     ^F
+
+Step 3:  1 -> 2 -> [3] -> 4 -> [5] -> null
+                    ^S          ^F
+
+Step 4: Fast cannot move two steps anymore because its next is null.
+
+Result: Slow is pointing at 3, which is the exact middle of the list!
+```
+
+### Comparison Summary
+| Feature | Finding a Cycle | Finding the Middle |
+|---------|-----------------|--------------------|
+| **Setup** | `Slow` at head, `Fast` at head. | `Slow` at head, `Fast` at head. |
+| **Movement** | `Slow` +1, `Fast` +2. | `Slow` +1, `Fast` +2. |
+| **Termination** | `Slow == Fast` or `Fast == null`. | `Fast == null` or `Fast.next == null`. |
+| **Used For...** | Detecting loops, finding cycle start. | Finding midpoints, palindromes. |
@@ -0,0 +1,81 @@
+# Understanding the Merge Intervals Concept
+
+Think of Merge Intervals like booking meetings in a conference room on a calendar. If you have one meeting from 1:00 PM to 3:00 PM and another meeting from 2:00 PM to 4:00 PM, they overlap. Instead of keeping them separate, you combine them into a single blocked-out block from 1:00 PM to 4:00 PM.
+
+This technique involves dealing with sets of overlapping intervals. The trick is to **sort the intervals** by their starting points first. Once sorted, any overlapping intervals will be right next to each other, allowing you to merge them in a single pass.
+
+There are two primary operations:
+1. **Merging Overlapping Intervals** (Combining intervals that intersect).
+2. **Finding Intersecting Intervals** (Finding common overlaps between lists).
+
+## Type 1: Merging Overlapping Intervals
+First, we sort the array of intervals based on their start values. Then, we take the first interval and compare its end value with the next interval's start value. If they overlap, we merge them by taking the maximum end value.
+
+### The Process Step-by-Step
+**Goal:** Merge the intervals `[[1, 3], [2, 6], [8, 10], [15, 18]]`.
+
+```plaintext
+Data: [[1, 3], [2, 6], [8, 10], [15, 18]]
+(Already sorted by start times: 1, 2, 8, 15)
+
+Step 1: Current = [1, 3]
+        Compare with [2, 6]. 
+        Does 2 <= 3? Yes! Overlap exists.
+        Merge: Start = 1, End = max(3, 6) = 6.
+        New Current = [1, 6]
+
+Step 2: Current = [1, 6]
+        Compare with [8, 10].
+        Does 8 <= 6? No! No overlap.
+        Push [1, 6] to Result.
+        New Current = [8, 10]
+
+Step 3: Current = [8, 10]
+        Compare with [15, 18].
+        Does 15 <= 10? No! No overlap.
+        Push [8, 10] to Result.
+        New Current = [15, 18]
+
+Step 4: End of list. Push final Current [15, 18] to Result.
+
+Result: [[1, 6], [8, 10], [15, 18]]
+```
+
+## Type 2: Inserting a New Interval
+When inserting a new interval into a list of already non-overlapping intervals, you iterate through the list. You add intervals that come before the new one, merge the overlapping ones by updating the new interval's bounds, and then add the remaining intervals.
+
+### The Process Step-by-Step
+**Goal:** Insert `[4, 8]` into `[[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]]`.
+
+```plaintext
+New Interval: [4, 8]
+Data: [[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]]
+
+Step 1: Compare [1, 2] with [4, 8]. Ends before 4. 
+        Add [1, 2] to Result.
+
+Step 2: Compare [3, 5] with [4, 8]. Overlaps!
+        Merge: [min(3, 4), max(5, 8)] = [3, 8].
+        New Interval is now [3, 8].
+
+Step 3: Compare [6, 7] with [3, 8]. Overlaps!
+        Merge: [min(6, 3), max(7, 8)] = [3, 8].
+        New Interval remains [3, 8].
+
+Step 4: Compare [8, 10] with [3, 8]. Overlaps!
+        Merge: [min(8, 3), max(10, 8)] = [3, 10].
+        New Interval is now [3, 10].
+
+Step 5: Compare [12, 16] with [3, 10]. Starts after 10.
+        Add merged New Interval [3, 10] to Result.
+        Add [12, 16] to Result.
+
+Result: [[1, 2], [3, 10], [12, 16]]
+```
+
+### Comparison Summary
+| Feature | Merging All Overlaps | Inserting New Interval |
+|---------|----------------------|------------------------|
+| **Prerequisite** | Must sort intervals by start time. | Existing list is already sorted. |
+| **Logic** | `next.start <= current.end` | `current.end < new.start` or `current.start > new.end` |
+| **Used For...** | Consolidating time slots, finding free time. | Adding appointments, dynamic scheduling. |
@@ -0,0 +1,66 @@
+# Understanding the Cyclic Sort Concept
+
+Think of Cyclic Sort like a group of people holding numbered tickets (from 1 to N) standing in a row of chairs, but they are completely scrambled. To fix this, you tell the first person to go to the chair that matches their ticket. They swap places with whoever is sitting there. You repeat this until the person in the first chair actually has ticket number 1. Then you move to the second chair and do the same.
+
+This pattern is highly effective when you are dealing with an array containing numbers in a given range (e.g., 1 to N, or 0 to N). Because the numbers match the array indices, we can place them at their correct index in O(N) time without using traditional O(N log N) sorting algorithms.
+
+There are two primary variations:
+1. **Finding the Missing Number**.
+2. **Finding the Duplicate Number**.
+
+## Type 1: Placing Numbers in Correct Indices
+We iterate through the array. For each number, if it is not at its correct index (i.e., `number != array[number - 1]`), we swap it with the number that is currently at its correct index.
+
+### The Process Step-by-Step
+**Goal:** Sort the array `[3, 1, 5, 4, 2]` containing numbers 1 to 5.
+
+```plaintext
+Indices:  0   1   2   3   4
+Data:    [3,  1,  5,  4,  2]
+
+Step 1: Index 0 has '3'. Correct index for '3' is 2. Swap(0, 2)
+        Data becomes: [5, 1, 3, 4, 2]
+
+Step 2: Index 0 has '5'. Correct index for '5' is 4. Swap(0, 4)
+        Data becomes: [2, 1, 3, 4, 5]
+
+Step 3: Index 0 has '2'. Correct index for '2' is 1. Swap(0, 1)
+        Data becomes: [1, 2, 3, 4, 5]
+
+Step 4: Index 0 has '1'. Correct index. Move to Index 1.
+Step 5: Index 1 has '2'. Correct index. Move to Index 2.
+Step 6: Index 2 has '3'. Correct index. Move to Index 3.
+... (All are in correct places).
+```
+
+## Type 2: Finding Missing or Duplicate Numbers
+Once the array is cyclically sorted, finding missing or duplicate numbers is trivial. We just iterate through the sorted array, and the first index that doesn't match its expected value holds the duplicate (and the missing number is the expected value of that index).
+
+### The Process Step-by-Step
+**Goal:** Find the missing number in `[4, 2, 1, 4]` (range 1 to 4).
+
+```plaintext
+Indices:  0   1   2   3
+Data:    [4,  2,  1,  4]
+
+Step 1: Index 0 has '4'. Correct index for '4' is 3. Swap(0, 3)
+        Data becomes: [4, 2, 1, 4]  <- Wait, index 3 already has a '4'. Duplicate found! 
+        Move to next index.
+
+Step 2: Index 1 has '2'. Correct index. Move to Index 2.
+Step 3: Index 2 has '1'. Correct index for '1' is 0. Swap(2, 0)
+        Data becomes: [1, 2, 4, 4]
+
+Step 4: Array is cyclically sorted as much as possible.
+        Let's scan:
+        Index 0: 1 (Matches)
+        Index 1: 2 (Matches)
+        Index 2: 4 (Mismatch! Should be 3. Missing is 3, Duplicate is 4)
+```
+
+### Comparison Summary
+| Feature | Missing Number | Duplicate Number |
+|---------|----------------|------------------|
+| **Core Action** | Swap numbers to target indices. | Swap numbers to target indices. |
+| **Detection Phase** | Scan for `array[i] != i + 1` | Same, or stop when `array[current] == array[target]` |
+| **Used For...** | Ranges 0 to N or 1 to N, finding missing numbers. | Finding single or multiple duplicates in O(N) time and O(1) space. |
@@ -0,0 +1,71 @@
+# Understanding In-Place Reversal of a LinkedList
+
+Think of reversing a LinkedList like turning a series of one-way street signs to point in the opposite direction. You start at the first sign, turn it to point behind you, move to the next sign, turn it to point to the previous one, and so on. You don't need to build a whole new road of signs; you just change where the current ones point.
+
+In code, this means we reverse the pointers of a LinkedList without using any extra memory. We rely on three pointers: `Current`, `Previous`, and `Next`.
+
+There are two primary types:
+1. **Reversing the Entire List**.
+2. **Reversing a Sub-list (a specific portion)**.
+
+## Type 1: Reversing the Entire List
+We iterate through the list. At each node, we save the next node, reverse the current node's pointer to point to the previous node, and then shift our pointers one step forward.
+
+### The Process Step-by-Step
+**Goal:** Reverse the linked list `1 -> 2 -> 3 -> null`.
+
+```plaintext
+Setup: Prev = null, Current = 1
+
+Step 1: [Current: 1]
+        Next = 1.next (which is 2)
+        1.next = Prev (which is null, so 1 -> null)
+        Prev = 1
+        Current = 2
+        (List state: 1 -> null.   Remaining: 2 -> 3 -> null)
+
+Step 2: [Current: 2]
+        Next = 2.next (which is 3)
+        2.next = Prev (which is 1, so 2 -> 1 -> null)
+        Prev = 2
+        Current = 3
+        (List state: 2 -> 1 -> null.  Remaining: 3 -> null)
+
+Step 3: [Current: 3]
+        Next = 3.next (which is null)
+        3.next = Prev (which is 2, so 3 -> 2 -> 1 -> null)
+        Prev = 3
+        Current = null
+
+Result: Current is null, loop ends. Head is now Prev (3). 
+Final list: 3 -> 2 -> 1 -> null.
+```
+
+## Type 2: Reversing a Sub-list
+If we only want to reverse from position `p` to `q`, we skip the first `p-1` nodes. We remember the node right before `p` (to connect it later to the new head of the reversed part) and remember the `p`th node itself (which will become the tail and needs to connect to `q+1`).
+
+### The Process Step-by-Step
+**Goal:** Reverse positions 2 to 4 in `1 -> 2 -> 3 -> 4 -> 5 -> null`.
+
+```plaintext
+Step 1: Skip to position p (node 2).
+        Node before p is '1' (let's call it nodeBeforeSublist).
+        Node at p is '2' (let's call it sublistWorkingTail).
+
+Step 2: Reverse nodes from position 2 to 4.
+        Reverse 2, 3, 4 just like Type 1.
+        Reversed sublist becomes: 4 -> 3 -> 2 -> null.
+
+Step 3: Reconnect.
+        nodeBeforeSublist.next = reversedHead (1 -> 4 -> 3 -> 2)
+        sublistWorkingTail.next = nodeAfterSublist (2 -> 5)
+
+Result: 1 -> 4 -> 3 -> 2 -> 5 -> null
+```
+
+### Comparison Summary
+| Feature | Entire List | Sub-list |
+|---------|-------------|----------|
+| **Traversal** | Starts from Head to end. | Skips to `p`, reverses to `q`, stops. |
+| **Pointers Needed** | `Prev`, `Current`, `Next` | `Prev`, `Current`, `Next` + references to reconnect bounds. |
+| **Complexity** | O(N) time, O(1) space. | O(N) time, O(1) space. |
@@ -0,0 +1,76 @@
+# Understanding Tree Breadth-First Search (BFS)
+
+Think of Tree BFS like exploring a corporate hierarchy level by level. You start at the top (the CEO). Before talking to any managers, you talk to all the Vice Presidents (level 1). Then, you talk to all the Directors (level 2), and finally the Managers (level 3). You never skip a level.
+
+To keep track of who to talk to next without jumping ahead, we use a **Queue** (a First-In-First-Out line, like people waiting at a grocery store).
+
+There are two primary variations:
+1. **Standard Level Order Traversal** (Left-to-Right).
+2. **Zigzag Traversal** (Alternating directions per level).
+
+## Type 1: Standard Level Order Traversal
+We push the root node into the queue. Then, we use a loop that runs as long as the queue has elements. Inside the loop, we count how many nodes are in the queue (this is the size of the current level), pop that many nodes, and push their children into the queue for the next level.
+
+### The Process Step-by-Step
+**Goal:** Traverse the tree level by level.
+Tree: 
+      1
+    /   \
+   2     3
+  / \   / \
+ 4   5 6   7
+
+```plaintext
+Step 1: Initialize Queue = [1]
+        Result = []
+
+Step 2: Queue size is 1 (Level 0).
+        Pop 1. Add 1 to Result.
+        Push children of 1 (2, 3).
+        Queue = [2, 3]
+        Result = [[1]]
+
+Step 3: Queue size is 2 (Level 1).
+        Pop 2. Add to levelResult. Push children (4, 5).
+        Pop 3. Add to levelResult. Push children (6, 7).
+        Queue = [4, 5, 6, 7]
+        Result = [[1], [2, 3]]
+
+Step 4: Queue size is 4 (Level 2).
+        Pop 4, 5, 6, 7. Push their children (none).
+        Queue = []
+        Result = [[1], [2, 3], [4, 5, 6, 7]]
+```
+
+## Type 2: Zigzag Traversal
+This is exactly the same as standard BFS, but we maintain a boolean flag that flips at each level. If the flag is true, we add the popped nodes to the current level's result array from left-to-right. If false, we add them right-to-left.
+
+### The Process Step-by-Step
+**Goal:** Zigzag traverse the same tree.
+
+```plaintext
+Step 1: Level 0 (Left-to-Right). 
+        Queue = [1]. Pop 1.
+        Level Result = [1]. 
+        Push children (2, 3). Queue = [2, 3]
+
+Step 2: Level 1 (Right-to-Left).
+        Queue size = 2. 
+        Pop 2. Insert at BEGINNING of Level Result -> [2].
+        Pop 3. Insert at BEGINNING of Level Result -> [3, 2].
+        Push children (4, 5, 6, 7). Queue = [4, 5, 6, 7]
+
+Step 3: Level 2 (Left-to-Right).
+        Queue size = 4.
+        Pop 4, 5, 6, 7. Append normally.
+        Level Result = [4, 5, 6, 7].
+
+Result: [[1], [3, 2], [4, 5, 6, 7]]
+```
+
+### Comparison Summary
+| Feature | Standard Level Order | Zigzag Traversal |
+|---------|----------------------|------------------|
+| **Data Structure** | Queue | Queue (with directional flag) |
+| **Collection Method**| Append to end of level list. | Alternate append to end / insert at front. |
+| **Used For...** | Shortest path, level averages, right-view. | Specialized UI rendering, spiral matrix logic. |