An overview of the QuickSort algorithm (2023)

Sorting organizes items in a structured way. Quicksort is one of the most popular sorting algorithms in use.nlognCompare the sorting of an array of n elements in a typical situation. Quicksort is based onDivide and conquer strategy.Let's look at the fast sort algorithm in this tutorial and see how it works.

Quicksort is a fast sorting algorithm that divides a large array of data into smaller subarrays.This implies that each iteration works by splitting the input into two components, sorting them, and recombining them.For large amounts of data, the technology is highly efficient due to its medium and optimal complexity.O(n*login).

Developed by Tony Hoare in 1961, it remains one of the most effective general-purpose sorting algorithms available today. It works by recursively sorting the sublists on either side of a given pivot and dynamically moving the list items around that pivot.

Therefore, the quick classification method can be summarized in three steps:

• To choose:Choose an element.
• To divide:Break up the problem set by moving smaller pieces to the left of the pivot and larger pieces to the right.
• Repeat and combine:Repeat the steps and combine the previously sorted matrices.

Benefits of Quicksort

Let's look at some of the main benefits of using Quicksort:

• It works quickly and efficiently.
• It has the best time complexity compared to other ranking algorithms.
• Quick Sort has a spatial complexity ofthe (enter), making it an excellent choice for situations where space is limited.

Quicksort Limitations

Although QuickSort is the fastest algorithm, it has some drawbacks. Let's take a look at some of the disadvantages of Quicksort.

• This sorting technique is considered unstable because it does not preserve the initial order of key-value pairs.
• When the pivot is the largest or smallest, or when all components are the same size. Quicksort performance is severely impacted by these worst case scenarios.
• It is difficult to implement because it is a recursive process, especially when recursion is not available.

Let's look at an example to better understand the fast sort algorithm. In this example, the matrix(shown in the graphic below)contains unsorted values ​​that we will sort using quicksort.

1). Select pivot point

The process starts with selection.an element (known as a pivot)from the list; It can be any element. A pivot can be:

• every random item
• The first or last item.
• middle element

For this example, we used the last element,4,as our axis.

two). array reordering

The objective here now is to reorganize the list so that all itemsless than the pivot are on the leftof this and allElements larger than the pivot are directed to the rightfrom that.

• HeThe pivot element is compared to all elementsstarting with the first index. If the element is greater than the pivot element, a second pointer is added.
• Compared to other itemsif an element smaller than the pivot element is found, the smaller element is replaced by the previously identified larger element.

Let's simplify the previous example,

• Every element that starts with7, is compared to the pivot (4). A second pointer is defined as7bom7is bigger than4.
• The next element, element2it is now compared to the pivot. As2It is less than4, is replaced by the largest number7what was found before.
• The payment7Y2They are exchanged. The pivot is now compared to the closest element,1which is less than4.
• ok one more time7is exchanged with1.
• The process continues until the penultimate element is reached,and at the end, the pivot element is replaced by the second pointer. here, number4(Pivot) is replaced by number6.

like elements2,1, Y3they are less than 4, they are on the left side of the pivot. The elements can be in any order:"1", "2", "3" or "3", "1", "2" or "2", "3", "1". The only requirement is that all elements must be less than the pivot point. Also, on the right side, all components must be greater than the pivot, regardless of their order.

Simply put, the algorithm looks for any value that is less than the pivot. Values ​​less than pivot are placed on the left, while values ​​greater than pivot are placed on the right. Once the values ​​are reordered, the pivot is placed in its sorted position.

3). Share Subarrays

After we partition the array we can solve this problemtwo sub-problems. First,Sort array segmentto the left of the pivot, and then sort the array segment to the right of the pivot.

• In the same way that we rearranged the elements in step 2,We will select a pivot element for each of the left and right subparts individually.
• Now let's organize the sublist so that all elements are less than the pivot point that points to the left. element for example3is the largest of the three elements that satisfies the condition, so the element3is in an orderly position.
• In the same way, we will edit the sublist again and order the elements2Y1. We will stop the process when we are done with a single item.
• Repeat the same process for the sublist on the right.Subarrays are further subdivided until each subarray consists of a single element.
• Now the array is sorted at this point :)

Fast Sort Algorithm

//start -> start index, end --> end index
quicksort(array, start, end)
{
if (start < end)
{
pIndex = partition(A, start, end)
Fast sort (A, start, pIndex-1)
Quicksort(A,pIndex+1, fin)
}
}

divisionfunction algorithm

Subarrays are rearranged in a specific order using the partition method. You will find different ways to partition. Here we see one of the most used methods.

partition(array, start, end)
{
// Set the rightmost index as a pivot
Pivot = arr[End];
i = (start - 1) // index of the smallest element and display it
// Correct pivot position found so farfor (j = start; j <= end- 1; j++)
{
// If the current element is less than the pivot
if (arr[j] < Girar)
{
I++; //Increase the index of the smallest element
Swap arr[i] and arr[j].
}
}
interchange arr[i + 1] and arr[end])
back (me + 1)
}

Let's look at quick sort programs written in the JavaScript and Python programming languages.

JavaScript

Let's start by creating a function that allows you to swap two components.

