Upcoming SlideShare
×

# Quick sort

2,208 views
1,954 views

Published on

Subject: Data Structure in C.

1 Comment
3 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No

Are you sure you want to  Yes  No
Views
Total views
2,208
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
144
1
Likes
3
Embeds 0
No embeds

No notes for slide

### Quick sort

1. 1. Abhishek PachisiaB.Tech(IT)-II yr09SETIT144
2. 2. It is one of the fastest sorting techniques available.Like binary search, this method uses a recursive, divideand conquer strategyThe basic idea is to separate a list of items into twoparts, surrounding a distinguished item called the pivot.At the end of the process, one part will contain itemssmaller than the pivot and the other part will contain itemslarger than the pivot.The performance of the whole Quicksort algorithmdepends on how well the pivot is taken.
3. 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. 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. 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_arrowWe 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. 6. Since right_arrow < left_arrow is TRUE, the first subdivision is complete. Atthis stage, numbers smaller than pivot are on the left side and numbers largerthan 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 tothe sorting function.List obtained after sorting is : 0 2 2 3 4 5 8 9 11 14 20 Sorted List
7. 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. 8. Since each element ultimately ends up in the correct position, the algorithmcorrectly sorts. But how long does it take?.On this basis it is divided intofollowing three cases.1. Best Case2. Worst Case3. Average CaseBest Case for Quick SortThe best case for divide-and-conquer algorithms comes when we split the input as evenly aspossible. Thus in the best case, each sub problem is of size n/2. The partition step on eachsub problem is linear in its size. the total efficiency(time taken) in the best case is O(nlog2n).Worst Case for QuicksortSuppose instead our pivot element splits the array as unequally as possible. Thus instead ofn/2 elements in the smaller half, we get zero, meaning that the pivot element is the biggestor smallest element in the array. The Average Case for QuicksortSuppose we pick the pivot element at random in an array of n keys Half the time, the pivotelement will be from the centre half of the sorted array. Whenever the pivot element is frompositions n/4 to 3n/4, the larger remaining sub-array contains at most 3n/4 elements.