Add linked list and binary search problems with solutions

Implemented multiple linked list and binary search problem solutions including `add_two_numbers`, `reverse_linked_list`, `merge_two_sorted_lists`, and `search_in_rotated_sorted_array`. Each includes unittests and follows PEP 8 for maintainability and clarity.

Author: nicholasadamou

Binary Search/find_minimum_in_rotated_sorted_array.py

@@ -0,0 +1,29 @@
+# https://neetcode.io/problems/find-minimum-in-rotated-sorted-array
+
+from typing import List
+
+import unittest
+
+
+def find_min(nums: List[int]) -> int:
+    n = len(nums)
+
+    left = 0
+    right = n - 1
+
+    while left < right:
+        mid = (right + left) // 2
+
+        if nums[mid] > nums[right]:
+            left = mid + 1
+        else:
+            right = mid
+
+    return nums[left]
+
+
+class Test(unittest.TestCase):
+    def test_find_min(self):
+        self.assertEqual(find_min([3, 4, 5, 1, 2]), 1)
+        self.assertEqual(find_min([4, 5, 6, 7, 0, 1, 2]), 0)
+        self.assertEqual(find_min([11, 13, 15, 17]), 11)

Binary Search/median_of_two_sorted_arrays.py

@@ -47,7 +47,7 @@ def find_median_sorted_arrays(nums1: List[int], nums2: List[int]) -> float:
             left = i + 1
 
 
-class TestFindMedianSortedArrays(unittest.TestCase):
+class Test(unittest.TestCase):
     def test_basic_case(self):
         nums1 = [1, 3]
         nums2 = [2]

Binary Search/search_in_rotated_sorted_array.py

@@ -0,0 +1,46 @@
+# https://neetcode.io/problems/find-target-in-rotated-sorted-array
+
+from typing import List
+
+import unittest
+
+
+def search(nums: List[int], target: int) -> int:
+    n = len(nums)
+
+    if n == 0:
+        return -1
+
+    left = 0
+    right = n - 1
+
+    while left <= right:
+        mid = (right + left) // 2
+
+        if nums[mid] == target:
+            return mid
+
+        if nums[mid] >= nums[left]:
+            if nums[left] <= target < nums[mid]:
+                right = mid - 1
+            else:
+                left = mid + 1
+        else:
+            if nums[mid] < target <= nums[right]:
+                left = mid + 1
+            else:
+                right = mid - 1
+
+    return -1
+
+
+class Test(unittest.TestCase):
+    def test_search(self):
+        self.assertEqual(search([4, 5, 6, 7, 0, 1, 2], 0), 4)
+        self.assertEqual(search([4, 5, 6, 7, 0, 1, 2], 3), -1)
+        self.assertEqual(search([1], 0), -1)
+        self.assertEqual(search([1], 1), 0)
+        self.assertEqual(search([1, 3], 3), 1)
+        self.assertEqual(search([3, 1], 3), 0)
+        self.assertEqual(search([3, 1], 1), 1)
+        self.assertEqual(search([3, 1], 0), -1)

Linked Lists/__init__.py

@@ -0,0 +1,51 @@
+# https://neetcode.io/problems/add-two-numbers
+
+from typing import Optional
+
+import unittest
+
+# We can use `divmod` to get the quotient and the remainder of the division
+# see https://docs.python.org/3/library/functions.html#divmod
+# Doing it by hand:
+# new_digit = a + b + carry
+# carry = new_digit // 10
+# new_digit %= 10
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+def add_two_numbers(
+    l1: Optional[ListNode], l2: Optional[ListNode]
+) -> Optional[ListNode]:
+    sentinel = ListNode()
+    current = sentinel
+
+    carry = 0
+
+    while l1 or l2 or carry:
+        a = l1.val if l1 else 0
+        b = l2.val if l2 else 0
+
+        carry, new_digit = divmod(a + b + carry, 10)
+
+        current.next = ListNode(new_digit)
+
+        current = current.next
+
+        l1 = l1.next if l1 else None
+        l2 = l2.next if l2 else None
+
+    return sentinel.next
+
+
+class Test(unittest.TestCase):
+    def test_add_two_numbers(self):
+        l1 = ListNode(2, ListNode(4, ListNode(3)))
+        l2 = ListNode(5, ListNode(6, ListNode(4)))
+        self.assertEqual(add_two_numbers(l1, l2).val, 7)
+        self.assertEqual(add_two_numbers(l1, l2).next.val, 0)
+        self.assertEqual(add_two_numbers(l1, l2).next.next.val, 8)

Linked Lists/add_two_numbers.py