Function Interchange (arr, i, j)
{ let temp = arr[i];
matrix[i] = matrix[j];
matrix[j] = temperature;
}

Now let's add a function that takes the last element (last value) as the pivot, moves all minor elements to the left of the pivot and all major elements to the right of the pivot, and places the pivot in the appropriate location in the .sorted array.

function partition(arr, start, end) {
// pivot point
let pivot = arr[end];
/* Index of a minor element that indicates the correct position of the pivot previously. */
six i = (start - 1);
for (chica j = inicio; j <= fin - 1; j++) {
// If the current element is less than the pivot
if (arr[j] < Girar) {
you++;
swap(arr, i, j);
}
}
swap(arr, i + 1, Fin);
return(i+1);
}

Then we add the main function that splits and sorts the elements.

function quicksort(arr, start, end) {
if (start < end) {
// The partition index is represented by pi.
let pi = partition(arr, start, end);
// Sort the elements before and after the partition separately
quicksort(arr, start, pi - 1);
quicksort(arr, pi + 1, fim);
}
}

Finally, let's add a function to print the array.

function printArray(array, size) {
for (let i = 0; i < size; i++)
document.write(arr[i] + " ");
document.write("");
}
// Let's start sorting the unsorted ones.
let arr = [7, 2, 1, 6, 8, 5, 3, 4];
let n = arr.length;
document.write("Matriz original:" + arr);
quicksort(arr, 0, n - 1);
document.write("Sortiertes Array:"+arr);

Here is the full (js) quick sort implementation code

(Video) 2.8.1 QuickSort Algorithm

Python

Let's start by creating a function that will sort the first and last elements of an array.

def find_pviot_index(A,inicio,fin):
Pivots=A[End]
p_index=start
to iterate over range (start, end):
and A[iter] <= Pivots:
A[p_index],A[iter]=A[iter],A[p_index]
p_index+=1
A[p_index],A[end]=support point,A[p_index]
return p_index

Next, let's add the main function that QuickSort implements.

def quick_sort(To,start,end):
if start < end:
pivot_index=find_pviot_index(A,inicio,fin)
print("--------------",A)
quick_sort(A,inicio,pivot_index-1)
quick_sort(A,pivot_index+1,fin)

Finally, let's add a function to print the array.

A=List()
n=int(input("Set of numbers to insert:"))
for x in the range (0, n):
num=int(input("Num eingeben:"))
A.appendix(num)
print("Original-Array:",A)
quick_sort(A,0,n-1)
print("Sort array:",A)

Here is the complete code for implementing Quicksort in Python.

Let's look at quicksort's spatial and temporal complexity in best, average, and worst cases. In general, the time consumed by QuickSort can be written as follows.

T(n) = T(k) + T(n-k-1) + O(n)

Here,T(k)YT(n-k-1)refer to two recursive calls while the last termE)refers to the partitioning process. The number of elements less than the pivot is denoted byk.

time complexity

1). Best case complexity:If the partition algorithm always chooses the middle element or close to the middle element as the pivot, the best case scenario will occur. The time complexity of quicksort in the best case isO (n*login). The following is the best case iteration.

T(n) = 2T(n/2) + O(n)//Solution O(nRegister)

two). Average case complexity:This occurs when the array elements are in an unordered order that doesn't grow or shrink correctly. The average time complexity of the Quicksort case isO(n*login). The following is repetition in the average case.

T(n) = T(n/9) + T(9n/10) + O(n)//Solution O(nRegister)

3). Worst case complexity:The worst situation is when the partitioning algorithm chooses the largest or smallest element as the pivot element each time. The worst-case time complexity of Quicksort isem 2). The following is the worst case iteration.

T(n) = T(0) + T(n-1) + O(n)//O(n2) solution

space complexity

The space complexity for quicksort isO(record n).

The sort algorithm is used to find information and since the quick sort is the fastest, it is often used as a more efficient search approach.

• It is used where a stable classification is not required.
• Since it is tail recursive, any optimization call can be executed.
• It is useful in event-driven simulation and operations research.

QuickSort can have some drawbacks, but it is the fastest and most efficient sorting algorithm available. The quick sort has aOr (enter)Spatial complexity, making it an excellent choice for situations where space is limited.

Although the worst-case running time is always the same, Quicksort is generally faster than HeapSort(begin session). Quicksort takes up less space than heapsort (due to the fact that a heap is an almost complete binary tree with pointers to it). So when it comes to sorting arrays, Quicksort is preferred.

QuickSort may have some drawbacks, but it is the fastest sorting algorithm out there. Quick Sort is an efficient algorithm that has proven itself in practice.

In this article, we learned what quicksort is, its advantages and disadvantages, and how to implement it. If you want a detailed explanation of an algorithm or a comparison of algorithms, feel free to comment below.

• https://www.tutorialspoint.com/data_structures_algorithms/quick_sort_algorithm.htm
• https://www.geeksforgeeks.org/quick-sort/
• https://www.cs.dartmouth.edu/~thc/cs5-F96/lec28.html
• https://towardsdatascience.com/quicksort-in-python-dbefa7dcf9cc
• https://github.com/its-harshil/Hacktoberfest_2021/blob/9b7bc632d47df33e70f1649451f1b887c13d4ec3/quick_sort.py