Added remove duplicates in linked list

Author: rampatra

src/main/java/com/ctci/linkedlists/RemoveDuplicates.java

@@ -0,0 +1,94 @@
+package com.ctci.linkedlists;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author rampatra
+ * @since 21/11/2018
+ */
+public class RemoveDuplicates {
+
+    /**
+     * Removes duplicates in an unsorted linked list by using additional memory
+     * and two references.
+     * <p>
+     * If asked not to use any additional memory then you can
+     * loop through the list for each node and check for repeated elements but bear
+     * in mind that the time complexity of this would be O(n^2) where n is the number
+     * of nodes in the linked list.
+     *
+     * @param head reference to the head of the linked list
+     */
+    private static void removeDuplicatesFromUnsortedList(Node head) {
+        Set<Integer> valuesInList = new HashSet<>();
+        Node curr = head;
+        Node prev = curr;
+        while (curr != null) {
+            if (valuesInList.contains(curr.val)) {
+                prev.next = curr.next;
+            }
+            valuesInList.add(curr.val);
+            prev = curr;
+            curr = curr.next;
+        }
+    }
+
+    private static void printList(Node head) {
+        if (head == null) return;
+
+        Node curr = head;
+        while (curr.next != null) {
+            System.out.print(curr.val + "->");
+            curr = curr.next;
+        }
+        System.out.println(curr.val);
+    }
+
+    public static void main(String[] args) {
+        Node l1 = new Node(1);
+        l1.next = new Node(2);
+        l1.next.next = new Node(3);
+        l1.next.next.next = new Node(4);
+        l1.next.next.next.next = new Node(5);
+        l1.next.next.next.next.next = new Node(5);
+        System.out.print("With dups: ");
+        printList(l1);
+        removeDuplicatesFromUnsortedList(l1);
+        System.out.print("Without dups: ");
+        printList(l1);
+
+        Node l2 = new Node(1);
+        l2.next = new Node(1);
+        l2.next.next = new Node(2);
+        l2.next.next.next = new Node(3);
+        l2.next.next.next.next = new Node(4);
+        l2.next.next.next.next.next = new Node(5);
+        System.out.print("\nWith dups: ");
+        printList(l2);
+        removeDuplicatesFromUnsortedList(l2);
+        System.out.print("Without dups: ");
+        printList(l2);
+
+        Node l3 = new Node(1);
+        l3.next = new Node(2);
+        l3.next.next = new Node(3);
+        l3.next.next.next = new Node(3);
+        l3.next.next.next.next = new Node(4);
+        l3.next.next.next.next.next = new Node(5);
+        System.out.print("\nWith dups: ");
+        printList(l3);
+        removeDuplicatesFromUnsortedList(l3);
+        System.out.print("Without dups: ");
+        printList(l3);
+    }
+}
+
+class Node {
+    int val;
+    Node next;
+
+    Node(int val) {
+        this.val = val;
+    }
+}

src/main/java/com/rampatra/linkedlists/RemoveDuplicates.java

@@ -3,8 +3,8 @@
 import com.rampatra.common.SingleLinkedList;
 import com.rampatra.common.SingleLinkedNode;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * Created by IntelliJ IDEA.
@@ -24,21 +24,19 @@ public class RemoveDuplicates {
      */
     public static <E extends Comparable<E>> void removeDuplicates(SingleLinkedList<E> list) {
         SingleLinkedNode<E> curr = list.getNode(0);
-        int index = 0;
         while (curr != null) {
             // inner while loop for removing multiple duplicates
             while (curr.next != null && curr.item == curr.next.item) {
-                list.remove(index + 1);
+                curr.next = curr.next.next;
             }
-            index++;
             curr = curr.next;
         }
     }
 
     /**
      * Removes duplicates from an unsorted linked list.
      * <p/>
-     * This method uses {@link HashMap}, another
+     * This method uses {@link HashSet}, another
      * way is that you can sort it using merge sort and then
      * call {@link #removeDuplicates}.
      *
@@ -47,48 +45,48 @@ public static <E extends Comparable<E>> void removeDuplicates(SingleLinkedList<E
      */
     public static <E extends Comparable<E>> void removeDuplicatesFromUnsortedList(SingleLinkedList<E> list) {
         SingleLinkedNode<E> curr = list.getNode(0);
-        Map<E, Boolean> map = new HashMap<>();
-        int index = 0;
+        SingleLinkedNode<E> prev = curr;
+        Set<E> itemsInList = new HashSet<>();
         while (curr != null) {
-            if (map.get(curr.item) == null) {
-                map.put(curr.item, true);
-                index++;
-            } else {
-                list.remove(index);
+            if (itemsInList.contains(curr.item)) {
+                itemsInList.add(curr.item);
+            } else { // delete duplicate element
+                prev.next = curr.next;
             }
+            prev = curr;
             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.add(0);
+        linkedList.add(0);
+        linkedList.add(0);
+        linkedList.add(1);
+        linkedList.add(1);
+        linkedList.add(2);
+        linkedList.add(2);
+        linkedList.add(2);
+        linkedList.add(2);
+        linkedList.add(3);
+        linkedList.add(3);
+        linkedList.add(3);
+        linkedList.add(3);
         linkedList.printList();
         removeDuplicates(linkedList);
         linkedList.printList();
 
         SingleLinkedList<Integer> linkedList2 = new SingleLinkedList<>();
-        linkedList2.add(00);
-        linkedList2.add(00);
-        linkedList2.add(22);
-        linkedList2.add(11);
-        linkedList2.add(44);
-        linkedList2.add(22);
-        linkedList2.add(66);
-        linkedList2.add(77);
-        linkedList2.add(66);
+        linkedList2.add(0);
+        linkedList2.add(0);
+        linkedList2.add(2);
+        linkedList2.add(1);
+        linkedList2.add(4);
+        linkedList2.add(2);
+        linkedList2.add(6);
+        linkedList2.add(7);
+        linkedList2.add(6);
         linkedList2.printList();
         removeDuplicatesFromUnsortedList(linkedList2);
         linkedList2.printList();