intersection of 2 lists done + code refactoring

Author: Ram swaroop

src/me/ramswaroop/common/DoubleLinkedList.java

@@ -198,7 +198,14 @@ public void printList() {
 
     public static <E extends Comparable<E>> DoubleLinkedList<E> getLinkedList(DoubleLinkedNode<E> node) {
         DoubleLinkedList<E> linkedList = new DoubleLinkedList<>();
+        // set head
         linkedList.head = node;
+        // set size
+        DoubleLinkedNode<E> curr = node;
+        while (curr != null) {
+            linkedList.size++;
+            curr = curr.next;
+        }
         return linkedList;
     }
 

src/me/ramswaroop/common/SingleLinkedList.java

@@ -174,6 +174,19 @@ public void printList() {
         out.println(curr.item + "]");
     }
 
+    public static <E extends Comparable<E>> SingleLinkedList<E> getLinkedList(SingleLinkedNode<E> node) {
+        SingleLinkedList<E> linkedList = new SingleLinkedList<>();
+        // set head
+        linkedList.head = node;
+        // set size
+        SingleLinkedNode<E> curr = node;
+        while (curr != null) {
+            linkedList.size++;
+            curr = curr.next;
+        }
+        return linkedList;
+    }
+
     private SingleLinkedNode<E> getPredecessorNode(int index) {
         return getNode(index - 1);
     }

src/me/ramswaroop/linkedlists/CloneWithRandPointers.java

@@ -9,6 +9,7 @@
  * @author: ramswaroop
  * @date: 6/20/15
  * @time: 1:00 PM
+ * @see: http://www.geeksforgeeks.org/a-linked-list-with-next-and-arbit-pointer/
  */
 public class CloneWithRandPointers<E extends Comparable<E>> extends DoubleLinkedList<E> {
 
@@ -55,7 +56,6 @@ public static void main(String a[]) {
         linkedList.getNode(3).prev = linkedList.getNode(1);
         linkedList.printList();
         DoubleLinkedList<Integer> clonedList = clone(linkedList.getNode(0));
-        clonedList.size = 4;
         clonedList.set(0, 234);
         clonedList.set(1, 567);
         clonedList.printList();

src/me/ramswaroop/linkedlists/IntersectionOfTwoLists.java

@@ -0,0 +1,67 @@
+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: 10:34 PM
+ */
+public class IntersectionOfTwoLists<E extends Comparable<E>> extends SingleLinkedList<E> {
+
+
+    public static <E extends Comparable<E>> SingleLinkedNode<E> getIntersectionNode(SingleLinkedList<E> list1,
+                                                                                    SingleLinkedList<E> list2) {
+
+        SingleLinkedNode<E> curr1, curr2;
+        int diffLength = Math.abs(list1.size - list2.size);
+
+        // forward the pointer in the longer list by their diff. in length
+        if (list1.size > list2.size) {
+            curr1 = list1.getNode(0);
+            curr2 = list2.getNode(0);
+        } else {
+            curr1 = list2.getNode(0);
+            curr2 = list1.getNode(0);
+        }
+        while (diffLength > 0) {
+            curr1 = curr1.next;
+            diffLength--;
+        }
+
+        // now compare both lists node by node
+        while (curr1 != null) {
+            if (curr1 == curr2) return curr1;
+            curr1 = curr1.next;
+            curr2 = curr2.next;
+        }
+
+        // lists do not intersect
+        return null;
+    }
+
+    public static void main(String a[]) {
+        SingleLinkedList<Integer> linkedList1 = new SingleLinkedList<>();
+        linkedList1.add(00);
+        linkedList1.add(11);
+        linkedList1.add(22);
+        linkedList1.add(33);
+        linkedList1.add(44);
+        linkedList1.add(55);
+        linkedList1.add(66);
+        linkedList1.add(77);
+        linkedList1.add(88);
+        SingleLinkedList<Integer> linkedList2 = new SingleLinkedList<>();
+        linkedList2.add(56);
+        linkedList2.add(78);
+        linkedList2.add(45);
+        linkedList2.add(23);
+        linkedList2.getNode(3).next = linkedList1.getNode(5); // join 2 lists at some point
+        linkedList2.size = 8; // update size after joining
+        System.out.println(getIntersectionNode(linkedList1, linkedList2) != null ?
+                getIntersectionNode(linkedList1, linkedList2).item : "List don't intersect!");
+    }
+}