@@ -0,0 +1,46 @@
+# https://neetcode.io/problems/linked-list-cycle-detection
+
+from typing import Optional
+
+import unittest
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+def has_cycle(head: Optional[ListNode]) -> bool:
+    slow = head
+    fast = head.next
+
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+
+        if slow == fast:
+            return True
+
+    return False
+
+
+class Test(unittest.TestCase):
+    def test_hasCycle(self):
+        head = ListNode(3, ListNode(2, ListNode(0, ListNode(-4))))
+        head.next.next.next.next = head.next
+
+        self.assertTrue(has_cycle(head))
+
+        head = ListNode(1, ListNode(2))
+        head.next.next = head
+
+        self.assertTrue(has_cycle(head))
+
+        head = ListNode(1)
+
+        self.assertFalse(has_cycle(head))
+
+        head = ListNode(1, ListNode(2, ListNode(3)))
+
+        self.assertFalse(has_cycle(head))

Linked Lists/linked_list_cycle.py

@@ -0,0 +1,48 @@
+# https://neetcode.io/problems/merge-two-sorted-linked-lists
+
+from typing import Optional
+
+import unittest
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+def merge_two_lists(
+    list1: Optional[ListNode], list2: Optional[ListNode]
+) -> Optional[ListNode]:
+    sentinel = ListNode()
+    current = sentinel
+
+    while list1 and list2:
+        if list1.val < list2.val:
+            current.next = list1
+            list1 = list1.next
+        else:
+            current.next = list2
+            list2 = list2.next
+
+        current = current.next
+
+    # Attach remaining portion of list1 or list2
+    current.next = list1 or list2
+
+    return sentinel.next
+
+
+class Test(unittest.TestCase):
+    def test_mergeTwoLists(self):
+        list1 = ListNode(1, ListNode(2, ListNode(4)))
+        list2 = ListNode(1, ListNode(3, ListNode(4)))
+
+        result = merge_two_lists(None, list1, list2)
+
+        self.assertEqual(result.val, 1)
+        self.assertEqual(result.next.val, 1)
+        self.assertEqual(result.next.next.val, 2)
+        self.assertEqual(result.next.next.next.val, 3)
+        self.assertEqual(result.next.next.next.next.val, 4)
+        self.assertEqual(result.next.next.next.next.next.val, 4)

Linked Lists/merge_two_sorted_lists.py

@@ -0,0 +1,64 @@
+# https://neetcode.io/problems/reorder-linked-list
+
+from typing import Optional
+
+import unittest
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+def reorder_list(head: Optional[ListNode]) -> None:
+    # Find middle of linked list
+
+    slow = head
+    fast = head.next
+
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+
+    # Slow now points to the middle of the list
+    second = slow.next
+    previous = slow.next = None  # Detach the second half
+
+    # Reverse
+
+    while second:
+        nxt = second.next
+
+        second.next = previous
+        previous = second
+
+        second = nxt
+
+    # Merge
+
+    first = head
+    second = previous
+
+    while second:
+        nxt1, nxt2 = first.next, second.next
+
+        first.next = second
+        second.next = nxt1
+
+        first, second = nxt1, nxt2
+
+
+class Test(unittest.TestCase):
+    def test_reorderList(self):
+        head = ListNode(1)
+        head.next = ListNode(2)
+        head.next.next = ListNode(3)
+        head.next.next.next = ListNode(4)
+
+        reorder_list(head)
+
+        self.assertEqual(head.val, 1)
+        self.assertEqual(head.next.val, 4)
+        self.assertEqual(head.next.next.val, 2)
+        self.assertEqual(head.next.next.next.val, 3)

Linked Lists/reorder_list.py

@@ -0,0 +1,39 @@
+# https://neetcode.io/problems/reverse-a-linked-list
+
+from typing import Optional
+
+import unittest
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+def reverse_linked_list(head: Optional[ListNode]) -> Optional[ListNode]:
+    prev = None
+    current = head
+
+    while current:
+        next_node = current.next
+
+        current.next = prev
+
+        prev = current
+        current = next_node
+
+    return prev
+
+
+class Test(unittest.TestCase):
+    def test_reverse_linked_list(self):
+        head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5)))))
+        reversed_head = reverse_linked_list(head)
+
+        self.assertEqual(reversed_head.val, 5)
+        self.assertEqual(reversed_head.next.val, 4)
+        self.assertEqual(reversed_head.next.next.val, 3)
+        self.assertEqual(reversed_head.next.next.next.val, 2)
+        self.assertEqual(reversed_head.next.next.next.next.val, 1)
+        self.assertIsNone(reversed_head.next.next.next.next.next)