经典排序算法----快速排序算法（不稳定）

快速排序（不稳定）

快速排序是由东尼·霍尔所发展的一种排序算法。 在平均状况下，排序 n 个项目要Ο(n log n)次比较。 在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为 它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj，Ai原来在位置前，排序后Ai还是要在Aj位置前。

快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j，交换a[i]和a[j],重复上面的过程，直到i > j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为5 3 3 4 3 8 9 10 11，现在中枢元素5和3（第5个元素，下标从1开始计）交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。

用途：

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小的程序方面的考试如软考，考研中也常常出现快速排序的身影。

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

该方法的基本思想是：

1. 先从数列中取出一个数作为基准数。
2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3. 再对左右区间重复第二步，直到各区间只有一个数。

虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明： 挖坑填数+分治法：

举例说明：

以一个数组作为示例，取区间第一个数为基准数。

数组arr

0	1	2	3	4	5	6	7	8	9
72	6	57	88	60	42	83	73	48	85

初始时，i=0，j=9，X=a[i]=72,其中X作为基准数

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从 j开始向前找一个比X 小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办呢？简单，再找数字来填a[8]这个坑。这次从 i开始向后找一个 大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j--;

此时数组变为：

数组arr

0	1	2	3	4	5	6	7	8	9
48	6	57		60	42	83	73	88	85

此时a[3]十个坑， i=3, j=7, X = 72;

再重复上面的步骤，先 从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;
从i开始向后找，当i=5时，由于i==j退出。
此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

此时的数组变为：

0	1	2	3	4	5	6	7	8	9
48	6	57	42	60	72	83	73	88	85

可以看出 a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

对挖坑填数进行总结：

1. i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2. j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
3. i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
4. 再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

根据总结可以比较轻松的写出源代码：

#include<stdio.h>
#include<stdlib.h>

void Show(int *s, int n)									//打印数组
{
	printf("\n数组排序：");
	for (int i = 0; i < n; i++)
		printf("%-3d", s[i]);
}

int AdjustBaseArray(int *s, int left, int right)			//返回调整后基准数的位置
{
	int i = left, j = right;
	int x = s[left];										//s[left]即s[i]为第一个坑
	while (i < j)
	{
		//从右向左找小于x的数填充s[i]
		while (i < j && s[j] >= x)
			j--;
		if (i < j)
		{
			s[i] = s[j];									//将s[j]填充到s[i]中，s[j]形成一个新的坑
			i++;
		}

		while (i < j && s[i] < x)
			i++;
		if (i < j)
		{
			s[j] = s[i];
			j--;
		}
	}

	//退出时，i等于j，将x填充到这个坑中
	s[i] = x;

	return i;
}

void QuickSort(int *s, int left, int right)
{
	if (left < right)
	{
		int i = AdjustBaseArray(s, left, right);
		Show(s, right - left + 1);
		QuickSort(s, left, i - 1);
		QuickSort(s, i + 1, right);
	}
}

void main()
{
	int arr[10] = { 72, 6, 57, 88, 60, 42, 83, 73, 48, 85 };
	Show(arr, 10);
	QuickSort(arr, 0, 9);
	Show(arr, 10);

	system("pause");
}

运行结果：

数组排序：72 6  57 88 60 42 83 73 48 85
数组排序：48 6  57 42 60 72 83 73 88 85
数组排序：42 6  48 57 60
数组排序：6  42
数组排序：6  42
数组排序：6  42 48 57
数组排序：6  42
数组排序：6  42 48 57 60 72 73 83 85 88 请按任意键继续. . .

对上述源代码的整理：

#include<stdio.h>
#include<stdlib.h>

void Show(int *s, int n)									//打印数组
{
	printf("\n数组排序：");
	for (int i = 0; i < n; i++)
		printf("%-3d", s[i]);
}

void QuickSort(int *s, int left, int right)					//返回调整后基准数的位置
{
	if (left < right)
	{
		int i = left, j = right, x = s[left];					//s[left]即s[i]为第一个坑
		while (i < j)
		{
			//从右向左找小于x的数填充s[i]
			while (i < j && s[j] >= x)
				j--;
			if (i < j)
				s[i++] = s[j];									//将s[j]填充到s[i]中，s[j]形成一个新的坑
			while (i < j && s[i] < x)
				i++;
			if (i < j)
				s[j--] = s[i];
		}

		//退出时，i等于j，将x填充到这个坑中
		s[i] = x;
		Show(s, right - left + 1);
		QuickSort(s, left, i - 1);
		QuickSort(s, i + 1, right);
	}
}


void main()
{
	int arr[10] = { 72, 6, 57, 88, 60, 42, 83, 73, 48, 85 };
	Show(arr, 10);
	QuickSort(arr, 0, 9);
	Show(arr, 10);

	system("pause");
}

运行结果：

数组排序：72 6  57 88 60 42 83 73 48 85
数组排序：48 6  57 42 60 72 83 73 88 85
数组排序：42 6  48 57 60
数组排序：6  42
数组排序：6  42
数组排序：6  42 48 57
数组排序：6  42
数组排序：6  42 48 57 60 72 73 83 85 88 请按任意键继续. . .

来源< http://blog.csdn.net/morewindows/article/details/6684558>

排序算法的另外一种实现方法

int partition(int num[], int left, int right)
{
    int x = num[right];
    int i = left;
    int j = left - 1;
    for (; i < right; i++)
    {
        if (num[i] < x)
        {
            j++;
            if (j != i)
            {
                swap(num[j], num[i]);
            }
        }
    }
    swap(num[j + 1], num[right]);

    return j + 1;  //返回分割点
}

void quick_sort(int num[], int left, int right)
{
    if (left < right)
    {
        int index = partition(num, left, right);
        quick_sort(num, left, index - 1);
        quick_sort(num, index + 1, right);
    }
}