Linked Lists: Program 11 to 12

Author: deltanode

26_linked_lists/11_mid_point_runner_technique.cpp

@@ -2,14 +2,38 @@
     TOPIC: Mid Point of Linked List 
            (Runner Technique)
 
-    - Approach-I: Calculate length of linked list & Iterate till "length/2".
+    - Approach-I: Calculate length of linked list & then Iterate till "length/2".
                   So, time = l + l/2
                   Complexity O(N)
 
-    - Approach-II:  Runner Technique: we will keep 2 pointers, 
-                    Slow pointer [It will move by one step] 
-                    Fast pointer [It will move by two steps]
-                    
+    - Approach-II: With Runner Technique we can calculte mid point in single pass (i.e single iteration)
+                   We will keep 2 pointers, 
+                   - Slow pointer [It will move by 1 step] 
+                   - Fast pointer [It will move by 2 steps]
+
+                    Fast 2x  --------------------------------> |>
+                    Slow 1x  ---------------->                 |
+                             __________________________________|
+                          Start              Mid              End
+                  
+                  Eg: - For Odd number of nodes
+                         F             F             F                 // F: Fast pointer (Speed 2x)
+                         1  ->  2  ->  3  ->  4  ->  5
+                         S      S      S                               // S: Slow Pointer (Speed 1x)
+                                      [mid]
+
+                      - For Even number of nodes
+                        Method 1:
+                                  F             F              F
+                                  1  ->  2  ->  3  ->  4  ->  NULL
+                                  S      S      S
+                                              [mid]
+
+                        Method 2: [Start "Fast pointer" 1 position ahead of "Slow pointer"]
+                                         F             F
+                                  1  ->  2  ->  3  ->  4
+                                  S      S
+                                       [mid]
 */
 
 
@@ -380,9 +404,10 @@ Node* recursive_reverse(Node *head)
 }
 
 
+// Finding the mid point of linked list
 Node* midpoint(Node *head)
 {
-    // linked list with 1 or 0 node
+    // linked list with 0 or 1 node
     if(head == NULL or head->next == NULL)
     {
         return head;
@@ -391,13 +416,13 @@ Node* midpoint(Node *head)
     Node *slow = head;
     Node *fast = head->next;
 
-    while(fast != NULL and fast->next != NULL)
+    while(fast != NULL and fast->next != NULL)   // checking 2 cases for fast pointer bcz fast takes 2 steps
     {
-        fast = fast->next->next;
-        slow = slow->next;
+        fast = fast->next->next;      // moving 2 steps
+        slow = slow->next;            // moving 1 step
     }
 
-    return slow;
+    return slow;       // returning the position where slow pointer stops (i.e mid point)
 }
 
 
@@ -425,12 +450,12 @@ int main()
 /* 
 OUTPUT:
 
-Case 1
+Case 1 [For Odd number of nodes in linked list]
     Enter Elements [Press -1 to Exit] : 1 2 3 4 5 -1
     Linked List                       : 5 -> 4 -> 3 -> 2 -> 1
     Linked List [Midpoint]            : 3
 
-Case 2
+Case 2 [For Even number of nodes in linked list]
     Enter Elements [Press -1 to Exit] : 1 2 3 4 -1
     Linked List                       : 4 -> 3 -> 2 -> 1
     Linked List [Midpoint]            : 3