Recursion on Arrays

Author: Shikha-code36

README.md

@@ -8,4 +8,7 @@ Data Structures and Algorithms implementation in Python.
         - [x] [Factorial](Recursion/Basic-Problems/factorial.py)
         - [x] [Fibonacci](Recursion/Basic-Problems/fibonacci.py)
         - [x] [Sum of Geometric Progression](Recursion/Basic-Problems/GP.py)
-        - [x] [Tower of Hanoi](Recursion/Basic-Problems/TOH.py)
+        - [x] [Tower of Hanoi](Recursion/Basic-Problems/TOH.py)
+    - [x] [Recursion on Arrays](Recursion/Arrays)
+        - [x] [Merge Sort Array](Recursion/Arrays/mergesort.py)
+        - [x] [Quick Sort Array](Recursion/Arrays/quicksort.py)

Recursion/Arrays/mergesort.py

@@ -0,0 +1,66 @@
+'''
+                                        Merge Sort  
+
+Merge sort is a Divide and Conquer based Algorithm. It divides the input array into two-parts, until the size of the input array is not ‘1’. In the return part, it will merge two sorted arrays a return a whole merged sorted array.
+
+This is the recursive approach for implementing merge sort. The steps needed to obtain the sorted array through this method can be found below:
+
+1.The list is divided into left and right in each recursive call until two adjacent elements are obtained.
+
+2.Now begins the sorting process. The i and j iterators traverse the two halves in each call. The k iterator traverses the whole lists and makes changes along the way.
+
+3.If the value at i is smaller than the value at j, left[i] is assigned to the arr[k] slot and i is incremented. If not, then right[j] is chosen.
+
+4.This way, the values being assigned through k are all sorted.
+
+5.At the end of this loop, one of the halves may not have been traversed completely. Its values are simply assigned to the remaining slots in the list.
+
+And with that, the merge sort has been implemented!
+
+Time Complexity - O(nlogn)
+
+'''
+
+def mergesort(arr):
+    if len(arr)>1:
+        left = arr[:len(arr)//2]
+        right = arr[len(arr)//2:]
+
+        #recursion
+        mergesort(left)
+        mergesort(right)
+
+        #merge
+        i=0 #left array index
+        j=0 #right array index
+        k=0 #merged array index
+
+        #to look at every element in the right array and transfer every element from the right to the merged array
+        while i<len(left) and j<len(right):
+            if left[i] <right[j]:
+                arr[k] = left[i]
+                i += 1
+                #k += 1
+            else:
+                arr[k] = right[j]
+                j += 1
+                #k += 1
+            k += 1 #in both cases we need to increment k
+
+        #to look at every element in the left array and transfer every element from the left to the merged array
+        while i<len(left): #because there's element  missing from the left array to transfer
+            arr[k] = left[i]
+            i += 1
+            k += 1
+
+        while j<len(right): #to check if we are not at the end of array
+            arr[k] = right[j]
+            j += 1
+            k += 1
+    
+    return arr
+
+print(mergesort([8, 3, 5, 6, 11, 19, 7])) #[3, 5, 6, 7, 8, 11, 19]
+        
+
+

Recursion/Arrays/quicksort.py

@@ -0,0 +1,53 @@
+'''
+                                Quick Sort
+
+Divide and conquer: Quicksort splits the array into smaller arrays until it ends up with an empty array, or one that has only one element, before recursively sorting the larger arrays.
+
+The basic version of the algorithm does the following:
+
+Divide the collection in two (roughly) equal parts by taking a pseudo-random element and using it as a pivot.
+
+Elements smaller than the pivot get moved to the left of the pivot, and elements larger than the pivot to the right of it.
+
+This process is repeated for the collection to the left of the pivot, as well as for the array of elements to the right of the pivot until the whole array is sorted.
+
+Time Complexity - O(n^2)
+
+'''
+
+
+def quicksort(arr,left,right):
+    if left<right:
+        partition_pos = partition(arr,left,right)
+        quicksort(arr,left,partition_pos-1)
+        quicksort(arr,partition_pos+1,right)
+    return arr
+
+#this function returns the index of the pivot element
+#after the first step of quicksort, when we have this index in partition_pos we can call quicksort on the original array 
+# from index left to index partition position minus onewhich just means that we call quicksort on all elements that are less than the pivot element 
+#we can call quick sort on the array from partition position plus one to the right so we call quicksort on the sub-array that contains all elements that are greater than the pivot element
+def partition(arr,left,right): 
+    i = left
+    j = right-1
+    pivot = arr[right] # choose the rightmost element as pivot
+
+    #i moves to the right and j moves to the left until i and j cross will be checked by this while loop
+    while i<j:
+        while i<right and arr[i] < pivot: #i to the right while i is not at the end of the array and element is less than pivot we increase i
+            i+=1
+        while j>left and arr[i] >= pivot: #similiar for j  decrease j because j moves to the left
+            j-=1
+
+        if i<j: #if i and j didn't cross we swap elements
+            arr[i], arr[j] = arr[j], arr[i]
+    
+    if arr[i]>pivot: #if i and j crossed means element at i is greater than pivot then do swap those elements
+        arr[i],arr[right] = arr[right],arr[i]
+
+    return i  #to determine where to split the array to call quick sort recursively
+
+arr=[7,9,10,3,5,12,90,43]
+print(quicksort(arr,0,len(arr)-1)) #[5, 7, 9, 3, 10, 12, 43, 90]
+
+