updated .py filename

Author: Mayank-tech69

pydatastructs/sorting/MERGE SORT/merge_sort.py

@@ -0,0 +1,55 @@
+def merge_sort(arr):
+    """
+    Function to perform Merge Sort on a given list.
+
+    Args:
+    arr (list): Unsorted list to be sorted.
+
+    Returns:
+    list: Sorted list in ascending order.
+    """
+    if len(arr) > 1:
+        # Finding the middle of the array to divide it
+        mid = len(arr) // 2
+        
+        # Dividing the array into two halves
+        left_half = arr[:mid]
+        right_half = arr[mid:]
+
+        # Recursively sorting both halves
+        merge_sort(left_half)
+        merge_sort(right_half)
+
+        # Initializing pointers for left, right, and the merged array
+        i = j = k = 0
+
+        # Merging the two sorted halves into a single sorted array
+        while i < len(left_half) and j < len(right_half):
+            if left_half[i] < right_half[j]:
+                arr[k] = left_half[i]
+                i += 1
+            else:
+                arr[k] = right_half[j]
+                j += 1
+            k += 1
+
+        # Checking if any element remains in left_half
+        while i < len(left_half):
+            arr[k] = left_half[i]
+            i += 1
+            k += 1
+
+        # Checking if any element remains in right_half
+        while j < len(right_half):
+            arr[k] = right_half[j]
+            j += 1
+            k += 1
+
+    return arr
+
+# Example usage:
+if __name__ == "__main__":
+    example_arr = [38, 27, 43, 3, 9, 82, 10]
+    print("Original Array:", example_arr)
+    sorted_arr = merge_sort(example_arr)
+    print("Sorted Array:", sorted_arr)

pydatastructs/sorting/QUICK SORT/quick_sort.py

@@ -0,0 +1,58 @@
+def quick_sort(arr, start, end):
+    """
+    Quick Sort algorithm: Sorts the array in ascending order.
+    
+    Parameters:
+        arr (list): The list of elements to be sorted.
+        start (int): The starting index of the array segment.
+        end (int): The ending index of the array segment.
+    """
+    if start < end:
+        # Partition the array and get the pivot index
+        pivot_index = partition(arr, start, end)
+        
+        # Recursively sort the left subarray
+        quick_sort(arr, start, pivot_index - 1)
+        
+        # Recursively sort the right subarray
+        quick_sort(arr, pivot_index + 1, end)
+
+
+def partition(arr, start, end):
+    """
+    Partitions the array around a pivot such that all elements smaller than
+    or equal to the pivot are on the left, and all elements greater are on the right.
+    
+    Parameters:
+        arr (list): The list of elements to be partitioned.
+        start (int): The starting index of the array segment.
+        end (int): The ending index of the array segment (pivot).
+    
+    Returns:
+        int: The index of the pivot element after partitioning.
+    """
+    pivot = arr[end]  # Choose the last element as the pivot
+    partition_index = start  # Initialize the partition index
+
+    for i in range(start, end):
+        if arr[i] <= pivot:
+            # Swap if the current element is smaller than or equal to the pivot
+            arr[i], arr[partition_index] = arr[partition_index], arr[i]
+            partition_index += 1
+
+    # Place the pivot element at the correct position
+    arr[partition_index], arr[end] = arr[end], arr[partition_index]
+    return partition_index
+
+
+# Example Usage
+if __name__ == "__main__":
+    # Input array
+    array = [8, 3, 1, 7, 0, 10, 2]
+    print("Original Array:", array)
+
+    # Perform Quick Sort
+    quick_sort(array, 0, len(array) - 1)
+    
+    # Output sorted array
+    print("Sorted Array:", array)