快速排序

快排，快排，不快怎么行呢！

但我们在实际应用中，处理大量数据时，如果采用普通排序（如冒泡排序）就会使得时间复杂度变为O(N^2),这是我们我们不愿意看到的。

而快速排序就很好的解决了这个问题。它的时间复杂度大概是O(logN),最坏的情况下为O(N^2)。当然我们一般情况下遇到最坏情况是很少见的。

快排，用到的一个重要的思想就是分治。分治分治，就是分而治之。简单来说，就是找到一个规律，将问题由大变小，最后得以解决。快排，一个重要的特点就是数据。数据就有大小之分。我们可以在一堆数据中随意找一个数，这个数称为枢纽元，其他数据与这个枢纽元进行比较，然后分成两组新的数据，一组数据全都比枢纽元小，另一组则比枢纽元大。在将这两组按照上面分治的方法进行处理。如此循环，直至所有数据都处理完成。

例如，有一个无序的数组a｛4，1，3，9，7，5｝，利用快排进行处理

为了便于操作，一般我们取数组第一位为枢纽元(pivot)，我们还需要两个下标指针i,j。它们分别指向数组的第一位以及最后一位。限制条件（i<j）

0	1	2	3	4	5
4	1	3	9	7	5
i					j

pivot=4,i=0,j=5

让后我们从右边开始，找到比pivot小的元素

0	1	2	3	4	5
4	1	3	9	7	5
i		j

pivot=4,i=0,j=2

然后进行数据赋值，将a[i]=a[j]

0	1	2	3	4	5
3	1	3	9	7	5
i		j

接着我们移动左边的i下标，记住条件是（i<j时，继续移动）以及a[i]>pivot

0	1	2	3	4	5
3	1	3	9	7	5
		i,j

上述的操作不断的往返进行， 直达i=j时停止下标移动，此时另a[i]=pivot;

0	1	2	3	4	5
3	1	4	9	7	5
		i,j

此时我们分为两个数组a1{3,1},a2{9,7,5}

对这两个数组进行以上操作，直到数组成为有序为止

void quick_sort(int *arr, int low, int high) {
	if (low < high) {
		int i = low, j = high, pivot = arr[low];
		while (i < j) {
			while (i < j&&arr[j] >= pivot)  //从右开始遍历，直到找到小于pivot的值为止
				--j;
			if (i < j)
				arr[i++] = arr[j];
			while (i < j&&arr[i] <= pivot)  //从左开始遍历直到找到大于pivot的值为止
				++i;
			if (i < j)
				arr[j--] = arr[i];
		}
		arr[i] = pivot;
		quick_sort(arr, low, i - 1);
		quick_sort(arr, i + 1, high);
	}
}

void main() {
	int arr[10] = { 99,76,199,34,321,56,1,45,26,38 };
	quick_sort(arr, 0, 9);
	for (int i = 0; i < 10; cout << arr[i++] << " " );
	cout << endl;
	system("pause");
}

快速排序算法效率与稳定性分析

　　当基数值不能很好地分割数组，即基准值将数组分成一个子数组中有一个记录，而另一个子组组有 n -1 个记录时，下一次的子数组只比原来数组小 1，这是快速排序的最差的情况。如果这种情况发生在每次划分过程中，那么快速排序就退化成了冒泡排序，其时间复杂度为O(n²)。

　　如果基准值都能讲数组分成相等的两部分，则出现快速排序的最佳情况。在这种情况下，我们还要对每个大小约为 n/2 的两个子数组进行排序。在一个大小为 n 的记录中确定一个记录的位置所需要的时间为O(n)。若T(n)为对n个记录进行排序所需要的时间，则每当一个记录得到其正确位置，整组大致分成两个相等的两部分时，我们得到快速排序算法的最佳时间复杂性。

　　T(n) <= cn + 2T(n/2)    c是一个常数

　　　　　<= cn + 2(cn/2+2T(n/4)) = 2cn+ 4T(n/4)

　　　　　<= 2cn + 4(cn/4+ 2T(n/8)) = 3cn + 8T(n/8)

　　　　　　…… ……

　　　　　<= cnlogn + nT(1) = O(nlogn)      其中cn 是一次划分所用的时间，c是一个常数

　　最坏的情况，每次划分都得到一个子序列，时间复杂度为：

　　T(n) = cn + T(n-1)

　　　　 = cn + c(n-1) + T(n - 2) = 2cn -c + T(n-2)

            = 2cn -c + c(n - 2) + T(n-3) = 3cn -3c + T(n-3)

　　　　……

　　　　= c[n(n+1)/2-1] + T(1) =  O(n²)

　　快速排序的时间复杂度在平均情况下介于最佳与最差情况之间，假设每一次分割时，基准值处于最终排序好的位置的概率是一样的，基准值将数组分成长度为0 和 n-1，1 和 n-2，……的概率都是 1/n。在这种假设下，快速排序的平均时间复杂性为：

　　　　T(n) = cn + 1/n(T(k)+ T(n-k-1))   T(0) = c, T(1) = c

　　这是一个递推公式，T(k)和T(n-k-1)是指处理长度为 k 和 n-k-1 数组是快速排序算法所花费的时间， 根据公式所推算出来的时间为 O(nlogn)。因此快速排序的平均时间复杂性为O(nlogn)。

　　快速排序需要栈空间来实现递归，如果数组按局等方式被分割时，则最大的递归深度为 log n，需要的栈空间为 O(log n)。最坏的情况下在递归的每一级上，数组分割成长度为0的左子数组和长度为 n - 1 的右数组。这种情况下，递归的深度就成为 n，需要的栈空间为 O(n)。

　　因为快速排序在进行交换时，只是根据比较基数值判断是否交换，且不是相邻元素来交换，在交换过程中可能改变相同元素的顺序，因此是一种不稳定的排序算法。