Linked List problems

Author: abhiabhi

src/main/java/com/arrays/InversionCountInArray_MergeSort.java

@@ -25,21 +25,21 @@
 public class InversionCountInArray_MergeSort {
 
     // Merge two sorted subarrays arr[low .. mid] and arr[mid + 1 .. high]
-    public static int merge(int[] arr, int leftIndex, int midIndex, int rightIndex) {
+    public static int merge(int[] arr, int start, int mid, int end) {
         // Left subarray
-        int[] left = Arrays.copyOfRange(arr, leftIndex, midIndex + 1);
+        int[] left = Arrays.copyOfRange(arr, start, mid + 1);
 
         // Right subarray
-        int[] right = Arrays.copyOfRange(arr, midIndex + 1, rightIndex + 1);
+        int[] right = Arrays.copyOfRange(arr, mid + 1, end + 1);
 
-        int leftCursor = 0, rightCursor = 0, current = leftIndex, swaps = 0;
+        int leftCursor = 0, rightCursor = 0, current = start, swaps = 0;
 
         while (leftCursor < left.length && rightCursor < right.length) {
             if (left[leftCursor] <= right[rightCursor])
                 arr[current++] = left[leftCursor++];
             else {
                 arr[current++] = right[rightCursor++];
-                swaps += (midIndex + 1) - (leftIndex + leftCursor);  /**important*/
+                swaps += mid + 1 - leftCursor; /**important*/
             }
         }
 

src/main/java/com/linkedlist/DetectLoopInLinkedList_LoopInLinkedList.java

@@ -0,0 +1,41 @@
+package com.linkedlist;
+
+import com.linkedlist.model.Node;
+
+public class DetectLoopInLinkedList_LoopInLinkedList {
+
+    public static void main(String args[]) {
+
+        Node node1 = new Node(4);
+        Node node2 = new Node(6);
+        Node node3 = new Node(8);
+        Node node4 = new Node(12);
+        Node node5 = new Node(14);
+
+        Node startNode = node1;
+
+        node1.setNext(node2);
+        node2.setNext(node3);
+        node3.setNext(node4);
+        node4.setNext(node5);
+        node5.setNext(node2);
+
+        System.out.println("Loop:" + detectLoop(startNode));
+
+    }
+
+    private static boolean detectLoop(Node startNode) {
+        Node slowPointer = startNode; // Initially ptr1 is at starting location.
+        Node fastPointer = startNode; // Initially ptr2 is at starting location.
+
+        while (fastPointer != null && fastPointer.getNext() != null) { // If ptr2 encounters NULL, it means there is no Loop in Linked list.
+            slowPointer = slowPointer.getNext(); // ptr1 moving one node at at time
+            fastPointer = fastPointer.getNext().getNext(); // ptr2 moving two nodes at at time
+
+            if (slowPointer == fastPointer) // if ptr1 and ptr2 meets, it means linked list contains loop.
+                return true;
+        }
+        return false;
+    }
+
+}

src/main/java/com/linkedlist/LoopInLinkedList_FloydCycleDetectionAlgo.html

@@ -0,0 +1,77 @@
+package com.linkedlist;
+
+import com.linkedlist.model.Node;
+
+/**
+ * Time complexity : O ( k N ) O(kN) O(kN) where k is the number of linked lists.
+ * We can merge two sorted linked list in O ( n ) O(n) O(n) time where n is the total number of nodes in two lists
+ */
+public class MergeTwoSortedLinkedLists {
+
+    public static void main (String args[]){
+        Node node1 = new Node(4);
+        Node node2 = new Node(6);
+        Node node3 = new Node(8);
+        Node node4 = new Node(12);
+        Node node5 = new Node(14);
+
+        node1.setNext(node2);
+        node2.setNext(node3);
+        node3.setNext(node4);
+        node4.setNext(node5);
+        node5.setNext(null);
+
+        Node list1 = node1;
+
+        Node node11 = new Node(41);
+        Node node21 = new Node(61);
+        Node node31 = new Node(81);
+        Node node41 = new Node(121);
+        Node node51 = new Node(141);
+
+        node11.setNext(node21);
+        node21.setNext(node31);
+        node31.setNext(node41);
+        node41.setNext(node51);
+        node51.setNext(null);
+
+        Node list2 = node11;
+
+        mergeSortedList(list1, list2);
+        printList( mergeSortedList(list1, list2));
+
+    }
+
+    private static void printList(Node mergeSortedList) {
+        while(mergeSortedList!= null) {
+            System.out.println(mergeSortedList.getData());
+            mergeSortedList = mergeSortedList.getNext();
+        }
+
+    }
+
+    private static Node mergeSortedList(Node list1, Node list2) {
+
+            if(list1 == null) return list2;
+            if(list2 == null) return list1;
+
+            Node result ;
+
+            if(list1.getData() < list2.getData())
+            {
+                result = new Node(list1.getData());
+                result.setNext(mergeSortedList(list1.getNext(), list2));
+            }
+            else
+            {
+                result = new Node(list2.getData());
+                result.setNext(mergeSortedList(list1, list2.getNext()));
+            }
+
+            return result;
+
+        }
+
+
+    }
+