Quick sorting
Download as PPT, PDF0 likes365 views
Quick sort, developed by Tony Hoare in 1960, is a divide and conquer algorithm that sorts elements by dividing them into left and right partitions based on a pivot value. The history explains Hoare's motivation for creating the algorithm while working on machine translation at Moscow State University, leading to its publication in the early 1960s. The document also includes code implementation in CodeBlocks and concludes with quick sort's efficiency, noting its average running time of O(n log n).
![Implementation of code in codeblocksImplementation of code in codeblocks
#include < stdio. h>
void quicksort(int [10],int,int);
int main(){
int x[20], size , i;
printf("Enter size of the array: ");
scanf("%d",&size);
printf("Enter %d elements: ",size);
for(i=0;i<size ; i++)
scanf("% d",& x [i]);
quicksort(x,0,size-1);](https://image.slidesharecdn.com/quicksorting-170708003245/85/Quick-sorting-5-320.jpg)
![ return 0;
}
printf("Sorted elements: ");
for(i=0;i<size ; i++)
printf(" %d ", x[ i]);
void quicksort(int x[10],int first,int last){
int pivot,j,temp,i;
if(first<last){
pivot=first;
i=first;
j=last;
while(i<j){
while(x[i]<=x[pivot]&&i<last)](https://image.slidesharecdn.com/quicksorting-170708003245/85/Quick-sorting-6-320.jpg)
![Algorithm For Quick SortAlgorithm For Quick Sort
Quick( A, N, Beg, End , Loc)
Here A is an array of N elements .Parameters Beg and End contain
the boundary values of the sublist to which this procedure applies.
Loc keeps track of the position of the first element A[Beg] of the
sublist during the procedure. The local variable Left and Right will
contain the boundary values of the list of elements that have not
been scanned.
1. [Initialize].Set Left:= Beg, Right:=End and Loc:=Beg.
2. [Scan from right to left]
a) Repeat while A[Loc]<=A[Right] and Loc!=Right. Right:=Right-1
[End of Loop]
b) If Loc=Right, then: return.
c) If A[Loc]>A[Right],then:
i. Interchange A[loc] and A[Right].
ii. Set Loc:=Right.
iii. Go to Step 3.](https://image.slidesharecdn.com/quicksorting-170708003245/85/Quick-sorting-7-320.jpg)
![3. [Scan from left to right]
a) Repeat while A[Left]<=A[Loc] and Left!=Loc: Left :=Left+1.
b) If Loc=Left , then return.
c) if A[Left]>A[Loc],then
i. Interchange A[Left] and A[Loc].
ii. Set Loc:=Left
iii. Go to Step 2.
[End of if structure].](https://image.slidesharecdn.com/quicksorting-170708003245/85/Quick-sorting-8-320.jpg)
![ i++;
while(x[j]>x[pivot])
j--;
if(i<j){
temp=x[i];
x[i]=x[j];
x[j]=temp;}
}
temp=x[pivot];
x[pivot]=x[j];
x[j]=temp;
quicksort(x,first,j-1);
quicksort(x,j+1,last);
}
}](https://image.slidesharecdn.com/quicksorting-170708003245/85/Quick-sorting-9-320.jpg)
Quick sorting
- 2. IntroductionIntroduction Quick sort is an example of divide and conquer algorithm. It was developed in1960 by Tony Hoare. It is a recursive algorithm.The intutive idea is as follows: Divide:- Choose any element of the list, say the last element as a pivot value. Remove the pivot from the list. Divide the remaining elements into two parts,left and right,such that all the elements equal to or less than the pivot are in the left list, while the elements greater than the pivot are in right list. Conquer:-Sort the two halves recursively using quick sort. Combine:-Return sorted_left + pivot + sorted_right,as your final sorted_list.
- 3. History of Quick Sort AlgorithmHistory of Quick Sort Algorithm While studying at Moscow State University, Tony Hoare received an offer of employment from National Physical Laboratory (NPL) to work on new project for machine translation form Russian to English. However ,because dictionaries were sorted into alphabetical order before translation. Hoare thought of two methods to solve this problem.The first method would have taken an amount of time proportional to the square of the length of a sentence. The second method would later manifest as quicksort. During this course, Hoare programmed an ultra-fast sorting algorithm now known as quicksort. His paper on Quicksort was also published in 1961,with another following in 1962.
- 4. Example of Quick SortExample of Quick Sort
- 5. Implementation of code in codeblocksImplementation of code in codeblocks #include < stdio. h> void quicksort(int [10],int,int); int main(){ int x[20], size , i; printf("Enter size of the array: "); scanf("%d",&size); printf("Enter %d elements: ",size); for(i=0;i<size ; i++) scanf("% d",& x [i]); quicksort(x,0,size-1);
- 6. return 0; } printf("Sorted elements: "); for(i=0;i<size ; i++) printf(" %d ", x[ i]); void quicksort(int x[10],int first,int last){ int pivot,j,temp,i; if(first<last){ pivot=first; i=first; j=last; while(i<j){ while(x[i]<=x[pivot]&&i<last)
- 7. Algorithm For Quick SortAlgorithm For Quick Sort Quick( A, N, Beg, End , Loc) Here A is an array of N elements .Parameters Beg and End contain the boundary values of the sublist to which this procedure applies. Loc keeps track of the position of the first element A[Beg] of the sublist during the procedure. The local variable Left and Right will contain the boundary values of the list of elements that have not been scanned. 1. [Initialize].Set Left:= Beg, Right:=End and Loc:=Beg. 2. [Scan from right to left] a) Repeat while A[Loc]<=A[Right] and Loc!=Right. Right:=Right-1 [End of Loop] b) If Loc=Right, then: return. c) If A[Loc]>A[Right],then: i. Interchange A[loc] and A[Right]. ii. Set Loc:=Right. iii. Go to Step 3.
- 8. 3. [Scan from left to right] a) Repeat while A[Left]<=A[Loc] and Left!=Loc: Left :=Left+1. b) If Loc=Left , then return. c) if A[Left]>A[Loc],then i. Interchange A[Left] and A[Loc]. ii. Set Loc:=Left iii. Go to Step 2. [End of if structure].
- 9. i++; while(x[j]>x[pivot]) j--; if(i<j){ temp=x[i]; x[i]=x[j]; x[j]=temp;} } temp=x[pivot]; x[pivot]=x[j]; x[j]=temp; quicksort(x,first,j-1); quicksort(x,j+1,last); } }
- 10. ConclusionConclusion We discussed the history of the algorithm. Then implemented the code in codeblocks. Quick sort is an efficient algorithm and has an average running time of O(n*log(n)).While the worst-case running time for quick sort is higher than that of the merge sort, in practice quick sort works slightly faster the the merge sort.