Quicksort is a sorting algorithm that works by partitioning an array around a pivot value, and then recursively sorting the sub-partitions. It chooses a pivot element and partitions the array based on whether elements are less than or greater than the pivot. Elements are swapped so that those less than the pivot are moved left and those greater are moved right. The process recursively partitions the sub-arrays until the entire array is sorted.

1. QuickSort
• Quick sort works by partitioning the array to be sorted.
• each partition is internally sorted recursively.
• As a first Step, this algorithm chooses one elements of an array as a pivot or a key element.
• the array is then partitioned on either side of the pivot.
• elements are moved so that those greater then the pivot are shifted to its right where as
the others are shifted to its left.
• two pointers low and up are initialized to the lower and upper boundes of the sub array.
• up pointer will be decremented and low pointer will be incremented as per following
condition.
1. Increase low pointer until t[low] > pivot.
2. Decrease up pointer until t[up] <= pivot.
3. If low < up then interchange t[low] with t[up].
4. If up <= low then interchange t[up] with t[i].

2. Algorithm
Produce pivot(T[i,...,j];var |)
{Permutes the elements in array T[i,...,j] and returns a value i such that, at the end, i<=1<=j,
T[k]<=p for all i<=k<i, t[i]=p, and t[k]>p for all i<k<=j, where p is the initial value t[i]}
P<--T[i]
K<--I; I<--J+1
Repeat k<--k+1 until t[k]>p
Repeat I<--I-1 untill T[i]<=p
While k < I do
Swap T[k] and T[i]
Repeat k<--k+1Untill T[k]>p
Repeat I<--I-1 Untill T[i]<=p
Swap T[i] and T[i]
Procedure quicksort(T[i,...,j])
{Sorts subarray T[i,...,j] into non decreasing order}
If j -- i is sufficiently small then insert (T[i,...,j])
else
Pivot(T[i,...,j],i)
Quicksort(T[i,..., I --1])
Quicksort(T[i+1,...,j])

3. Analysis
1. Worst case
• Running time of quick sort depends on whether the partitioning is balanced or unbalanced.
• And this in turn depends on which elements elements is chosen as key or pivot elements.
• The worst case behavior for quick sort occurs when the partitioning routine produces one
sub problem with n--1 elements and one with 0 elements.
• In this case recurrence will be,
T(n)=t(n-1)+t(0)+o(n)
T(n)=t(n-1)+o(n)
T(n)=o(n2)
2. Best case
• Occures when partition produces sub problems each of size n/2.
• Recurrence equation:
T(n)=2t(n/2)+o(n)
I=2, B=2, K=1, so I=Bk
T(n)=o(nlogn)

4. 3. Average case
• Average case running time is much closer to the best case.
• If suppose the partitioning algorithm produces a 9--to--1 proportional split the recurrence
will be
T(n)=t(9n/10)+t(n/10)+o(n)
Solving it,
T(n)=o(nlogn)
• The running time of quick sort is therefor o(nlogn) whenever the split has constant
proportionality.

5. 20 10 80 100307506040
Pivot,i j
Here, pivot = T[i], k = 1, i=j+1
Repeat k = k+1, Untill T[k] > pivot
Repeat i = i-1, Untill T[k] <= pivot
20 10 80 100307506040
Pivot K i
Is k < I ? , Yes then Swap T[k] <--> T[i]
Example

6. 20 10 30 100807506040
Pivot K i
Repeat i = i-1, Untill T[k] <= Pivot
Repeat k = k+1, Untill T[k] > Pivot
20 10 30 100807506040
Pivot K i
Is k < I ? , Yes then Swap T[k] <--> T[i]
20 10 30 100806050740
Pivot K i

7. Repeat k = k+1, Untill T[k] > pivot
Repeat i = i-1, Untill T[k] <= pivot
20 10 30 100806050740
Pivot Ki
Is k < I ? , No then Swap Pivot <--> T[i]
20 10 30 100806050407
Pivot

8. • Now we have two sub list one having elements less or equal pivot and second
having elements greater than pivot.
20 10 30 1008060507
Pivot,i j Pivot,i
40
j
• Sorted Array
10 20 30 100806050407

9. Thank You