算法介绍（2） 快速排序算法

                  本篇介绍快速排序算法，以及相应的时间空间复杂度求解。        
         首先介绍一下冒泡排序的时间复杂度： 对于n位的数列则有比较次数为 (n-1) + (n-2) + ... + 1 = n * (n - 1) / 2，这就得到了最大的比较次数而O(N^2)表示的是复杂度的数量级。举个例子来说，如果n = 10000，那么 n(n-1)/2 = (n^2 - n) / 2 = (100000000 - 10000) / 2，相对10^8来说，10000小的可以忽略不计了，所以总计算次数约为0.5 * N^2。用O(N^2)就表示了其数量级（忽略前面系数0.5）。在没有改进的情况下，冒泡排序的时间复杂度都是相同的，为O(N^2)。以下改进的方法可以使最佳情况时为O(n)。
         

public void bubbleSort(int arr[]) {
    boolean didSwap;
    for(int i = 0, len = arr.length; i < len - 1; i++) {
        didSwap = false;
        for(int j = 0; j < len - i - 1; j++) {
            if(arr[j + 1] < arr[j]) {
                swap(arr, j, j + 1);
                didSwap = true;
            }
        }
        if(didSwap == false)
            return;
    }    
}

          快速排序的基本思想如下：首先在要排序的序列 a 中选取一个中轴值，而后将序列分成两个部分，其中左边的部分 b 中的元素均小于或者等于 中轴值，右边的部分 c 的元素 均大于或者等于中轴值，而后通过递归调用快速排序的过程分别对两个部分进行排序，最后将两部分产生的结果合并即可得到最后的排序序列。   为了实现一次划分，我们可以从数组（假定数据是存在数组中）的两端移动下标，必要时交换记录，直到数组两端的下标相遇为止。为此，我们附设两个指针（下角标）i 和 j， 通过 j 从当前序列的有段向左扫描，越过不小于基准值的记录。当遇到小于基准值的记录时，扫描停止。通过 i 从当前序列的左端向右扫描，越过小于基准值的记录。当遇到不小于基准值的记录时，扫描停止。交换两个方向扫描停止的记录 a[j] 与 a[i]。 然后，继续扫描，直至 i 与 j 相遇为止。扫描和交换的过程结束。这是 i 左边的记录的关键字值都小于基准值，右边的记录的关键字值都不小于基准值。   
          快速排序的时间复杂度为：
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(n2)

　　快速排序的时间复杂度在平均情况下介于最佳与最差情况之间，假设每一次分割时，基准值处于最终排序好的位置的概率是一样的，基准值将数组分成长度为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)。
        以下贴出快速排序的代码：
 

       
#include <iostream>
using namespace std;

int a[101], n;

void quickSort(int left, int right)
{
	int i, j, t, temp;
	if (left > right)
		return;




	temp = a[left];
	i = left;
	j = right;
	while (i != j)
	{
		while (a[j] >= temp && i < j)
			j--;
		while (a[i] <= temp && i < j)
			i++;
		if (i < j)
		{
			t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
	}
	a[left] = a[i];
	a[i] = temp;

	quickSort(left, i - 1);
	quickSort(i + 1, right);
}

int main()
{
	int i;
	cin >> n;
	for (i = 0; i < n; i++)
	{
		cin >> a[i];
	}

	quickSort(0, n - 1);

	for (i = 0; i < n; i++)
	{
		cout << a[i] << " ";
	}

	system("pause");
	return 0;
}