leetcode

Author: ayoubzulfiqar

LinkedListCycle/linked_list_cycle..go

@@ -0,0 +1,46 @@
+package main
+
+// Definition for singly-linked list.
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+/*
+
+ListNode? fast = head;
+    while (fast != null && fast.next != null) {
+      head = head?.next;
+      fast = fast.next?.next;
+      if (head == fast) return true;
+    }
+    return false;
+*/
+func hasCycle(head *ListNode) bool {
+	if head == nil || head.Next == nil {
+		return false
+	}
+
+	//set the 'mark' is over 10^5
+	mark := 100001
+	//marking
+	head.Val = mark
+	//move to next
+	head = head.Next
+
+	for head != nil && head.Next != nil {
+
+		//When 'head' becomes the same as 'mark', it's Cycle.
+		if head.Val == mark || head.Next.Val == mark {
+			return true
+		}
+
+		//marking & move to next ( Two ahead )
+		head.Val = mark
+		head = head.Next.Next
+
+	}
+
+	return false
+
+}

LinkedListCycle/linked_list_cycle.dart

@@ -0,0 +1,122 @@
+/*
+
+-* Linked List Cycle *-
+
+
+Given head, the head of a linked list, determine if the linked list has a cycle in it.
+
+There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to. Note that pos is not passed as a parameter.
+
+Return true if there is a cycle in the linked list. Otherwise, return false.
+
+
+
+Example 1:
+
+
+Input: head = [3,2,0,-4], pos = 1
+Output: true
+Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
+Example 2:
+
+
+Input: head = [1,2], pos = 0
+Output: true
+Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.
+Example 3:
+
+
+Input: head = [1], pos = -1
+Output: false
+Explanation: There is no cycle in the linked list.
+
+
+Constraints:
+
+The number of the nodes in the list is in the range [0, 104].
+-105 <= Node.val <= 105
+pos is -1 or a valid index in the linked-list.
+
+
+Follow up: Can you solve it using O(1) (i.e. constant) memory?
+
+
+*/
+
+// Definition for singly-linked list.
+
+import 'dart:collection';
+
+class ListNode {
+  int val;
+  ListNode? next;
+  ListNode([this.val = 0, this.next]);
+}
+
+class A {
+  bool hasCycle(ListNode? head) {
+    ListNode? fast = head;
+    while (fast != null && fast.next != null) {
+      head = head?.next;
+      fast = fast.next?.next;
+      if (head == fast) return true;
+    }
+    return false;
+  }
+}
+
+class B {
+  bool hasCycle(ListNode? head) {
+    if (head == null) return false;
+    ListNode? fast = head, slow = head;
+    while (fast?.next != null && fast?.next?.next != null) {
+      slow = slow?.next;
+      fast = fast?.next?.next;
+      if (fast == slow) return true;
+    }
+    return false;
+  }
+}
+
+class C {
+  bool hasCycle(ListNode? head) {
+    ListNode? tmp = null;
+    while (head == null) {
+      if (head == head?.next) return true;
+      tmp = head?.next;
+      head?.next = head;
+      head = tmp;
+    }
+    return false;
+  }
+}
+
+// O(1) Space Solution
+class D {
+  bool hasCycle(ListNode? head) {
+    if (head == null) return false;
+    ListNode? walker = head;
+    ListNode? runner = head;
+    while (runner!.next != null && runner.next!.next != null) {
+      walker = walker!.next;
+      runner = runner.next!.next;
+      if (walker == runner) return true;
+    }
+    return false;
+  }
+}
+
+// Using HashSet
+
+class E {
+  bool hasCycle(ListNode? head) {
+    HashSet s = HashSet();
+    for (ListNode? current = head; current != null; current = current.next) {
+      if (s.contains(current)) {
+        return true;
+      }
+      s.add(current);
+    }
+    return false;
+  }
+}

LinkedListCycle/linked_list_cycle.md

@@ -0,0 +1,125 @@
+# 🔥 Dart || 5 Solutions || Simple Fast Easy with Explanation
+
+## Definition for singly-linked list
+
+```dart
+class ListNode {
+  int val;
+  ListNode? next;
+  ListNode([this.val = 0, this.next]);
+}
+```
+
+## Solution - 1 Two Pointers
+
+### Core Strategy
+
+For this problem, let's see what will happen if there's a circle.
+If it's a little abstract, then let's think about we are running on a circular track.
+
+If the track is 100m long, your speed is 10m/s, your friend's speed is 5m/s. Then after 20s, you've run 200m, your friend has run 100m. But because the track is circular, so you will be at the same place with your friend since the difference between your distances is exactly 100m.
+
+How about we change another track, change the speed of you and your friend? As long as your speeds are not the same, the faster person will always catch up with the slower person again.
+
+That's the key point for this problem.
+
+### Approach
+
+We just need to follow the strategy above - make a slower pointer and a faster pointer. Then we loop and loop again:
+
+if the fast pointer catch up with slow pointer, then it's a circular linked list
+if the fast pointer get to the end, then it's not a circular linked list
+
+```dart
+class Solution {
+  bool hasCycle(ListNode? head) {
+    ListNode? fast = head;
+    while (fast != null && fast.next != null) {
+      head = head?.next;
+      fast = fast.next?.next;
+      if (head == fast) return true;
+    }
+    return false;
+  }
+}
+```
+
+## Solution - 2
+
+```dart
+class Solution {
+  bool hasCycle(ListNode? head) {
+    if (head == null) return false;
+    ListNode? fast = head, slow = head;
+    while (fast?.next != null && fast?.next?.next != null) {
+      slow = slow?.next;
+      fast = fast?.next?.next;
+      if (fast == slow) return true;
+    }
+    return false;
+  }
+}
+```
+
+## Solution - 3 Swapping nodes
+
+```dart
+class Solution {
+  bool hasCycle(ListNode? head) {
+    ListNode? tmp = null;
+    while (head == null) {
+      if (head == head?.next) return true;
+      tmp = head?.next;
+      head?.next = head;
+      head = tmp;
+    }
+    return false;
+  }
+}
+```
+
+## Solution - 4  O(1) Space Solution
+
+```dart
+class Solution {
+  bool hasCycle(ListNode? head) {
+    if (head == null) return false;
+    ListNode? walker = head;
+    ListNode? runner = head;
+    while (runner!.next != null && runner.next!.next != null) {
+      walker = walker!.next;
+      runner = runner.next!.next;
+      if (walker == runner) return true;
+    }
+    return false;
+  }
+}
+```
+
+## Solution - 5 Using HashSet
+
+```dart
+
+import 'dart:collection';
+
+class Solution {
+  bool hasCycle(ListNode? head) {
+    HashSet s = HashSet();
+    for (ListNode? current = head; current != null; current = current.next) {
+      if (s.contains(current)) {
+        return true;
+      }
+      s.add(current);
+    }
+    return false;
+  }
+}
+
+```
+
+## [GitHub Link](https://github.com/ayoubzulfiqar/leetcode)
+
+## Disclaimer:-
+
+This question is not available in Dart language on leetcode i don't know Why but I solved it in different ways to show case how we can achieve the result using different methods. I hope in future this question available in dart.
+HOPE FOR THE BEST.

README.md

@@ -52,6 +52,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [Push Dominoes](PushDominoes/push_dominoes.dart)
 - [Single Number](SingleNumber/single_number.dart)
 - [Remove Nth Node From End of List](RemoveNthNodeFromEndOfList/remove_nth_node_from_end_of_list.dart)
+- [Linked List Cycle](LinkedListCycle/linked_list_cycle.dart)
 
 ## Reach me via