Add fast and slow pointers code

Author: ashishps1

patterns/c#/FastAndSlowPointers.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+
+public class ListNode {
+    public int val;
+    public ListNode next;
+    public ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class FastAndSlowPointers {
+    // LeetCode 141 - Linked List Cycle (HashSet Approach)
+    public bool HasCycleHashSetApproach(ListNode head) {
+        HashSet<ListNode> visited = new HashSet<ListNode>();
+        ListNode current = head;
+        while (current != null) {
+            if (visited.Contains(current)) {
+                return true; // Cycle detected
+            }
+            visited.Add(current);
+            current = current.next;
+        }
+        return false; // No cycle
+    }
+
+    // LeetCode 141 - Linked List Cycle (Fast and Slow Pointer Approach)
+    public bool HasCycleFastAndSlowPointersApproach(ListNode head) {
+        if (head == null || head.next == null) return false;
+        ListNode slow = head, fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast) return true;
+        }
+        return false;
+    }
+
+    // LeetCode 876 - Middle of the Linked List (Counting Approach)
+    public ListNode MiddleNodeCountingApproach(ListNode head) {
+        int count = 0;
+        ListNode current = head;
+        while (current != null) {
+            count++;
+            current = current.next;
+        }
+        current = head;
+        for (int i = 0; i < count / 2; i++) {
+            current = current.next;
+        }
+        return current;
+    }
+
+    // LeetCode 876 - Middle of the Linked List (Fast and Slow Pointer Approach)
+    public ListNode MiddleNodeFastAndSlowPointerApproach(ListNode head) {
+        ListNode slow = head, fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
+
+    // LeetCode 202 - Happy Number (HashSet Approach)
+    private int GetSumOfSquares(int n) {
+        int sum = 0;
+        while (n > 0) {
+            int digit = n % 10;
+            sum += digit * digit;
+            n /= 10;
+        }
+        return sum;
+    }
+
+    public bool IsHappyHashSetApproach(int n) {
+        HashSet<int> seen = new HashSet<int>();
+        while (n != 1 && !seen.Contains(n)) {
+            seen.Add(n);
+            n = GetSumOfSquares(n);
+        }
+        return n == 1;
+    }
+
+    // LeetCode 202 - Happy Number (Fast and Slow Pointer Approach)
+    public bool IsHappyFastAndSlowPointersApproach(int n) {
+        int slow = n;
+        int fast = GetSumOfSquares(n);
+        while (fast != 1 && slow != fast) {
+            slow = GetSumOfSquares(slow);
+            fast = GetSumOfSquares(GetSumOfSquares(fast));
+        }
+        return fast == 1;
+    }
+}

patterns/c++/FastAndSlowPointers.cpp

@@ -0,0 +1,100 @@
+#include <unordered_set>
+using namespace std;
+
+class ListNode {
+public:
+    int val;
+    ListNode* next;
+    ListNode(int x) : val(x), next(nullptr) {}
+};
+
+class FastAndSlowPointers {
+public:
+    // LeetCode 141 - Linked List Cycle (HashSet Approach)
+    bool hasCycleHashSetApproach(ListNode* head) {
+        unordered_set<ListNode*> visited;
+        ListNode* current = head;
+        while (current != nullptr) {
+            if (visited.find(current) != visited.end()) {
+                return true; // Cycle detected
+            }
+            visited.insert(current);
+            current = current->next;
+        }
+        return false; // No cycle
+    }
+
+    // LeetCode 141 - Linked List Cycle (Fast and Slow Pointer Approach)
+    bool hasCycleFastAndSlowPointersApproach(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+            return false;
+        }
+        ListNode* slow = head;
+        ListNode* fast = head;
+        while (fast != nullptr && fast->next != nullptr) {
+            slow = slow->next;
+            fast = fast->next->next;
+            if (slow == fast) {
+                return true; // Cycle detected
+            }
+        }
+        return false; // No cycle
+    }
+
+    // LeetCode 876 - Middle of the Linked List (Counting Approach)
+    ListNode* middleNodeCountingApproach(ListNode* head) {
+        int count = 0;
+        ListNode* current = head;
+        while (current != nullptr) {
+            count++;
+            current = current->next;
+        }
+        current = head;
+        for (int i = 0; i < count / 2; i++) {
+            current = current->next;
+        }
+        return current;
+    }
+
+    // LeetCode 876 - Middle of the Linked List (Fast and Slow Pointer Approach)
+    ListNode* middleNodeFastAndSlowPointerApproach(ListNode* head) {
+        ListNode* slow = head;
+        ListNode* fast = head;
+        while (fast != nullptr && fast->next != nullptr) {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        return slow;
+    }
+
+    // LeetCode 202 - Happy Number (HashSet Approach)
+    int getSumOfSquares(int n) {
+        int sum = 0;
+        while (n > 0) {
+            int digit = n % 10;
+            sum += digit * digit;
+            n /= 10;
+        }
+        return sum;
+    }
+
+    bool isHappyHashSetApproach(int n) {
+        unordered_set<int> seen;
+        while (n != 1 && seen.find(n) == seen.end()) {
+            seen.insert(n);
+            n = getSumOfSquares(n);
+        }
+        return n == 1;
+    }
+
+    // LeetCode 202 - Happy Number (Fast and Slow Pointer Approach)
+    bool isHappyFastAndSlowPointersApproach(int n) {
+        int slow = n;
+        int fast = getSumOfSquares(n);
+        while (fast != 1 && slow != fast) {
+            slow = getSumOfSquares(slow);
+            fast = getSumOfSquares(getSumOfSquares(fast));
+        }
+        return fast == 1;
+    }
+};

