快速排序法

算法原理

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

分 治 法 的 基本 思想 是： 将 原 问题 分解 为 若干个 规模 更小 但 结构 与 原 问题 相 似的 子 问题。 递归 地 解 这些 子 问题， 然后 将 这些 子 问题 的 解组 合为 原 问 题的 解。

快速 排序 的 基本 思想： 设 当前 待 排序 的 无序 区 为 A[ low… high]， 利 用分 治 法 可 描述 为：

（1） 分解： 在 A[ low... high] 中 任选 一个 记录 作为 基准（ pivot）， 以此 基准 将 当前无序 区划 分为 左、 右 两个 较 小的 子 区间 A[ low… pivotpos- 1] 和 A[ pivotpos+ 1… high]， 并使 左边 子 区间 中 所有 记录 的 关键字 均 小于 等于 基准 记录（ pivot）， 右边 的 子 区间 中 所有 记录 的 关键字 均 大于 等于 pivot， 而 基准 记录 pivot 则 位于 正确 的 位置 上， 它 无须 参加 后续 的 排序。 注意， 划分 的 关键 是要 求出 基准 记录 所在 的 位置 pivotpos。 划分 的 结果 可以 简单 地 表示 为（ pivot= A[ pivotpos]）： A[ low… pivotpos- 1] ≤ A[ pivotpos] ≤ A[ pivotpos+ 1… high]， 其中 low ≤ pivotpos ≤ high。

（2） 求解： 通过 递归 调用 快速 排序 对 左、 右 子 区间 A[ low... pivotpos- 1] 和 A[ pivotpos+ 1... high] 快速 排序。

（3） 组合： 当“ 求解” 步骤 中的 两个 递归 调用 结束 时， 其 左、 右 两个 子 区间 已 有序。 对 快速 排序 而言，“ 组合” 步骤 无须 做 什么， 可 看作 空 操作。

草稿笔记

代码实现

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


#define SUCCESS		0
#define PARAM_ERR	-1

int QuickSort(int * array, int low, int high){
	if(NULL == array){
		printf("%s para error", __func__);
		return PARAM_ERR;
	}

	int i = 0, j = 0;	/*左右下游标*/
	int pivot = 0; 		/*分治数*/
#ifdef DEBUG
		int k = 0;
#endif

	/*递归结束条件*/
	if(low >= high){
		goto out;
	}

	/*初始化*/
	pivot = array[low]; /* i = low 的值为默认分治值，保存到pivot中，此时i的位置已经空出*/
	i = low;
	j = high;

	/*
	 * 每次循环，左右对找一次，
	 * 保证本次第一个小于pivot的放左边，大于pivot的放右边
	 * 每次结束的时候，i位置空出
	 */
	while(i < j){
		
		/* 从后面找到第一个小于pivot的值，
		 * 回填到已经空出的i的位置，
		 * i位置填充后向后移动
		 * 此时 j 的位置相当于已经空出
		 */
		while(i < j && array[j] >= pivot) j--;
		if(i < j){ /* 只有游标正常的情况下发生填写交换，游标不正常说明找到了pivotpos，在while外处理填入pivot*/
			array[i] = array[j];
			i++;
		}

		/* 从前面找到第一个大于pivot的值，
		 * 回填到已经空出的j的位置，
		 * j位置填充后前后移动
		 * 此时 i 的位置相当于已经又空出
		 */
		while(i < j && array[i] <= pivot) i++;
		if(i < j){ /* 只有游标正常的情况下发生填写交换，游标不正常说明找到了pivotpos，在while外处理填入pivot*/
			array[j] = array[i];
			j--;
		}
	}

	/*最后的i位置，就是pivotpos*/
	array[i] = pivot;

#ifdef DEBUG
	printf("low = %d, high = %d, pivot = %d\n",low, high, pivot);
	printf("[");
	/*左边的小于区域*/
	for(k =low; k < i; k++){
		printf("  %d  ", array[k]);
	}
	printf("], ");

	/*pivot的值*/
	printf("  %d,  ",array[i]);
		
	/*右边的大于区域*/
	printf("[");
	for(k =i+1; k < high + 1; k++){
		printf("  %d  ", array[k]);
	}
	printf("]\n");
	printf("\n");

#endif

	/*左边分区递归*/
	QuickSort(array, low, i - 1);
	
	/*右边分区递归*/
	QuickSort(array, i + 1, high);

out:
	return SUCCESS;
	
}


int main(int argc, char ** argv){
	int array[10] = {54,38,96,23,0,15,72,60,45,83};
	int i = 0;

	printf("Before sort: \n");
	for(i = 0; i < 10; i++){
		printf("  %d  ", array[i]);
	}
	printf("\n");
	

	QuickSort(array, 0, 9);

	printf("after sort: \n");
	for(i = 0; i < 10; i++){
		printf("  %d  ", array[i]);
	}
	printf("\n");
	
	return 0;
}

这里 pivot 代表 基准 值， 它的 初始 值 为 a[ low]。 局部 变量 i 和 j 分别 代表 low 和 high 的 位置。 接着 按照 下面 的 步骤 进行 一 趟 交换。

（1） 把 比 pivot 小的 元素 移到 低 端（ low）。

（2） 把 比 pivot 大的 元素 移到 高端（ high）。

（3） pivot 移到 最终 位置， 此时 这个 位置 的 左边 元素 的 值 都比 pivot 小， 而 其 右边 元素 的 值 都比 pivot 大。

（4） 对 左、 右 区间 分别 进行 递归 排序。 从而 把 前 三步 的 粗 排序 逐渐 地 细化， 直至 最终 low 和 high 交汇。

在代码实现中，还要注意左右查找时候填充，要看一下左右游标状态是否正常(i < j)， 才能开始进行填充，游标不正常说明找到了pivotpos，在while外处理填入pivot。

 

调试编译

gcc QuickSort.c -DDEBUG

调试输出

Before sort:
  54    38    96    23    0    15    72    60    45    83
low = 0, high = 9, pivot = 54
[  45    38    15    23    0  ],   54,  [  72    60    96    83  ]

low = 0, high = 4, pivot = 45
[  0    38    15    23  ],   45,  []

low = 0, high = 3, pivot = 0
[],   0,  [  38    15    23  ]

low = 1, high = 3, pivot = 38
[  23    15  ],   38,  []

low = 1, high = 2, pivot = 23
[  15  ],   23,  []

low = 6, high = 9, pivot = 72
[  60  ],   72,  [  96    83  ]

low = 8, high = 9, pivot = 96
[  83  ],   96,  []

after sort:
  0    15    23    38    45    54    60    72    83    96

相关的参考资料

https://blog.csdn.net/elma_tww/article/details/86164674

https://www.cnblogs.com/sunriseblogs/p/10009890.html