this ppt most useful for engineering students...

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