Merge pull request ByteByteGoHq#18 from ongshunping/cpp-solutions-fast-and-slow-pointers

Add C++ solutions for Chapter 4 (Fast and Slow Pointers)

Author: Destiny-02

cpp/Fast and Slow Pointers/happy_number.cpp

@@ -0,0 +1,30 @@
+bool happyNumber(int n) {
+    int slow = n;
+    int 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;
+        }
+    }
+}
+
+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 integer 
+        // division.
+        x /= 10;
+        // Add the square of the extracted digit to the sum.
+        nextNum += digit * digit;
+    }
+    return nextNum;
+}

cpp/Fast and Slow Pointers/linked_list_loop.cpp

@@ -0,0 +1,26 @@
+#include "ds/ListNode.h"
+using ds::ListNode;
+
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+bool linkedListLoop(ListNode* head) {
+    ListNode* slow = head;
+    ListNode* fast = head;
+    // Check both 'fast' and 'fast->next' to avoid null pointer
+    // exceptions when we perform 'fast->next' and 'fast->next->next'.
+    while (fast != nullptr && fast->next != nullptr) {
+        slow = slow->next;
+        fast = fast->next->next;
+        if (fast == slow) {
+            return true;
+        }
+    }
+    return false;
+}

cpp/Fast and Slow Pointers/linked_list_loop_naive.cpp

@@ -0,0 +1,26 @@
+#include <unordered_set>
+#include "ds/ListNode.h"
+using ds::ListNode;
+
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+bool linkedListLoopNaive(ListNode* head) {
+    std::unordered_set<ListNode*> visited;
+    ListNode* curr = head;
+    while (curr) {
+        // Cycle detected if the current node has already been visited.
+        if (visited.find(curr) != visited.end()) {
+            return true;
+        }
+        visited.insert(curr);
+        curr = curr->next;
+    }
+    return false;
+}

cpp/Fast and Slow Pointers/linked_list_midpoint.cpp

@@ -0,0 +1,23 @@
+#include "ds/ListNode.h"
+using ds::ListNode;
+
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* linkedListMidpoint(ListNode* head) {
+    ListNode* slow = head;
+    ListNode* 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 != nullptr && fast->next != nullptr) {
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    return slow;
+}