patterns/go/fast_and_slow_pointers.go

@@ -0,0 +1,98 @@
+package main
+
+import "fmt"
+
+type ListNode struct {
+    Val  int
+    Next *ListNode
+}
+
+// LeetCode 141 - Linked List Cycle (HashSet Approach)
+func hasCycleHashSetApproach(head *ListNode) bool {
+    visited := map[*ListNode]bool{}
+    current := head
+    for current != nil {
+        if visited[current] {
+            return true
+        }
+        visited[current] = true
+        current = current.Next
+    }
+    return false
+}
+
+// LeetCode 141 - Linked List Cycle (Fast and Slow Pointer Approach)
+func hasCycleFastAndSlowPointersApproach(head *ListNode) bool {
+    if head == nil || head.Next == nil {
+        return false
+    }
+    slow, fast := head, head
+    for fast != nil && fast.Next != nil {
+        slow = slow.Next
+        fast = fast.Next.Next
+        if slow == fast {
+            return true
+        }
+    }
+    return false
+}
+
+// LeetCode 876 - Middle of the Linked List (Counting Approach)
+func middleNodeCountingApproach(head *ListNode) *ListNode {
+    count := 0
+    current := head
+    for current != nil {
+        count++
+        current = current.Next
+    }
+    current = head
+    for i := 0; i < count/2; i++ {
+        current = current.Next
+    }
+    return current
+}
+
+// LeetCode 876 - Middle of the Linked List (Fast and Slow Pointer Approach)
+func middleNodeFastAndSlowPointerApproach(head *ListNode) *ListNode {
+    slow, fast := head, head
+    for fast != nil && fast.Next != nil {
+        slow = slow.Next
+        fast = fast.Next.Next
+    }
+    return slow
+}
+
+// LeetCode 202 - Happy Number (HashSet Approach)
+func getSumOfSquares(n int) int {
+    sum := 0
+    for n > 0 {
+        digit := n % 10
+        sum += digit * digit
+        n /= 10
+    }
+    return sum
+}
+
+func isHappyHashSetApproach(n int) bool {
+    seen := map[int]bool{}
+    for n != 1 && !seen[n] {
+        seen[n] = true
+        n = getSumOfSquares(n)
+    }
+    return n == 1
+}
+
+// LeetCode 202 - Happy Number (Fast and Slow Pointer Approach)
+func isHappyFastAndSlowPointersApproach(n int) bool {
+    slow := n
+    fast := getSumOfSquares(n)
+    for fast != 1 && slow != fast {
+        slow = getSumOfSquares(slow)
+        fast = getSumOfSquares(getSumOfSquares(fast))
+    }
+    return fast == 1
+}
+
+func main() {
+    // You can test the implementations here
+}