update on Linked lists

Author: Blooverh

DataAndAlgoL/Chp3LinkedLists/ExchangeAdjacenNodes.java

@@ -1,6 +1,6 @@
 package DataAndAlgoL.Chp3LinkedLists;
 
-//PROBLEM 40 EXCHANGE THE ADJACEN ELEMENTS
+//PROBLEM 40 EXCHANGE THE ADJACENT ELEMENTS
 public class ExchangeAdjacenNodes {
     public ListNode exchangeAdjNode(ListNode head){
         ListNode temp = new ListNode(0); //temporary node to point to head

DataAndAlgoL/Chp3LinkedLists/Problem12.java

@@ -4,6 +4,8 @@
 
 /*Check whether the given linked list is null-terminated or not
  * If there is a cycle find the start node of the loop
+ * 
+ * OBJECTIVE IS TO RETURN THE NODE THAT STARTS THE CYCLE SINCE WE ALREADY KNOW THERE IS CYCLE IN THIS LINKED LIST 
  */
 /*SOlUTION: extended version of Floyd cycle finding algorithm
  * After finding the loop in the
@@ -29,6 +31,7 @@ public static ListNode findBeginOfLoop(ListNode head){
         ListNode fast=head;
         ListNode slow=head;
         boolean loopExists=false;
+        //We find if a loop exists
         while(fast != null && fast.getNext() != null){ //while linked list is not empty and head is not null
             fast= fast.getNext().getNext();// double jump, travels at 2x rather than once
             slow= slow.getNext();
@@ -38,14 +41,15 @@ public static ListNode findBeginOfLoop(ListNode head){
             }
         }
 
+        //once we find that the loop exists we start slow pointer from head and iterate once as well as the fast pointer but at its current position
         if(loopExists){ //while loop is is
             slow=head; //get slow back to head 
             while(slow != fast){ //while slow and fast are not equal now both travel one jump at time until both pointers are in the loop at the start loop position
                 slow=slow.getNext();
                 fast=fast.getNext();
             }        
-
-            return fast; //return the pointer where the cycle starts
+            //once both slow and fast are equals, we return the node fast which indicates its the first node that starts the cycle
+            return fast; 
         }
 
         return null;

DataAndAlgoL/Chp3LinkedLists/Problem15.java

@@ -1,6 +1,10 @@
 package DataAndAlgoL.Chp3LinkedLists;
 /*
  * Check whether the given linked list is NULL-terminated. If there is a cycle, find the length of the loop.
+ * 
+ * OBJECTIVE IS TO FIND THE AMOUNT OF NODES IN THE LOOP SIDE, 
+ * WE NEED TO FIND IF THERE IS A LOOP. WE CAN START COUNTING HOW MANY NODES ARE IN THE LOOP
+ * BY HAVING ONE OF THE POINTERS TRAVELING THROUGH THE LOOP UNTIL IT FINDS THE OTHER POINTER THAT STAYED STATIONARY 
  */
 /*
  * This solution is also an extension of the basic cycle detection problem. After finding the

DataAndAlgoL/Chp3LinkedLists/Problem16.java

@@ -1,6 +1,10 @@
 package DataAndAlgoL.Chp3LinkedLists;
 /* Insert a node in a sorted linked list
  * Solution: Traverse the list and find a position for the element and insert it.
+ * 
+ * OBJECTIVE -> COMPARE BOTH THE NODE WE WANT TO INSERT PLUS EVERY NODE IN THE LIST 
+ * UNTIL WE FIND THE NODE BIGGER THAN THE NEW NODE 
+ * THEN WE SWAP THEM 
  */
 public class Problem16 {
     public static void main(String[] args) {

DataAndAlgoL/Chp3LinkedLists/Problem2.java

@@ -5,23 +5,26 @@ public static void main(String[] args) {
 
     }
 
+    //O(max(m,n)) is the run time complexity for this problem
     public static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
         int l1=0;
         int l2=0;
         int diff=0;
         ListNode head1= headA;
         ListNode head2= headB;
-
+        //Finding the length of both list and see which one is bigger leads to O(max(n,m))
+        //O(n) Iterates throught one list of n inputs
         while(head1 != null){
             l1++;
             head1= head1.next;
         }
-
+        // O(m) Iterates throught a second list of m inputs 
         while(head2 != null){
             l2++;
             head2=head2.next;
         }
 
+        //Taking the different is done in O(1)
         if(l1 < l2){
             head1=headB;
             head2=headA;
@@ -32,6 +35,7 @@ public static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
             diff= l1-l2;
         }
 
+        // O(diff) for making diff steps in longer list 
         for(int i=0; i< diff; i++){
             head1= head1.next;
             while(head1 != null && head2 != null){

DataAndAlgoL/Chp3LinkedLists/Problem24.java

@@ -0,0 +1,37 @@
+package DataAndAlgoL.Chp3LinkedLists;
+
+/*
+ * How can we find the middle of a linked list !!
+ * With just one scan which is the faster algorithm
+ * 
+ * OBJECTIVE -> USE 2 POINTERS, ONE GOES TWICE FAST THAN THE OTHER ONCE FAST NODE REACHES NULL POINTER 
+ * SLOW POINTER WILL BE AT THE MIDDLE POSITION
+ * 
+ * NOTE: IF LIST HAS AN EVEN LENGTH MIDDLE NODE WILL BE N/2
+ */
+public class Problem25_28 {
+    public static void main(String[] args) {
+        
+    }
+
+    public static ListNode findMid(ListNode head){
+        ListNode fast= head;
+        ListNode slow= head;
+        int i=0;
+
+        //Loops until the tail is reached
+        while(fast.next!= null){
+            if(i==0){ //increment only 1st pointer 
+                fast=fast.next;
+                i=1;
+            }else if(i==1){
+                //increement both pointers
+                fast=fast.next;
+                slow= slow.next;
+                i=0;
+            }
+        }
+
+        return slow;
+    }
+}

DataAndAlgoL/Chp3LinkedLists/Problem25_28.java

@@ -0,0 +1,55 @@
+package DataAndAlgoL.Chp3LinkedLists;
+
+
+/*
+ * Find the Nth Node from the end of a linked list 
+ * Return that node once foud
+ */
+public class Problem2_5_6 {
+    public static void main(String[] args) {
+        
+    }
+
+    //solution from problem 5
+    public static ListNode NthNodeFromEnd(ListNode head, int NthNode){
+        ListNode pTemp=head; //temporary node 
+        ListNode pNthNode= null; //counts the number of nodes
+        // pNthNode only starts movinf after pTemp  has made n moves 
+
+        for(int i=1; i<NthNode; i++){
+            if(pTemp != null){
+                pTemp= pTemp.getNext(); //if temporary pointer is not null get the next node until we find the end of the list 
+            }
+        }
+        //pTemp node moves forward until it reaches the end of the list
+        while(pTemp!=null){
+            if(pNthNode==null){
+                pNthNode= head;
+            }else{
+                pNthNode=pNthNode.getNext();
+            }
+
+            pTemp= pTemp.getNext();
+        }
+
+        if(pNthNode != null){
+            return pNthNode;
+        }
+
+        return null;
+    }
+
+    //Using Recursion which is O(2n) = O(n), however small than previous one due to recursion call
+    public ListNode NthNodeFromEnd2(ListNode head, int Nth){
+        int counter=0;//counts the ietarions up to the node 
+        if(head != null){
+            NthNodeFromEnd2(head.next, Nth); //recursion call, where if head is not equal to null, increase counter
+            counter++;
+            if(Nth == counter){// If counter is equal to Nth then return the head
+                return head;
+            }
+        }
+
+        return null; //return null if there is no element in linked list
+    }
+}

DataAndAlgoL/Chp3LinkedLists/Problem2_5_6.java

@@ -0,0 +1,32 @@
+package DataAndAlgoL.Chp3LinkedLists;
+
+/*
+ * EXERCISE 7 BUT SOLUTION FOR EXERCISE 10
+ * Check whether the given linked list is either NULL-terminated or ends in a cycle 
+ */
+public class Problem7_10 {
+    public static void main(String[] args) {
+        
+    }
+
+    //O(n) Solution -> Original Floyd Cycle algorithm (slow and fast pointer), once they enter a cycle they are expected to meet, which denotes a loop
+    public static boolean findLoopIfExists(ListNode head){
+        ListNode slow= head;
+        ListNode fast= head;
+
+        //If the 2 next pointers of fast are not null 
+        //then fast jumps 2 nodes and slow jumps one node
+        while(fast.next != null && fast.next.next != null){ 
+            fast= fast.next.next;
+            slow=slow.next;
+
+            if(slow == fast){ //if there is no null pointers found; however slow and fast are equal, then there is a cycle and return true for existence of a loop
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+}