rotate linked list: done

Author: Ram swaroop

src/me/ramswaroop/linkedlists/AddNumbersInTwoLists.java

@@ -14,19 +14,20 @@ public class AddNumbersInTwoLists {
 
     /**
      * Adds two numbers represented by two linked lists {@param list1}
-     * and {@param list2} and stores them in another list.
+     * and {@param list2} (where first node is the least significant
+     * digit) and stores them in another list.
      * <p/>
      * Example:
      * <p/>
      * Input:
      * First List: 5->6->3              // represents number 365
-     * Second List: 8->4->2             //  represents number 248
+     * Second List: 8->4->2             // represents number 248
      * Output:
      * Resultant list: 3->1->6          // represents number 613
      * <p/>
      * Input:
      * First List: 7->5->9->4->6        // represents number 64957
-     * Second List: 8->4                //  represents number 48
+     * Second List: 8->4                // represents number 48
      * Output:
      * Resultant list: 5->0->0->5->6    // represents number 65005
      *

src/me/ramswaroop/linkedlists/RotateLinkedList.java

@@ -0,0 +1,77 @@
+package me.ramswaroop.linkedlists;
+
+import me.ramswaroop.common.SingleLinkedList;
+import me.ramswaroop.common.SingleLinkedNode;
+
+/**
+ * Created by IntelliJ IDEA.
+ *
+ * @author: ramswaroop
+ * @date: 7/3/15
+ * @time: 3:07 PM
+ */
+public class RotateLinkedList {
+
+    /**
+     * Rotates the {@param list} anti-clockwise by {@param k} nodes.
+     *
+     * @param list
+     * @param k
+     * @param <E>
+     */
+    public static <E extends Comparable<E>> void rotateCounterClockwise(SingleLinkedList<E> list, int k) {
+        int clockwiseK = list.size - k;
+        rotateClockwise(list, clockwiseK);
+    }
+
+
+    /**
+     * Rotates the {@param list} clockwise by {@param k} nodes.
+     *
+     * Example,
+     *
+     * Input:   [0,11,22,33,44,55] and k =2
+     * Output:  [22,33,44,55,0,11]
+     *
+     * @param list
+     * @param k
+     * @param <E>
+     */
+    public static <E extends Comparable<E>> void rotateClockwise(SingleLinkedList<E> list, int k) {
+        int i = 0;
+        SingleLinkedNode<E> curr = list.head, end = curr;
+
+        // get a pointer to the last node
+        while (end.next != null) {
+            end = end.next;
+        }
+
+        // start moving first k nodes from start to end
+        while (i < k && k < list.size) {
+            end.next = curr;
+            end = end.next;
+            curr = curr.next;
+            i++;
+        }
+
+        // change head to k+1 node
+        list.head = curr;
+        end.next = null;
+
+    }
+
+    public static void main(String a[]) {
+        SingleLinkedList<Integer> linkedList = new SingleLinkedList<>();
+        linkedList.add(00);
+        linkedList.add(11);
+        linkedList.add(22);
+        linkedList.add(33);
+        linkedList.add(44);
+        linkedList.add(55);
+        linkedList.printList();
+        rotateClockwise(linkedList, 2);
+        linkedList.printList();
+        rotateCounterClockwise(linkedList, 2);
+        linkedList.printList();
+    }
+}