Subject: Data Structure in C.

1. Abhishek Pachisia
B.Tech(IT)-II yr
09SETIT144

2. It is one of the fastest sorting techniques available.
Like binary search, this method uses a recursive, divide
and conquer strategy
The basic idea is to separate a list of items into two
parts, surrounding a distinguished item called the pivot.
At the end of the process, one part will contain items
smaller than the pivot and the other part will contain items
larger than the pivot.
The performance of the whole Quicksort algorithm
depends on how well the pivot is taken.

3. Let the unsorted list (let it be a)be…
14 3 2 11 5 8 0 2 9 4 20
Unsorted List
1. Let us take the middle element as pivot.
2. Then we arrange the array such that all elements greater then 8 is on right
side and others on left side.(This is the first subdivision producing two sub
list).
3. Now, each sub list is subdivided in exactly the same manner. This process
continues until all sub lists are in order. The list is then sorted. This is a
recursive process.
0 2 2 3 4 5 8 9 11 14 20
Sorted List

4. We choose the value as pivot.(Preferably middle element).
As in binary search, the index of this value is found by (first+last)/2
where first and last are the indices of the initial and final items in the list.
We then identify a left_arrow and right_arrow on the far left and far
right, respectively.(left_arrow and right_arrow initially represent the lowest
and highest indices of the vector items).
It looks like:
Pivot
14 3 2 11 5 8 0 2 9 4 20
left_arrow right_arrow

5. Starting on the right, the right_arrow is moved left until a value less than or
equal to the pivot is encountered.
In a similar manner, left_arrow is moved right until a value greater than or
equal to the pivot is encountered. This is the situation just encountered. Now the
contents of the two vector items are swapped to produce
Pivot
14 3 2 11 5 8 0 2 9 4 20
left_arrow right_arrow
We continue by moving right_arrow left and moving left_arrow right to produce.
Pivot
4 3 2 2 5 0 8 11 9 14 20
right_arrow
left_arrow

6. Since right_arrow < left_arrow is TRUE, the first subdivision is complete. At
this stage, numbers smaller than pivot are on the left side and numbers larger
than pivot are on the right side. This produces two sub lists ,they are:
Pivot
4 3 2 2 5 0 8 11 9 14 20
Smaller Numbers Larger Numbers
Each sub list can now be sorted by the same function using recursive call to
the sorting function.
List obtained after sorting is :
0 2 2 3 4 5 8 9 11 14 20
Sorted List

7. void QuickSort(apvector<int> &list, int left, int right)
{
int pivot, leftArrow, rightArrow, n;
leftArrow = left;
rightArrow = right;
n=left - right + 1;
pivot = list[(left + right) / 2];
do
{ Total efficiency
while (list[rightArrow] > pivot)
--rightArrow;
while (list[leftArrow] < pivot)
++leftArrow;
if (leftArrow <= rightArrow)
{
Swap_Data(list[leftArrow], list[rightArrow]);
++leftArrow;
--rightArrow;
level++;
printf(“nLevel %d : ”,level);
efficiency(n);
}
} while (rightArrow >= leftArrow);
if (left < rightArrow)
QuickSort(list, left, rightArrow);
if (leftArrow < right)
QuickSort(list, leftArrow, right);
}

8. Since each element ultimately ends up in the correct position, the algorithm
correctly sorts. But how long does it take?.On this basis it is divided into
following three cases.
1. Best Case
2. Worst Case
3. Average Case
Best Case for Quick Sort
The best case for divide-and-conquer algorithms comes when we split the input as evenly as
possible. Thus in the best case, each sub problem is of size n/2. The partition step on each
sub problem is linear in its size. the total efficiency(time taken) in the best case is O(nlog2n).
Worst Case for Quicksort
Suppose instead our pivot element splits the array as unequally as possible. Thus instead of
n/2 elements in the smaller half, we get zero, meaning that the pivot element is the biggest
or smallest element in the array.
The Average Case for Quicksort
Suppose we pick the pivot element at random in an array of n keys Half the time, the pivot
element will be from the centre half of the sorted array. Whenever the pivot element is from
positions n/4 to 3n/4, the larger remaining sub-array contains at most 3n/4 elements.