completed PreCourse-2

Exercise_1.py

@@ -5,8 +5,19 @@
 # if present, else returns -1 
 def binarySearch(arr, l, r, x): 
 
-  #write your code here
-
+  # write your code here
+  # tc O(log n), sc O(1).
+  left, right = 0, len(nums) - 1
+
+  while left <= right:
+      mid = left + ((right - left) // 2)
+      if nums[mid] == target:
+          return mid
+      if nums[mid] > target:
+          right = mid - 1
+      else:
+          left = mid + 1
+  return -1
 
 
 # Test array 

Exercise_2.py

@@ -1,16 +1,35 @@
 # Python program for implementation of Quicksort Sort 
 
-# give you explanation for the approach
-def partition(arr,low,high):
-
-
-    #write your code here
-
-
-# Function to do Quick sort 
-def quickSort(arr,low,high): 
+# tc O(n log n), sc O(log n), but in worst case tc O(n^2) and sc O(n).
+# the worst case tc and sc can be reduced by selecting middle element as pivot.
+def partition(start, end):
+    import random
+    random_idx = random.randint(start, end)
+    arr[random_idx], arr[start] = arr[start], arr[random_idx]
 
-    #write your code here
+    left, right = start + 1, end
+
+    while left <= right:
+        if arr[left] <= arr[start]:
+            left += 1
+        elif arr[right] > arr[start]:
+            right -= 1
+        else:
+            arr[left], arr[right] = arr[right], arr[left]
+            left += 1
+            right -= 1
+
+    arr[start], arr[right] = arr[right], arr[start]
+    return right
+
+
+def quickSort(arr, start, end):
+    if start >= end:
+        return
+    pivot_idx = partition(start, end)
+    quick(start, pivot_idx - 1)
+    quick(pivot_idx + 1, end)
+
 
 # Driver code to test above 
 arr = [10, 7, 8, 9, 1, 5] 

Exercise_3.py

@@ -2,19 +2,33 @@
 class Node:  
 
     # Function to initialise the node object  
-    def __init__(self, data):  
+    def __init__(self, data):
+        self.val = data
+        self.next = None
 
 class LinkedList: 
 
     def __init__(self): 
-
+        self.head = None
+        self.tail = None
 
     def push(self, new_data): 
-
+        if not self.head:
+            self.head = Node(new_data)
+            self.tail = self.head
+        else:
+            self.tail.next = Node(new_data)
+            self.tail = self.tail.next
 
     # Function to get the middle of  
     # the linked list 
-    def printMiddle(self): 
+    def printMiddle(self):
+        # tc O(n), sc O(1).
+        slow, fast = head, head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+        return slow
 
 # Driver code 
 list1 = LinkedList() 

Exercise_4.py

@@ -1,12 +1,49 @@
 # Python program for implementation of MergeSort 
 def mergeSort(arr):
 
-  #write your code here
+      # write your code here
+      # tc O(n log n), sc O(n + log n = n).
+      def divide_and_conquer(array, start, end):
+          if start >= end:
+              return
+
+          mid = start + ((end - start) // 2)
+          divide_and_conquer(start, mid)
+          divide_and_conquer(mid+1, end)
+
+          # merge two sorted arrays
+          sorted_arrays = []
+          i, j = start, mid+1
+
+          while i <= mid and j <= end:
+              if array[i] <= array[j]:
+                  sorted_arrays.append(array[i])
+                  i += 1
+              else:
+                  sorted_arrays.append(array[j])
+                  j += 1
+
+          while i <= mid:
+              sorted_arrays.append(array[i])
+              i += 1
+
+          while j <= end:
+              sorted_arrays.append(array[j])
+              j += 1
+
+          array[start:end+1] = sorted_arrays
+
+      divide_and_conquer(arr, 0, len(arr)-1)
 
 # Code to print the list 
 def printList(arr): 
 
-    #write your code here
+    # write your code here
+    sortedlist = []
+    for num in arr:
+        sortedlist.append(num)
+
+    print(sortedlist)
 
 # driver code to test the above code 
 if __name__ == '__main__': 

Exercise_5.py

@@ -1,10 +1,37 @@
 # Python program for implementation of Quicksort
 
-# This function is same in both iterative and recursive
-def partition(arr, l, h):
-  #write your code here
+def random_partition(arr, low, high):
+    # Swapping arr[high] with any random element in the array and then partitioning around
+    # pivot_element = arr[high].
+    import random
+    random_index = random.randint(low, high)
+    arr[random_index], arr[high] = arr[high], arr[random_index]
 
+    pivot = low
+    pivot_element = arr[high]
 
-def quickSortIterative(arr, l, h):
-  #write your code here
+    for i in range(low, high):
+        if arr[i] < pivot_element:
+            arr[i], arr[pivot] = arr[pivot], arr[i]
+            pivot += 1
+
+    # Taking pivot_element to pivot position.
+    arr[pivot], arr[high] = arr[high], arr[pivot]
+    return pivot
+
+def quick_sort(arr):
+    n = len(arr)
+    helper = [(0, n - 1)]
+
+    while helper:
+        low, high = helper.pop()
+
+        pivot = random_partition(arr, low, high)
+
+        if pivot - 1 > low:
+            helper.append((low, pivot - 1))
+        if pivot + 1 < high:
+            helper.append((pivot + 1, high))
+
+    return arr