insertion in sorted linked list

Author: Ram swaroop

src/me/ramswaroop/common/DoubleLinkedList.java

@@ -11,7 +11,7 @@
  * @date: 6/16/15
  * @time: 1:00 PM
  */
-public class DoubleLinkedList<E> implements LinkedList<E> {
+public class DoubleLinkedList<E extends Comparable<E>> implements LinkedList<E> {
 
     public DoubleLinkedNode<E> head;
     public int size;
@@ -196,7 +196,7 @@ public void printList() {
         out.println(curr.item + "]");*/
     }
 
-    public static <E> DoubleLinkedList<E> getLinkedList(DoubleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> DoubleLinkedList<E> getLinkedList(DoubleLinkedNode<E> node) {
         DoubleLinkedList<E> linkedList = new DoubleLinkedList<>();
         linkedList.head = node;
         return linkedList;

src/me/ramswaroop/common/DoubleLinkedNode.java

@@ -7,7 +7,7 @@
  * @date: 6/18/15
  * @time: 2:42 PM
  */
-public class DoubleLinkedNode<E> {
+public class DoubleLinkedNode<E extends Comparable<E>> {
 
     public E item;
     public DoubleLinkedNode<E> next;

src/me/ramswaroop/common/LinkedList.java

@@ -7,7 +7,7 @@
  * @date: 6/16/15
  * @time: 12:53 PM
  */
-public interface LinkedList<E> {
+public interface LinkedList<E extends Comparable<E>> {
 
     /**
      * Appends the specified element to the end of this list.

src/me/ramswaroop/common/SingleLinkedList.java

@@ -11,7 +11,7 @@
  * @date: 6/16/15
  * @time: 1:00 PM
  */
-public class SingleLinkedList<E> implements LinkedList<E> {
+public class SingleLinkedList<E extends Comparable<E>> implements LinkedList<E> {
 
     public SingleLinkedNode<E> head;
     public int size;

src/me/ramswaroop/common/SingleLinkedNode.java

@@ -7,7 +7,7 @@
  * @date: 6/18/15
  * @time: 2:37 PM
  */
-public class SingleLinkedNode<E> {
+public class SingleLinkedNode<E extends Comparable<E>> {
 
     public E item;
     public SingleLinkedNode<E> next;

src/me/ramswaroop/linkedlists/CloneWithRandPointers.java

@@ -10,9 +10,9 @@
  * @date: 6/20/15
  * @time: 1:00 PM
  */
-public class CloneWithRandPointers<E> extends DoubleLinkedList<E> {
+public class CloneWithRandPointers<E extends Comparable<E>> extends DoubleLinkedList<E> {
 
-    public static <E> DoubleLinkedList<E> clone(DoubleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> DoubleLinkedList<E> clone(DoubleLinkedNode<E> node) {
         DoubleLinkedNode<E> curr = node;
 
         // copy node and insert after it
@@ -57,6 +57,9 @@ 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(1, 567);
         clonedList.printList();
+        linkedList.printList();
     }
 }

src/me/ramswaroop/linkedlists/DeleteNode.java

@@ -10,15 +10,15 @@
  * @date: 6/18/15
  * @time: 2:35 PM
  */
-public class DeleteNode<E> extends SingleLinkedList<E> {
+public class DeleteNode<E extends Comparable<E>> extends SingleLinkedList<E> {
 
     /**
      * Given a pointer to a node, delete it.
      *
      * @param node
      * @param <E>
      */
-    public static <E> void deleteNode(SingleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> void deleteNode(SingleLinkedNode<E> node) {
         // assert node isn't the last node in the linked list
         node.item = node.next.item;
         node.next = node.next.next;

src/me/ramswaroop/linkedlists/DetectLoop.java

@@ -12,7 +12,7 @@
  * @date: 6/19/15
  * @time: 9:24 AM
  */
-public class DetectLoop<E> extends SingleLinkedList<E> {
+public class DetectLoop<E extends Comparable<E>> extends SingleLinkedList<E> {
 
     /**
      * Uses Flyod's Cycle Finding algorithm.
@@ -30,7 +30,7 @@ public class DetectLoop<E> extends SingleLinkedList<E> {
      * @param node
      * @return
      */
-    public static <E> boolean isLoopPresent(SingleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> boolean isLoopPresent(SingleLinkedNode<E> node) {
         SingleLinkedNode<E> prev = node, curr = node;
         while (curr != null && curr.next != null) {
             prev = prev.next;
@@ -51,7 +51,7 @@ public static <E> boolean isLoopPresent(SingleLinkedNode<E> node) {
      * @param node
      * @return
      */
-    public static <E> boolean isLoopPresentUsingHashMap(SingleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> boolean isLoopPresentUsingHashMap(SingleLinkedNode<E> node) {
         HashMap<SingleLinkedNode<E>, Boolean> map = new HashMap<>();
         SingleLinkedNode<E> curr = node;
         while (curr != null) {

src/me/ramswaroop/linkedlists/InsertionInSortedList.java

@@ -0,0 +1,41 @@
+package me.ramswaroop.linkedlists;
+
+import me.ramswaroop.common.SingleLinkedList;
+import me.ramswaroop.common.SingleLinkedNode;
+
+/**
+ * Created by IntelliJ IDEA.
+ *
+ * @author: ramswaroop
+ * @date: 6/21/15
+ * @time: 10:20 PM
+ */
+public class InsertionInSortedList<E extends Comparable<E>> extends SingleLinkedList<E> {
+
+    /**
+     * Insert an element in the sorted linked list.
+     *
+     * @param item
+     */
+    public void insert(E item) {
+        int index = 0;
+        SingleLinkedNode<E> node = head;
+        while (node != null) {
+            if (item.compareTo(node.item) < 0) break;
+            index++;
+            node = node.next;
+        }
+        add(index, item);
+    }
+
+    public static void main(String a[]) {
+        InsertionInSortedList<Integer> linkedList = new InsertionInSortedList<>();
+        linkedList.add(00);
+        linkedList.add(11);
+        linkedList.add(22);
+        linkedList.add(33);
+        linkedList.printList();
+        linkedList.insert(13);
+        linkedList.printList();
+    }
+}

src/me/ramswaroop/linkedlists/IsPalindrome.java

@@ -12,7 +12,7 @@
  * @date: 6/18/15
  * @time: 2:35 PM
  */
-public class IsPalindrome<E> extends SingleLinkedList<E> {
+public class IsPalindrome<E extends Comparable<E>> extends SingleLinkedList<E> {
 
     /**
      * Uses Stack to test whether a linked list starting
@@ -21,7 +21,7 @@ public class IsPalindrome<E> extends SingleLinkedList<E> {
      * @param node
      * @return
      */
-    public static <E> boolean isPalindrome(SingleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> boolean isPalindrome(SingleLinkedNode<E> node) {
         SingleLinkedNode<E> curr = node;
         Stack<SingleLinkedNode<E>> stack = new LinkedStack<>();
 

src/me/ramswaroop/linkedlists/MiddleNode.java

@@ -10,9 +10,9 @@
  * @date: 6/18/15
  * @time: 10:34 PM
  */
-public class MiddleNode<E> extends SingleLinkedList<E> {
+public class MiddleNode<E extends Comparable<E>> extends SingleLinkedList<E> {
 
-    public static <E> SingleLinkedNode<E> getMiddleNode(SingleLinkedNode<E> node) {
+    public static <E extends Comparable<E>> SingleLinkedNode<E> getMiddleNode(SingleLinkedNode<E> node) {
         SingleLinkedNode<E> slow = node;
         SingleLinkedNode<E> fast = node;
         while (fast != null && fast.next != null) {

src/me/ramswaroop/linkedlists/NthNodeFromLast.java

@@ -10,9 +10,9 @@
  * @date: 6/18/15
  * @time: 6:49 PM
  */
-public class NthNodeFromLast<E> extends SingleLinkedList<E> {
+public class NthNodeFromLast<E extends Comparable<E>> extends SingleLinkedList<E> {
 
-    public static <E> SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedNode<E> node, int n) {
+    public static <E extends Comparable<E>> SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedNode<E> node, int n) {
         SingleLinkedNode<E> slow = node;
         SingleLinkedNode<E> fast = node;
         // move the fast reference ahead of slow reference by 'n' nodes

src/me/ramswaroop/linkedlists/ReverseList.java

@@ -10,7 +10,7 @@
  * @date: 6/19/15
  * @time: 9:24 AM
  */
-public class ReverseList<E> extends SingleLinkedList<E> {
+public class ReverseList<E extends Comparable<E>> extends SingleLinkedList<E> {
 
     /**
      * Reverses the linked list using 3 references prev, curr and next.