Kth node from last

Author: rampatra

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

@@ -0,0 +1,65 @@
+package com.ctci.linkedlists;
+
+import static com.ctci.linkedlists.Node.printList;
+
+/**
+ * @author rampatra
+ * @since 21/11/2018
+ */
+public class KthToLastElement {
+
+    /**
+     * Finds the kth node from the end in a linked list.
+     *
+     * @param head is the reference to the head of the linked list
+     * @param k    is the position of element from the end
+     * @return the Kth node from the end
+     */
+    private static Node getKthToLastElement(Node head, int k) {
+        Node slow = head;
+        Node fast = head;
+        int i = 0;
+
+        // forward the fast reference k times
+        while (i < k) {
+            if (fast == null) return null; // k is out of bounds
+            fast = fast.next;
+            i++;
+        }
+
+        while (fast != null) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+        return slow;
+    }
+
+    public static void main(String[] args) {
+        Node l1 = new Node(1);
+        l1.next = new Node(6);
+        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(7);
+        printList(l1);
+        System.out.println("k=2: " + getKthToLastElement(l1, 2).val); // NPE check is omitted intentionally to keep it simple
+
+        Node l2 = new Node(1);
+        l2.next = new Node(6);
+        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(7);
+        printList(l2);
+        System.out.println("k=1: " + getKthToLastElement(l2, 1).val);
+
+        Node l3 = new Node(1);
+        l3.next = new Node(6);
+        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(7);
+        printList(l3);
+        System.out.println("k=6: " + getKthToLastElement(l3, 6).val);
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.ctci.linkedlists;
+
+/**
+ * @author rampatra
+ * @since 21/11/2018
+ */
+class Node {
+    int val;
+    Node next;
+
+    Node(int val) {
+        this.val = val;
+    }
+
+    public 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);
+    }
+}

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

@@ -3,6 +3,8 @@
 import java.util.HashSet;
 import java.util.Set;
 
+import static com.ctci.linkedlists.Node.printList;
+
 /**
  * @author rampatra
  * @since 21/11/2018
@@ -34,17 +36,6 @@ private static void removeDuplicatesFromUnsortedList(Node head) {
         }
     }
 
-    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);
@@ -82,13 +73,4 @@ public static void main(String[] args) {
         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/NthNodeFromLast.java

@@ -6,12 +6,17 @@
 /**
  * Created by IntelliJ IDEA.
  *
- * @author: ramswaroop
- * @date: 6/18/15
- * @time: 6:49 PM
+ * @author rampatra
+ * @since 6/18/15
  */
 public class NthNodeFromLast {
 
+    /**
+     * @param list
+     * @param n
+     * @param <E>
+     * @return
+     */
     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);
@@ -29,15 +34,42 @@ public static <E extends Comparable<E>> SingleLinkedNode<E> getNthNodeFromLast(S
 
     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.add(66);
-        linkedList.add(77);
-        linkedList.add(88);
-        System.out.println(getNthNodeFromLast(linkedList, 3).item);
+        linkedList.add(0);
+        linkedList.add(1);
+        linkedList.add(2);
+        linkedList.add(3);
+        linkedList.add(4);
+        linkedList.add(5);
+        linkedList.add(6);
+        linkedList.add(7);
+        linkedList.add(8);
+        linkedList.printList();
+        System.out.println("n=3: " + getNthNodeFromLast(linkedList, 3).item);
+
+        SingleLinkedList<Integer> linkedList2 = new SingleLinkedList<>();
+        linkedList2.add(0);
+        linkedList2.add(1);
+        linkedList2.add(2);
+        linkedList2.add(3);
+        linkedList2.add(4);
+        linkedList2.add(5);
+        linkedList2.add(6);
+        linkedList2.add(7);
+        linkedList2.add(8);
+        linkedList2.printList();
+        System.out.println("n=1: " + getNthNodeFromLast(linkedList2, 1).item);
+
+        SingleLinkedList<Integer> linkedList3 = new SingleLinkedList<>();
+        linkedList3.add(0);
+        linkedList3.add(1);
+        linkedList3.add(2);
+        linkedList3.add(3);
+        linkedList3.add(4);
+        linkedList3.add(5);
+        linkedList3.add(6);
+        linkedList3.add(7);
+        linkedList3.add(8);
+        linkedList3.printList();
+        System.out.println("n=9: " + getNthNodeFromLast(linkedList3, 9).item);
     }
 }