Quick Sort 快速排序

 

Quicksort is a well-known sorting algorithm developed by C. A. R. Hoare that, on average, makes Θ(n log n) comparisons to sort n items. However, in the worst case, it makes Θ(n2) comparisons. Typically, quicksort is significantly faster in practice than other Θ(n log n) algorithms, because its inner loop can be efficiently implemented on most architectures, and in most real-world data it is possible to make design choices which minimize the possibility of requiring quadratic time. Quicksort sorts by employing a divide and conquer strategy to divide a list into two sub-lists. The steps are: 1. Pick an element, called a pivot, from the list. 2. Reorder the list so that all elements which are less than the pivot come before the pivot and so that all elements greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation. 3. Recursively sort the sub-list of lesser elements and the sub-list of greater elements. The base case of the recursion are lists of size zero or one, which are always sorted. The algorithm always terminates because it puts at least one element in its final place on each iteration (the loop invariant).  Quicksort in action on a list of random numbers. The horizontal lines are pivot values. Write a program to sort ascending int number by QuickSort ,n less than 50000.

输入

two lows, the first low is numbers , less and equal than 50000. the second low is a set integer numbers

输出

a set integer numbers of sort ascending

样例输入

10
4 2 1 5 7 6 9 8 0 3

样例输出

0 1 2 3 4 5 6 7 8 9

提 交

gcc

 

1

简单一点，就是一个快速排序

上图只是给出了第1趟快速排序的流程。在第1趟中，设置x=a[i]，即x=30。
(01) 从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=20，此时j=4；然后将a[j]赋值a[i]，此时i=0；接着从左往右遍历。
(02) 从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=40，此时i=1；然后将a[i]赋值a[j]，此时j=4；接着从右往左遍历。
(03) 从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=10，此时j=3；然后将a[j]赋值a[i]，此时i=1；接着从左往右遍历。
(04) 从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=60，此时i=2；然后将a[i]赋值a[j]，此时j=3；接着从右往左遍历。
(05) 从"右 --> 左"查找小于x的数：没有找到满足条件的数。当i>=j时，停止查找；然后将x赋值给a[i]。此趟遍历结束！

递归即可得到有序数组

#include "iostream"
#include "stdio.h"
#include "cmath"
#include "stdlib.h"
#include "algorithm"
#include "cstring"
using namespace std;
void quicksort(int a[], int left, int right)
{
	if(left < right)
	{
		int i = left;
		int j = right;
		int x = a[i];
		while(i < j)
		{
			while(i < j && a[j] > x) //从右向左找第一个小于x的数 
				j--;
			if(i < j)
				a[i++] = a[j];
			while(i < j && a[i] < x) //从左往右找第一个大于x的数
				i++;
			if(i < j)
				a[j--] = a[i];
		}
		a[i] = x;
		quicksort(a,left,i - 1);
		quicksort(a,i+1,right);
	}
}
int main()
{
	int num;
	cin >> num;
	int a[num] = {0};
	for(int i = 0; i < num; i++)
		cin >> a[i];
	quicksort(a,0,num - 1);
	for(int i = 0; i < num; i++)
		cout << a[i] << " ";
	cout << endl;
	return 0;
}