merge sort for double linked list: done

Author: Ram swaroop

src/me/ramswaroop/linkedlists/MergeSort.java

@@ -104,6 +104,7 @@ public static <E extends Comparable<E>> SingleLinkedNode<E> mergeTwoSortedLists(
             curr = curr.next;
         }
 
+        // return the node next to the dummy node
         return head.next;
     }
 

src/me/ramswaroop/linkedlists/MergeSortDoubleLinkedList.java

@@ -0,0 +1,131 @@
+package me.ramswaroop.linkedlists;
+
+import me.ramswaroop.common.DoubleLinkedList;
+import me.ramswaroop.common.DoubleLinkedNode;
+
+/**
+ * Created by IntelliJ IDEA.
+ *
+ * @author: ramswaroop
+ * @date: 7/7/15
+ * @time: 4:34 PM
+ */
+public class MergeSortDoubleLinkedList {
+
+    /**
+     * Merge sort for linked list starting at {@param node}.
+     *
+     * @param node
+     * @param <E>
+     * @return
+     */
+    public static <E extends Comparable<E>> DoubleLinkedNode<E> mergeSort(DoubleLinkedNode<E> node) {
+        if (node == null || node.next == null) return node;
+
+        DoubleLinkedNode<E> middleNode, head1, head2;
+
+        middleNode = divideInTwoHalves(node);
+
+        head1 = mergeSort(node);
+        head2 = mergeSort(middleNode);
+
+        return mergeTwoSortedLists(head1, head2);
+
+    }
+
+
+    /**
+     * Divides a linked list starting from {@param node} into 2 halves
+     * and returns the starting {@code node} of the second half.
+     *
+     * @param node
+     * @param <E>
+     * @return
+     */
+    public static <E extends Comparable<E>> DoubleLinkedNode<E> divideInTwoHalves(DoubleLinkedNode<E> node) {
+        DoubleLinkedNode<E> slow = node, fast = node, prev = slow;
+
+        if (node == null || node.next == null) {
+            return null;
+        }
+
+        while (fast != null && fast.next != null) {
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        prev.next = null;
+        return slow;
+    }
+
+
+    /**
+     * Merges two sorted lists starting at {@param node1} and {@param node2}
+     * into one and returns its starting node.
+     * <p/>
+     * This method is similar to {@link MergeTwoSortedLists#mergeTwoSortedLists}
+     *
+     * @param node1
+     * @param node2
+     * @param <E>
+     * @return
+     */
+    public static <E extends Comparable<E>> DoubleLinkedNode<E> mergeTwoSortedLists(DoubleLinkedNode<E> node1,
+                                                                                    DoubleLinkedNode<E> node2) {
+        DoubleLinkedNode<E> curr1 = node1, curr2 = node2, head, curr;
+
+        if (node1 == null && node2 == null) return null;
+
+        head = curr = new DoubleLinkedNode<>(null); // dummy node
+
+        while (curr1 != null || curr2 != null) {
+            // handle cases where either of the list run out first
+            if (curr1 == null) {
+                curr.next = curr2;
+                curr2.prev = curr;
+                curr2 = curr2.next;
+            } else if (curr2 == null) {
+                curr.next = curr1;
+                curr1.prev = curr;
+                curr1 = curr1.next;
+            } else if (curr1.item.compareTo(curr2.item) < 0) {  // advance the current pointer of the
+                // list having smaller {@code item}
+                curr.next = curr1;
+                curr1.prev = curr;
+                curr1 = curr1.next;
+            } else if (curr1.item.compareTo(curr2.item) > 0) {
+                curr.next = curr2;
+                curr2.prev = curr;
+                curr2 = curr2.next;
+            } else { // both nodes are equal so add both to the result
+                curr.next = curr1;
+                curr = curr.next;
+                curr1 = curr1.next;
+                curr1.prev = curr;
+                curr.next = curr2;
+                curr2.prev = curr;
+                curr2 = curr2.next;
+            }
+
+            curr = curr.next;
+        }
+
+        // the dummy node should be unlinked
+        head.next.prev = null;
+
+        // return the node next to the dummy node
+        return head.next;
+    }
+
+    public static void main(String a[]) {
+        DoubleLinkedList<Integer> linkedList = new DoubleLinkedList<>();
+        linkedList.add(21);
+        linkedList.add(33);
+        linkedList.add(89);
+        linkedList.add(21);
+        linkedList.add(44);
+        linkedList.add(67);
+        linkedList.printList();
+        linkedList.printList(mergeSort(linkedList.head));
+    }
+}