Quick sort
0 likes215 views
Quicksort is a sorting algorithm that uses a divide and conquer approach. It works by selecting a pivot element and partitioning the array around the pivot so that elements less than the pivot are to its left and greater elements are to its right. It then recursively applies this process to the subarrays until each contains a single element, at which point the array is fully sorted. The example demonstrates quicksort sorting an array from 0 to 7.
![5 6 7
80 70=j 90=i
5 6 7
70 80 90
Finally
0 1 2 3 4 5 6 7
10 20 30 40 50 70 80 90
Algorithm QuickSort(l,h)
{
if(l<h)
{
j=Partition(l,h);
QuickSort(l,j);
QuickSort(j+1,h);
}
}
Algorithm Partition(l,h)
{
Pivot=A[l];
i=l,j=h;
while(i<j)
{
do
{
i++;
}while(A[i]<=pivot);
do
{](https://image.slidesharecdn.com/quicksort-210706145445/85/Quick-sort-3-320.jpg)
![j--;
}while(A[j]>pivot);
if(i<j)
swap(A[i],A[j]);
}
Swap(A[l],A[j]);
return j;
}](https://image.slidesharecdn.com/quicksort-210706145445/85/Quick-sort-4-320.jpg)
Quick sort
- 1. Quick Sort Quicksort is a sorting algorithm based on the divide and conquer approach where An array is divided into subarrays by selecting a pivot element (element selected from the array). While dividing the array, the pivot element should be positioned in such a way that elements less than pivot are kept on the left side and elements greater than pivot are on the right side of the pivot. The left and right subarrays are also divided using the same approach. This process continues until each subarray contains a single element. At this point, elements are already sorted. Finally, elements are combined to form a sorted array. Example: 0 1 2 3 4 5 6 7 50=i 30 10 90 80 20 40 70=j Pivot=50 0 1 2 3 4 5 6 7 50 30 10 90=i 80 20 40=j 70 0 1 2 3 4 5 6 7 50 30 10 40=i 80 20 90=j 70 0 1 2 3 4 5 6 7 50 30 10 40 80=i 20=j 90 70 0 1 2 3 4 5 6 7 50 30 10 40 20=i 80=j 90 70 0 1 2 3 4 5 6 7 50 30 10 40 20=j 80=i 90 70 0 1 2 3 4 5 6 7 20 30 10 40 50 80 90 70
- 2. Left Half 0 1 2 3 20=i 30 10 40=j Pivot=20 0 1 2 3 20 30=i 10=j 40 0 1 2 3 20 10=i 30=j 40 0 1 2 3 20 10=j 30=i 40 0 1 2 3 10 20 30 40 Right Half 5 6 7 80=i 90 70=j Pivot=80 5 6 7 80 90=i 70=j 5 6 7 80 70=i 90=j
- 3. 5 6 7 80 70=j 90=i 5 6 7 70 80 90 Finally 0 1 2 3 4 5 6 7 10 20 30 40 50 70 80 90 Algorithm QuickSort(l,h) { if(l<h) { j=Partition(l,h); QuickSort(l,j); QuickSort(j+1,h); } } Algorithm Partition(l,h) { Pivot=A[l]; i=l,j=h; while(i<j) { do { i++; }while(A[i]<=pivot); do {