Merge pull request ByteByteGoHq#27 from Jer3myYu/java-solution-fast-and-slow-pointers

Java Chapter 4: Fast and Slow Pointers

Author: Destiny-02

java/Fast and Slow Pointers/HappyNumber.java

@@ -0,0 +1,28 @@
+public class HappyNumber {
+    public boolean happyNumber(int n) {
+        int slow, fast;
+        slow = fast = n;
+        while (true) {
+            slow = getNextNum(slow);
+            fast = getNextNum(getNextNum(fast));
+            if (fast == 1) return true;
+            // If the fast and slow pointers meet, a cycle is detected. 
+            // Hence, 'n' is not a happy number.
+            else if (fast == slow) return false;
+        }
+    }
+
+    private int getNextNum(int x) {
+        int nextNum = 0;
+        while (x > 0) {
+            // Extract the last digit of 'x'.
+            int digit = x % 10;
+            // Truncate (remove) the last digit from 'x' using floor 
+            // division.
+            x /= 10;
+            // Add the square of the extracted digit to the sum.
+            nextNum += Math.pow(digit, 2);
+        }
+        return nextNum;
+    }
+}

java/Fast and Slow Pointers/LinkedListLoop.java

@@ -0,0 +1,30 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class LinkedListLoop {
+    public boolean linkedListLoop(ListNode head) {
+        ListNode slow, fast;
+        slow = fast = head;
+        // Check both 'fast' and 'fast.next' to avoid null pointer
+        // exceptions when we perform 'fast.next' and 'fast.next.next'.
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (fast == slow) return true;
+        }
+        return false;
+    }
+}

java/Fast and Slow Pointers/LinkedListLoopNaive.java

@@ -0,0 +1,32 @@
+import java.util.HashSet;
+import java.util.Set;
+
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class LinkedListLoopNaive {
+    public boolean linkedListLoopNaive(ListNode head) {
+        Set<ListNode> visited = new HashSet<>();
+        ListNode curr = head;
+        while (curr != null) {
+            // Cycle detected if the current node has already been visited.
+            if (visited.contains(curr)) return true;
+            visited.add(curr);
+            curr = curr.next;
+        }
+        return false;
+    }
+}

java/Fast and Slow Pointers/LinkedListMidpoint.java

@@ -0,0 +1,29 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class LinkedListMidpoint {
+    public ListNode linkedListMidpoint(ListNode head) {
+        ListNode slow, fast;
+        slow = fast = head;
+        // When the fast pointer reaches the end of the list, the slow
+        // pointer will be at the midpoint of the linked list.
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
+}