remove duplicates in sorted linked list done + code refactoring

Author: Ram swaroop

src/me/ramswaroop/linkedlists/CloneWithRandPointers.java

@@ -13,8 +13,17 @@
  */
 public class CloneWithRandPointers<E extends Comparable<E>> extends DoubleLinkedList<E> {
 
-    public static <E extends Comparable<E>> DoubleLinkedList<E> clone(DoubleLinkedNode<E> node) {
-        DoubleLinkedNode<E> curr = node;
+    /**
+     * Clones a linked list with next pointer pointing to the
+     * next node and prev pointer pointing to any random node.
+     *
+     * @param list
+     * @param <E>
+     * @return
+     */
+    public static <E extends Comparable<E>> DoubleLinkedList<E> clone(DoubleLinkedList<E> list) {
+        DoubleLinkedNode<E> firstNode = list.getNode(0);
+        DoubleLinkedNode<E> curr = firstNode;
 
         // copy each node and insert after it
         while (curr != null) {
@@ -24,16 +33,16 @@ public static <E extends Comparable<E>> DoubleLinkedList<E> clone(DoubleLinkedNo
         }
 
         // copy all random pointers from original node to the copied node
-        curr = node;
+        curr = firstNode;
         while (curr != null && curr.next != null) {
             curr.next.prev = (curr.prev != null) ? curr.prev.next : null;
             curr = curr.next.next;
         }
 
         // separate the copied nodes into a different linked list
-        curr = node;
-        DoubleLinkedNode<E> cloneHead = node.next;
-        DoubleLinkedNode<E> dupNode = cloneHead;
+        curr = firstNode;
+        DoubleLinkedNode<E> cloneHead = firstNode.next;
+        DoubleLinkedNode<E> dupNode;
         while (curr != null && curr.next != null) {
             dupNode = curr.next;
             curr.next = (dupNode != null) ? dupNode.next : null;
@@ -54,11 +63,16 @@ public static void main(String a[]) {
         linkedList.getNode(1).prev = linkedList.getNode(2);
         linkedList.getNode(2).prev = linkedList.getNode(0);
         linkedList.getNode(3).prev = linkedList.getNode(1);
+        System.out.println("======Original======");
         linkedList.printList();
-        DoubleLinkedList<Integer> clonedList = clone(linkedList.getNode(0));
+        DoubleLinkedList<Integer> clonedList = clone(linkedList);
+        System.out.println("======Cloned======");
+        clonedList.printList();
+        System.out.println("======Cloned (Modified)======");
         clonedList.set(0, 234);
         clonedList.set(1, 567);
         clonedList.printList();
+        System.out.println("======Original======");
         linkedList.printList();
     }
 }

src/me/ramswaroop/linkedlists/DetectLoop.java

@@ -27,11 +27,12 @@ public class DetectLoop<E extends Comparable<E>> extends SingleLinkedList<E> {
      * Time:    O(n)
      * Space:   O(1)
      *
-     * @param node
+     * @param list
      * @return
      */
-    public static <E extends Comparable<E>> boolean isLoopPresent(SingleLinkedNode<E> node) {
-        SingleLinkedNode<E> prev = node, curr = node;
+    public static <E extends Comparable<E>> boolean isLoopPresent(SingleLinkedList<E> list) {
+        SingleLinkedNode<E> firstNode = list.getNode(0);
+        SingleLinkedNode<E> prev = firstNode, curr = firstNode;
         while (curr != null && curr.next != null) {
             prev = prev.next;
             curr = curr.next.next;
@@ -73,6 +74,6 @@ public static void main(String a[]) {
         linkedList.add(44);
         linkedList.add(55);
         linkedList.getNode(4).next = linkedList.getNode(3);
-        System.out.println(isLoopPresent(linkedList.getNode(0)));
+        System.out.println(isLoopPresent(linkedList));
     }
 }

src/me/ramswaroop/linkedlists/IsPalindrome.java

@@ -18,19 +18,20 @@ public class IsPalindrome<E extends Comparable<E>> extends SingleLinkedList<E> {
      * Uses Stack to test whether a linked list starting
      * from {@param node} is palindrome or not.
      *
-     * @param node
+     * @param list
      * @return
      */
-    public static <E extends Comparable<E>> boolean isPalindrome(SingleLinkedNode<E> node) {
-        SingleLinkedNode<E> curr = node;
+    public static <E extends Comparable<E>> boolean isPalindrome(SingleLinkedList<E> list) {
+        SingleLinkedNode<E> head = list.getNode(0);
+        SingleLinkedNode<E> curr = head;
         Stack<SingleLinkedNode<E>> stack = new LinkedStack<>();
 
         while (curr != null) {
             stack.push(curr);
             curr = curr.next;
         }
 
-        curr = node;
+        curr = head;
 
         while (curr != null) {
             if (curr.item != stack.pop().item) {
@@ -72,7 +73,7 @@ public static void main(String a[]) {
         linkedList.add(11);
         linkedList.add(00);
         linkedList.printList();
-        System.out.println(isPalindrome(linkedList.getNode(0)));
+        System.out.println(isPalindrome(linkedList));
         linkedList.printList();
         System.out.println(linkedList.isPalindromeRecursive(linkedList.getNode(0)));
     }

src/me/ramswaroop/linkedlists/MiddleNode.java

@@ -12,9 +12,9 @@
  */
 public class MiddleNode<E extends Comparable<E>> extends SingleLinkedList<E> {
 
-    public static <E extends Comparable<E>> SingleLinkedNode<E> getMiddleNode(SingleLinkedNode<E> node) {
-        SingleLinkedNode<E> slow = node;
-        SingleLinkedNode<E> fast = node;
+    public static <E extends Comparable<E>> SingleLinkedNode<E> getMiddleNode(SingleLinkedList<E> list) {
+        SingleLinkedNode<E> slow = list.getNode(0);
+        SingleLinkedNode<E> fast = list.getNode(0);
         while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
@@ -33,6 +33,6 @@ public static void main(String a[]) {
         linkedList.add(66);
         linkedList.add(77);
         linkedList.add(88);
-        System.out.println(getMiddleNode(linkedList.getNode(0)).item);
+        System.out.println(getMiddleNode(linkedList).item);
     }
 }

src/me/ramswaroop/linkedlists/NthNodeFromLast.java

@@ -12,9 +12,9 @@
  */
 public class NthNodeFromLast<E extends Comparable<E>> extends SingleLinkedList<E> {
 
-    public static <E extends Comparable<E>> SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedNode<E> node, int n) {
-        SingleLinkedNode<E> slow = node;
-        SingleLinkedNode<E> fast = node;
+    public static <E extends Comparable<E>> SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedList<E> list, int n) {
+        SingleLinkedNode<E> slow = list.getNode(0);
+        SingleLinkedNode<E> fast = list.getNode(0);
         // move the fast reference ahead of slow reference by 'n' nodes
         for (int i = 0; i < n; i++) {
             // assert length of linkedlist > n
@@ -38,6 +38,6 @@ public static void main(String a[]) {
         linkedList.add(66);
         linkedList.add(77);
         linkedList.add(88);
-        System.out.println(getNthNodeFromLast(linkedList.getNode(0), 3).item);
+        System.out.println(getNthNodeFromLast(linkedList, 3).item);
     }
 }

src/me/ramswaroop/linkedlists/RemoveDuplicates.java

@@ -0,0 +1,53 @@
+package me.ramswaroop.linkedlists;
+
+import me.ramswaroop.common.SingleLinkedList;
+import me.ramswaroop.common.SingleLinkedNode;
+
+/**
+ * Created by IntelliJ IDEA.
+ *
+ * @author: ramswaroop
+ * @date: 6/18/15
+ * @time: 2:35 PM
+ */
+public class RemoveDuplicates<E extends Comparable<E>> extends SingleLinkedList<E> {
+
+    /**
+     * Removes duplicates in a sorted linked list
+     * by traversing it once.
+     *
+     * @param list
+     * @param <E>
+     */
+    public static <E extends Comparable<E>> void removeDuplicates(SingleLinkedList<E> list) {
+        SingleLinkedNode<E> firstNode = list.getNode(0), curr = firstNode;
+        int index = 0;
+        while (curr != null) {
+            while (curr.next != null && curr.item == curr.next.item) {
+                list.remove(index + 1);
+            }
+            index++;
+            curr = curr.next;
+        }
+    }
+
+    public static void main(String a[]) {
+        SingleLinkedList<Integer> linkedList = new SingleLinkedList<>();
+        linkedList.add(00);
+        linkedList.add(00);
+        linkedList.add(00);
+        linkedList.add(11);
+        linkedList.add(11);
+        linkedList.add(22);
+        linkedList.add(22);
+        linkedList.add(22);
+        linkedList.add(22);
+        linkedList.add(33);
+        linkedList.add(33);
+        linkedList.add(33);
+        linkedList.add(33);
+        linkedList.printList();
+        removeDuplicates(linkedList);
+        linkedList.printList();
+    }
+}