LinkedList related problems added

Author: sushant097

coding_solutions/DataStructure_related/6_LinkedList_Cycle.py

@@ -0,0 +1,48 @@
+'''
+Question: https://leetcode.com/problems/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.
+
+=> => =>
+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).
+
+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.
+
+
+Follow up: Can you solve it using O(1) (i.e. constant) memory?
+
+
+'''
+
+# Time: O(n); Space: O(1)
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        # Idea : Place some new unique value to current node value
+        # if that value again comes then it has cycle
+        # Time: O(n); Space: O(1)
+        temp = head
+        while temp:
+            if temp.val == float('-inf'):
+                return True
+            
+            temp.val = float('-inf')
+            temp = temp.next
+        return False
+            
+

coding_solutions/DataStructure_related/LinkedList/3_MergeTwoSortedList.py

@@ -0,0 +1,44 @@
+'''
+Question: https://leetcode.com/problems/merge-two-sorted-lists/
+You are given the heads of two sorted linked lists list1 and list2.
+Merge the two lists in a one sorted list. The list should be made by splicing together the nodes of the first two lists.
+Return the head of the merged linked list.
+=> => => => =>
+Input: list1 = [1,2,4], list2 = [1,3,4]
+Output: [1,1,2,3,4,4]
+Input: list1 = [], list2 = []
+Output: []
+
+Idea Explained at: https://leetcode.com/problems/merge-two-sorted-lists/discuss/2253040/O(n)-O(1)Python-Merging-Explained-with-detail-output
+
+'''
+# Solution: Time: O(n); Space: O(1)
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+
+        dummy=ListNode()
+        head = dummy
+        # Take out all the values of both linked list
+        while list1 and list2:
+            if list1.val < list2.val:
+                head.next = list1
+                list1 = list1.next
+            else:
+                head.next = list2
+                list2 = list2.next
+            head = head.next
+            # print(f"head: {head}")
+            # print(f"Dummy: {dummy}")            
+        if list1 or list2:
+            head.next = list1 if list1 else list2
+        
+        # print("Finally")
+        # print(f"head: {head}")
+        # print(f"Dummy: {dummy}")    
+        return dummy.next
+        

coding_solutions/DataStructure_related/LinkedList/4_Reverse_LinkedList.py

@@ -0,0 +1,75 @@
+'''
+Question: https://leetcode.com/problems/reverse-linked-list/
+Given the head of a singly linked list, reverse the list, and return the reversed list.
+
+=> => => =>
+Input: head = [1,2,3,4,5]
+Output: [5,4,3,2,1]
+
+Input: head = [1,2]
+Output: [2,1]
+
+Input: head = []
+Output: []
+
+Follow up: A linked list can be reversed either iteratively or recursively. Could you implement both?
+
+
+'''
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+# Appraoch 1: Iterative approach -> Time: O(n); Space: O(n)
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        # Iterative solution
+        # Time: O(n), Space: O(n)
+        
+        if not head:
+            return head
+
+        if not head.next:
+            return head
+        # Get the values of linked List
+        values = []
+        while head:
+            values.append(head.val)
+            head = head.next
+        
+        # Create the new linkedlist with the values 
+        # Where the values are in reverse order
+        for i in range(len(values)):
+            if i == 0:
+                left = ListNode(values[i])
+            else:
+                left = ListNode(values[i], left)
+            # print(f"{left}")
+        return left
+        
+
+# Approach : Recursive with Queue Data Structure -> Time: O(n); Space: O(n)
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        # Recursive Solution : Queue Data Structure
+        # Time: O(n); Space: O(n)
+        queue = []
+        
+        self.process(head, queue)
+        
+        return head
+    
+    def process(self, head: Optional[ListNode], queue) -> None:
+        
+        if not head:
+            return 
+        queue.append(head.val)
+        self.process(head.next, queue)
+        # after recursive all the values are in queue
+        # These values are in descending order
+        # Just update head value with values of queue
+        head.val = queue.pop(0)
+        
+            

coding_solutions/DataStructure_related/LinkedList/5_Palindrome_LinkedList.py

@@ -0,0 +1,95 @@
+'''
+Question: https://leetcode.com/problems/palindrome-linked-list/
+Given the head of a singly linked list, return true if it is a palindrome.
+
+=> => => =>
+Input: head = [1,2,2,1]
+Output: true
+
+Input: head = [1,2]
+Output: false
+
+Follow up: Could you do it in O(n) time and O(1) space?
+
+'''
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+# Solution: Time: O(n); Space: O(n)
+# First we get all the values of LinkedList
+# Check whether that values is equal to reverse of this
+class Solution:
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
+        if head.next == None:
+            return True
+        values = []
+        while head:
+            values.append(head.val)
+            head = head.next
+        
+        # print(values)
+        # Check if the values == reverse of that
+        i = 0
+        j = len(values) - 1
+        while i < j:
+            if values[i] != values[j]:
+                return False
+            i += 1
+            j -= 1
+        return True
+
+
+"Follow up: Could you do it in O(n) time and O(1) space?"
+# Solution : Time: O(n); Space: O(1)
+# We will utilize two algorithm methods:
+# Floyd's Tortoise & Hare Algorithm aka Fast and Slow Pointers + Linked List Reversal
+# Time is O(n) because in the worst case we are just traversing through the entire linked list in a single iteration time.
+# Space is O(1) because we aren't saving the entire input/linked list anywhere during our algorithm, so there is no scaling memory. 
+# Only we keep track of variables and pointers.
+class Solution:
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
+        if head.next == None:
+            return True
+
+        slow = head
+        fast = head
+
+        # We use slow and fast pointer algorithm to get the middle of the linked list
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        
+        # reverse the second half head ; Reverse in between [slow, tail]
+        secondHalfEnd = self.reverse(slow)
+
+        # check the reverse second half and first half
+        # so use two pointers
+        # Pointer1 is in starting and pointer2 is in middle
+        pointer1 = head
+        pointer2 = secondHalfEnd
+        validPalindrome = True
+
+        while pointer1 and pointer2:
+            if pointer1.val != pointer2.val:
+                validPalindrome = False
+                break
+            pointer1 = pointer1.next
+            pointer2 = pointer2.next
+        
+        # Reverse the second half of the linked list back to normal
+        self.reverse(secondHalfEnd)
+        return validPalindrome
+
+    def reverse(self, head):
+        prev = None
+        current = head
+        while current:
+            temp = current.next
+            current.next = prev
+            prev = current
+            current = temp
+        return prev