From 044e186eaa67737b273fc2b75b8307f32548af0d Mon Sep 17 00:00:00 2001
From: shubhakari <shubhakaridikshith@gmail.com>
Date: Sun, 22 Dec 2024 21:45:32 -0800
Subject: [PATCH] completed precourse 2

---
 Exercise_1.py | 18 ++++++++++++++----
 Exercise_2.py | 14 ++++++++++++++
 Exercise_3.py | 25 +++++++++++++++++++++++--
 Exercise_4.py | 33 +++++++++++++++++++++++++++++++--
 Exercise_5.py | 24 ++++++++++++++++++++++++
 5 files changed, 106 insertions(+), 8 deletions(-)

diff --git a/Exercise_1.py b/Exercise_1.py
index 3e6adcf4..04a2e98b 100644
--- a/Exercise_1.py
+++ b/Exercise_1.py
@@ -6,17 +6,27 @@
 def binarySearch(arr, l, r, x): 
   
   #write your code here
-  
+  # The Binary Search function checks whether an element exists in a given array by utilizing the left 
+  # and right pointers of the array and updating them based on specific criteria.
+  while l<=r:
+     mid = (l+r)//2
+     if arr[mid] == x:
+        return mid
+     elif arr[mid] < x:
+        l = mid +1
+     else:
+        r = mid -1  
+  return -1 
     
   
 # Test array 
 arr = [ 2, 3, 4, 10, 40 ] 
-x = 10
+x = 4
   
 # Function call 
 result = binarySearch(arr, 0, len(arr)-1, x) 
   
 if result != -1: 
-    print "Element is present at index % d" % result 
+    print("Element is present at index ", result)
 else: 
-    print "Element is not present in array"
+    print ("Element is not present in array")
diff --git a/Exercise_2.py b/Exercise_2.py
index 35abf0dd..8714e1c7 100644
--- a/Exercise_2.py
+++ b/Exercise_2.py
@@ -5,12 +5,26 @@ def partition(arr,low,high):
   
   
     #write your code here
+    # Rearranges the array so that smaller and greater elements are to left side and right side of pivot element respectively. 
+    pivot = arr[high]
+    i = low - 1
+    for j in range(low,high):
+        if arr[j] <pivot:
+            i += 1
+            arr[i],arr[j] = arr[j],arr[i]
+        arr[i+1],arr[high] = arr[high],arr[i+1]
+    return i+1
   
 
 # Function to do Quick sort 
 def quickSort(arr,low,high): 
     
     #write your code here
+    # Sorts the left and right sub arrays recursively based on the index.
+    if low<high:
+        pi = partition(arr,low,high)
+        quickSort(arr,low,pi-1)
+        quickSort(arr,pi+1,high)
   
 # Driver code to test above 
 arr = [10, 7, 8, 9, 1, 5] 
diff --git a/Exercise_3.py b/Exercise_3.py
index a26a69b8..272d50cc 100644
--- a/Exercise_3.py
+++ b/Exercise_3.py
@@ -2,19 +2,38 @@
 class Node:  
   
     # Function to initialise the node object  
-    def __init__(self, data):  
+    def __init__(self, data=0,next=None):  
+        self.data = data
+        self.next = next
         
 class LinkedList: 
   
     def __init__(self): 
-        
+        # Initialise the head node
+        self.head = Node()
   
     def push(self, new_data): 
+        # Append a new node to the list if we have a head node or assign the new node as head node
+        if self.head is None:
+            newNode = Node(new_data)
+            self.head = newNode
+            return
+        newNode = Node(new_data)
+        temp = self.head
+        while temp.next is not None:
+            temp = temp.next
+        temp.next = newNode
         
   
     # Function to get the middle of  
     # the linked list 
     def printMiddle(self): 
+        # use 2 pointers slow and fast to fetch the middle node.
+        slow,fast = self.head,self.head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        print("Value of Middle Node: ",slow.data)
 
 # Driver code 
 list1 = LinkedList() 
@@ -23,4 +42,6 @@ def printMiddle(self):
 list1.push(2) 
 list1.push(3) 
 list1.push(1) 
+list1.push(10)
+list1.push(11)
 list1.printMiddle() 
diff --git a/Exercise_4.py b/Exercise_4.py
index 9bc25d3d..7ddc8152 100644
--- a/Exercise_4.py
+++ b/Exercise_4.py
@@ -1,18 +1,47 @@
 # Python program for implementation of MergeSort 
+def merge(left, right):
+    result = []
+    i = j = 0
+
+    while i < len(left) and j < len(right):
+        if left[i] < right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+
+    result.extend(left[i:])
+    result.extend(right[j:])
+
+    return result
+
 def mergeSort(arr):
   
   #write your code here
+    if len(arr) <= 1:
+        return arr
+
+    mid = len(arr) // 2
+    leftHalf = arr[:mid]
+    rightHalf = arr[mid:]
+
+    sortedLeft = mergeSort(leftHalf)
+    sortedRight = mergeSort(rightHalf)
+
+    return merge(sortedLeft, sortedRight)
   
 # Code to print the list 
 def printList(arr): 
     
     #write your code here
+    print(arr)
   
 # driver code to test the above code 
 if __name__ == '__main__': 
     arr = [12, 11, 13, 5, 6, 7]  
     print ("Given array is", end="\n")  
     printList(arr) 
-    mergeSort(arr) 
+    sortedarr = mergeSort(arr) 
     print("Sorted array is: ", end="\n") 
-    printList(arr) 
+    printList(sortedarr) 
diff --git a/Exercise_5.py b/Exercise_5.py
index 1da24ffb..07bd3d2e 100644
--- a/Exercise_5.py
+++ b/Exercise_5.py
@@ -3,8 +3,32 @@
 # This function is same in both iterative and recursive
 def partition(arr, l, h):
   #write your code here
+  # Rearranges the array so that smaller and greater elements are to left side and right side of pivot element respectively. 
+  pivot = arr[h]
+  i = l - 1
+  for j in range(l,h):
+    if arr[j] < pivot:
+      i+=1
+      arr[i],arr[j] = arr[j],arr[i]
+    arr[i+1],arr[h] = arr[h],arr[i+1]
+  return i+1
 
 
 def quickSortIterative(arr, l, h):
   #write your code here
+  # This approach follows the idea of appending the start and end indexes of arrays and corresponding subarrays for the array partitions.
+  st = []
+  st.append((0,len(arr)-1))
+  while st:
+    l,h = st.pop()
+    if l <h :
+      pi = partition(arr,l,h)
+      st.append((l,pi-1))
+      st.append((pi+1,h))
 
+# Driver code to test above 
+arr = [10, 7, 8, 9, 1, 5] 
+n = len(arr) 
+quickSortIterative(arr,0,n-1) 
+print ("Sorted array is:") 
+print(arr)
\ No newline at end of file