Quick Sort Algorithm

Quick Sort is a popular sorting algorithm that uses a divide-and-conquer approach to sort elements in an array or list. Here’s an explanation:

Quick Sort Algorithm:

1. Partitioning:

   • Choose a pivot element from the array. This pivot can be selected randomly or can be the last element, first element, or median of the array.
   • Rearrange the elements in the array in such a way that all elements less than the pivot are placed before it, and all elements greater than the pivot are placed after it. After this partitioning, the pivot is in its correct sorted position.

2. Recursion:

   • Apply the above steps recursively to the sub-arrays on the left and right sides of the pivot until the entire array is sorted.

Quick Sort Process:

Let’s say you have an array [7, 2, 1, 6, 8, 5, 3, 4].

1. Select Pivot: You might choose the last element, 4, as the pivot.

2. Partitioning: Rearrange the array so that elements less than 4 are on the left, and elements greater than 4 are on the right. After the first partitioning, the array might look like [2, 1, 3, 4, 8, 5, 7, 6]. Here, 4 is in its sorted position.

3. Recursion: Apply the same steps recursively to the left and right sub-arrays ([2, 1, 3] and [8, 5, 7, 6]) until the entire array is sorted.

4. Further Partitioning: For the left sub-array [2, 1, 3], you might choose 2 as the pivot, resulting in [1, 2, 3].

5. For the right sub-array [8, 5, 7, 6], you might choose 7 as the pivot, resulting in [6, 5, 7, 8].

6. Conquering: Eventually, all partitions are sorted, and you merge them to get the fully sorted array.

Key Points:

• Efficiency: Quick Sort is efficient and typically faster than many other sorting algorithms, especially for large datasets.
• Space Complexity: It generally operates in-place, using only a small auxiliary stack.
• Time Complexity: On average, it has a time complexity of O(n log n). However, in the worst-case scenario (rarely encountered), it can degrade to O(n^2), especially if the pivot choice consistently results in unbalanced partitions.

The efficiency of Quick Sort relies on the choice of the pivot element. Different strategies for pivot selection, like picking the median, random elements, or using advanced algorithms for pivot selection, can improve its performance.Certainly! Here’s a simple implementation of Quick Sort in Python along with an explanation of each line:

def partition(arr, low, high):
    pivot = arr[high]  # Selecting the pivot as the last element
    i = low - 1  # Initialize a variable to keep track of the smaller element's index

    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1  # Increment index of smaller element
            arr[i], arr[j] = arr[j], arr[i]  # Swap elements at i and j

    arr[i + 1], arr[high] = arr[high], arr[i + 1]  # Place pivot in its correct position
    return i + 1  # Return the index of the pivot

def quick_sort(arr, low, high):
    if low < high:
        pivot_index = partition(arr, low, high)  # Get the pivot index

        # Recursively sort elements before and after the pivot
        quick_sort(arr, low, pivot_index - 1)
        quick_sort(arr, pivot_index + 1, high)

# Usage:
arr = [7, 2, 1, 6, 8, 5, 3, 4]
quick_sort(arr, 0, len(arr) - 1)
print("Sorted array:", arr)

Explanation of each line:

• def partition(arr, low, high): - This function partitions the array based on the pivot element.
• pivot = arr[high] - Selects the pivot element as the last element of the array.
• i = low - 1 - Initializes a variable to keep track of the smaller element’s index.
• for j in range(low, high): - Loops through the array from low to high.
• if arr[j] <= pivot: - Checks if the current element is less than or equal to the pivot.
• i += 1 - Increments the index of the smaller element.
• arr[i], arr[j] = arr[j], arr[i] - Swaps the elements at positions i and j if necessary to place smaller elements to the left of the pivot.
• arr[i + 1], arr[high] = arr[high], arr[i + 1] - Places the pivot in its correct sorted position.
• return i + 1 - Returns the index of the pivot element.
• def quick_sort(arr, low, high): - This is the main Quick Sort function that recursively sorts the array.
• if low < high: - Checks if there’s more than one element in the sub-array to be sorted.
• pivot_index = partition(arr, low, high) - Gets the index of the pivot element after partitioning.
• quick_sort(arr, low, pivot_index - 1) - Recursively sorts the elements before the pivot.
• quick_sort(arr, pivot_index + 1, high) - Recursively sorts the elements after the pivot.
• arr = [7, 2, 1, 6, 8, 5, 3, 4] - Sample array to be sorted.In the Quick Sort algorithm, the variable i is used to keep track of the position where elements less than or equal to the pivot should be placed in the array during the partitioning step. It’s an essential part of the partitioning process and helps maintain the correct positioning of elements relative to the pivot.

Let’s break down its purpose within the partition function:

1. Initialization: i = low - 1

   • This initializes i to one position before the start of the sub-array being considered. It represents the rightmost index of the elements smaller than the pivot.

2. Looping through the array:

   • As the loop progresses (for j in range(low, high):), whenever an element arr[j] is found that is less than or equal to the pivot:
     • i gets incremented by 1 (i += 1), signifying an increase in the count of elements smaller than the pivot.
     • Elements at positions i and j are swapped (arr[i], arr[j] = arr[j], arr[i]), effectively placing the smaller element in its correct position relative to the pivot.

3. Placing the pivot in its correct position:

   • Finally, after iterating through the array and moving smaller elements to the left side of the pivot, the pivot needs to be placed in the correct position.
   • arr[i + 1], arr[high] = arr[high], arr[i + 1] swaps the pivot element with the element at index i + 1, effectively positioning the pivot in its sorted place.

Without i, the algorithm would have difficulty in correctly partitioning the array and placing elements smaller than the pivot to its left, which is crucial for the Quick Sort’s operation and correct sorting of the array.

• quick_sort(arr, 0, len(arr) - 1) - Initiates the Quick Sort algorithm.
• print("Sorted array:", arr) - Prints the sorted array.