超快速排序算法
制作游戏辅助必备算法：按键精灵快速排序(比冒泡更快更有效率的算法)
学习制作游戏辅助必备算法——按键精灵快速排序〔比冒泡更快更有效率的算法〕来源：按键学院【按键精灵】冒泡排序为O(N^2)，在排序过程中其实是效率较低的。
在扫拍卖或者其他需要比拼速度的时候，时间就是金钱~越快越能抢占先机。
今天我们介绍另一种更快更有效率的排序——快速排序，时间复杂度为O(n*logn)。
快速排序的算法思想快速排序采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
该方法的基本思想是：1．先从数列中取出一个数作为基准数。
〔不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了〕。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3 . 再对左右区间重复第二步，直到各区间只有一个数。
白话讲解算法：假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个10个数进行排序。
就让第一个数6作为基准数吧。
接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边。
方法其实很简单：分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。
先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换他们。
这里可以用两个变量i和j，分别指向序列最左边和最右边。
我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。
刚开始的时候让哨兵i指向序列的最左边〔即i=1〕，指向数字6。
让哨兵j指向序列的最右边〔即=10〕，指向数字。
首先哨兵j开始出动。
因为此处设置的基准数是最左边的数，所以需要让哨兵j 先出动，这一点非常重要〔请自己想一想为什么〕。
哨兵j一步一步地向左挪动〔即j--〕，直到找到一个小于6的数停下来。
接下来哨兵i再一步一步向右挪动〔即i++〕，直到找到一个数大于6的数停下来。
最后哨兵j停在了数字5面前，哨兵i停在了数字7面前。
现在交换哨兵i和哨兵j所指向的元素的值。
C语言--常见排序算法
49
2 j 49
08
0
25* 3 49 25
16 4
21
5
08
25
25*
16
21
i k 49
j 25* 25
08
25
25*
16
21
算法实例：
1.1.5 选择排序
49 2
08 0
25 1 i
25* 3
16 4 k
21 5 j 21 16
k 指示当前序列中最小者
算法实现：
08 5 temp
16 21 25 25* 49 08 0 1 2 3 4 5
算法实现：
1.1.3 直接插入排序
void InsertSort (int r[ ], int n ) { // 假设关键字为整型，放在向量r[]中 int i, j, temp; for (i = 1;i< n;i++ ) { temp = r[i]; for(j = i;j>0;j- -) {//从后向前顺序比较，并依次后移 if ( temp < r[j-1] ) r[j] = r[j-1]; else break; } r[j] = temp; } }
输入n 个数给a[1] 到 a[n]
for j=1 to n-1
for i=1 to n-j
真 a[i]>a[i+1]
a[i]a[i+1]
输出a[1] 到 a[n]
main() { int a[11],i,j,t; printf("Input 10 numbers:\n"); for(i=1;i<11;i++) scanf("%d",&a[i]); printf("\n"); 假 for(j=1;j<=9;j++) for(i=1;i<=10-j;i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1]; a[i+1]=t;} printf("The sorted numbers:\n"); for(i=1;i<11;i++) printf("%d ",a[i]); }
一种针对任意整数序列的超“快速排序”算法研究
一
种针 对 任 意整 数 序 列 的超 “ 速 排序 ’ 法研 究 快 ’ 算
王秋 芬 ， 保 胜 王
（ 阳理 ＿ 学 院计算 机科学 与技 术 系 河 南 南 阳 南 Ｔ ４ ３０ ） ７０４
摘 要 ： 出 了一 种 基 于 哈 希 函 数 的 超 “ 速 排 序 ” 法 。 根 据 数 组 下 标 递 增 的 特 点 ， 待 排 序 的 任 意 整 数 序 列 建 提 快 算 对 立 有 效 的哈 希 函 数 ， 过 循 环 映 射 链 接 完 成 排 序 。分 析 了 算 法 的 时 间 和 空 间 复 杂 度 ， 验 验证 了算 法 的运 行 效 率 。 通 实 结 果 表 明 ： 法 的时 间和 空 间复 杂 度 均 为 Ｏ（ ）， 问 题 规 模 较 大 时 ， 率 优 势 明显 。 算 ｎ 在 效 关键 词 ： 希 函数 ； 数 排序 ； 法 ； 杂 性 哈 整 算 复
第 ２卷 第 ２期
２０ １ ０年 ３月
南 阳 理 工 学 院 学
报
Ｖｏ ． ． １ ２ Ｎｏ ２
Ｍａ． ２ Ｏ ｒ ０１
Ｊ ＯＵＲＮＡＬ ＯＦ ＮＡＮＹＡＮＧ Ｉ ＴＩ ＮＳ ＴＵＴＥ ＯＦ ＴＥＣＨＮＯＬＯＧＹ
文章 编 号 ：６ ４— １ ２ ２ １ ） ２— ０ １ ０ １７ ５ ３ （０ ０ ０ ０ ３ — ５
位 置
步骤 ７：［ ｆｎ一１ ］＝ｎ—ｆｎ一１ ， ｉ ２ ［ ቤተ መጻሕፍቲ ባይዱ令 ＝ ； 步骤 ８ ｆｎ— ］ ［ ：［ ｉ ＝ｚｎ—ｉ ］ ［ ； ＋１ 一ｚｎ— ］
作者简介 ： 王秋 芬 （９ ８一） 女 ， 士 ， 师 ， １７ ， 硕 讲 主要 研 究 方 向 ： 算 机 软 件 和 算 法 理 论 。Ｅ－ ｉ： — ｉ ｅ＠ １３ ｃｒ 计 ｍａ Ｗ ｑｕ ｎ ６ ．ｏ ｌ ｆ ｎ
各种排序方法总结
选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
冒泡法：这是最原始，也是众所周知的最慢的算法了。
他的名字的由来因为它的工作看来象是冒泡：复杂度为O(n*n)。
当数据为正序，将不会有交换。
复杂度为O(0)。
直接插入排序：O(n*n)选择排序：O(n*n)快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。
归并排序：l og2(n)*n堆排序：l og2(n)*n希尔排序：算法的复杂度为n的1.2次幂这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况1.数组的大小是2的幂，这样分下去始终可以被2整除。
假设为2的k次方，即k=log2(n)。
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。
第一层递归，循环n次，第二层循环2*(n/2)......所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n所以算法复杂度为O(lo g2(n)*n) 其他的情况只会比这种情况差，最差的情况是每次选择到的midd le都是最小值或最大值，那么他将变成交换法（由于使用了递归，情况更糟）。
但是你认为这种情况发生的几率有多大？？呵呵，你完全不必担心这个问题。
实践证明，大多数的情况，快速排序总是最好的。
如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢于快速排序（因为要重组堆）。
超快排对关键词的要求
超快排对关键词的要求超快排（Ultra Fast Sorting）是一种较新发展起来的排序算法，它使用一种新颖的技术通过大量地并发请求和排序内容来更快地比较数据，以达到极快的排序速度。
一、超快排的技术原理超快排的技术原理是利用了MapReduce技术，即分布式数据管理概念，来实现超快排。
MapReduce技术能够将所有用户的操作和排序要求，转变成能够分发到网络上的多个定义的节点，从而实现并行处理。
在超快排中，数据被分发到多个节点，每个节点都分别执行排序，然后将排序完毕并将结果返回给用户，用户就可以完成排序任务。
由于这种技术的实施，每个任务都不需要整体等待，从而极为简单地增加了操作次数，从而加快了排序速度。
二、超快排的优势1）高效率：超快排利用MapReduce技术，大大降低处理时间和排序时间，排序速度更快。
2）拓展性：超快排具有容易拓展的特点，可以根据用户的需求添加其他排序算法，实现更复杂的排序要求。
3）易于实现：超快排不需要除了传统排序算法之外的复杂编程语言和技术，容易上手，降低开发成本。
三、超快排的应用超快排的应用非常广泛，它可以应用到处理数据规模较大的交易中，比如处理比特币、股票市场等大量交易，超快排可以在较短的时间内处理大量的数据，极大程度的提高了效率。
此外，超快排也可以应用在数据分析、机器学习、物流货运管理、智能客服等方面，提高工作效率，提高服务质量。
四、超快排的缺点1）技术复杂性：由于超快排需要用到MapReduce技术，所以开发者必须具备较高的技术能力，才能高效完成超快排程序开发，增加开发成本。
2）系统兼容性：由于超快排需要利用分布式系统，各个节点的硬件和软件环境必须保持一致，才能保证排序结果的正确性，增加系统成本。
总之，超快排是一种新兴的排序技术，它极大提高了排序效率，被广泛应用在各种领域，但是这种技术的实施成本也比较高，在技术复杂性和系统兼容性上应用需要更多的研究和完善。
CC++实现快速排序算法的思路及原理解析
CC++实现快速排序算法的思路及原理解析⽬录快速排序2. 实现原理3. 动态演⽰4. 完整代码5. 结果展⽰6. 算法分析快速排序1. 算法思想快速排序的基本思想：通过⼀趟排序将待排记录分隔成独⽴的两部分，其中⼀部分记录的关键字均⽐另⼀部分的关键字⼩，则可分别对这两部分记录继续进⾏排序，以达到整个序列有序。
2. 实现原理2.1、设置两个变量 low、high，排序开始时：low=0，high=size-1。
2.2、整个数组找基准正确位置，所有元素⽐基准值⼩的摆放在基准前⾯，所有元素⽐基准值⼤的摆在基准的后⾯默认数组的第⼀个数为基准数据，赋值给key，即key=array[low]。
因为默认数组的第⼀个数为基准，所以从后⾯开始向前搜索（high–），找到第⼀个⼩于key的array[high]，就将 array[high] 赋给 array[low]，即 array[low] = array[high]。
（循环条件是 array[high] >= key；结束时 array[high] < key）此时从前⾯开始向后搜索（low++），找到第⼀个⼤于key的array[low]，就将 array[low] 赋给 array[high]，即 array[high] = array[low]。
（循环条件是 array[low] <= key；结束时 array[low] > key）循环 2-3 步骤，直到 low=high，该位置就是基准位置。
把基准数据赋给当前位置。
2.3、第⼀趟找到的基准位置，作为下⼀趟的分界点。
2.4、递归调⽤（recursive）分界点前和分界点后的⼦数组排序，重复2.2、2.3、2.4的步骤。
2.5、最终就会得到排序好的数组。
3. 动态演⽰4. 完整代码三个函数基准插⼊函数：int getStandard(int array[],int low,int high)（返回基准位置下标）递归排序函数：void quickSort(int array[],int low,int high)主函数：int main()#include <stdio.h>#include <stdlib.h>void display(int* array, int size) {for (int i = 0; i < size; i++) {printf("%d ", array[i]);}printf("\n");}int getStandard(int array[], int i, int j) {// 基准数据int key = array[i];while (i < j) {// 因为默认基准是从左边开始，所以从右边开始⽐较// 当队尾的元素⼤于等于基准数据时,就⼀直向前挪动 j 指针while (i < j && array[j] >= key) {j--;}// 当找到⽐ array[i] ⼩的时，就把后⾯的值 array[j] 赋给它if (i < j) {array[i] = array[j];}// 当队⾸元素⼩于等于基准数据时,就⼀直向后挪动 i 指针while (i < j && array[i] <= key) {i++;}// 当找到⽐ array[j] ⼤的时，就把前⾯的值 array[i] 赋给它if (i < j) {array[j] = array[i];}}// 跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置// 把基准数据赋给正确位置array[i] = key;return i;}void QuickSort(int array[], int low, int high) {// 开始默认基准为 lowif (low < high) {// 分段位置下标int standard = getStandard(array, low, high);// 递归调⽤排序// 左边排序QuickSort(array, low, standard - 1);// 右边排序QuickSort(array, standard + 1, high);}}// 合并到⼀起快速排序// void QuickSort(int array[], int low, int high) {// if (low < high) {// int i = low;// int j = high;// int key = array[i];// while (i < j) {// while (i < j && array[j] >= key) {// j--;// }// if (i < j) {// array[i] = array[j];// }// while (i < j && array[i] <= key) {// i++;// }// if (i < j) {// array[j] = array[i];// }// }// array[i] = key;// QuickSort(array, low, i - 1);// QuickSort(array, i + 1, high);// }// }int main() {int array[] = {49, 38, 65, 97, 76, 13, 27, 49, 10};int size = sizeof(array) / sizeof(int);// 打印数据printf("%d \n", size);QuickSort(array, 0, size - 1);display(array, size);// int size = 20;// int array[20] = {0}; // 数组初始化// for (int i = 0; i < 10; i++) { // 数组个数// for (int j = 0; j < size; j++) { // 数组⼤⼩// array[j] = rand() % 1000; // 随机⽣成数⼤⼩ 0~999// }// printf("原来的数组：");// display(array, size);// QuickSort(array, 0, size - 1);// printf("排序后数组：");// display(array, size);// printf("\n");// }return 0;}5. 结果展⽰（递归调⽤，不好展⽰每次排序结果）6. 算法分析时间复杂度：最好： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)最坏： O ( n 2 ) O(n^2) O(n2)平均： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)空间复杂度： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)稳定性：不稳定到此这篇关于C/C++实现快速排序算法的思路及原理解析的⽂章就介绍到这了,更多相关C++实现快速排序算法内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
【转】三种快速排序算法以及快速排序的优化
【转】三种快速排序算法以及快速排序的优化⼀. 快速排序的基本思想快速排序使⽤分治的思想，通过⼀趟排序将待排序列分割成两部分，其中⼀部分记录的关键字均⽐另⼀部分记录的关键字⼩。
之后分别对这两部分记录继续进⾏排序，以达到整个序列有序的⽬的。
⼆. 快速排序的三个步骤1) 选择基准：在待排序列中，按照某种⽅式挑出⼀个元素，作为 “基准”（pivot）；2) 分割操作：以该基准在序列中的实际位置，把序列分成两个⼦序列。
此时，在基准左边的元素都⽐该基准⼩，在基准右边的元素都⽐基准⼤；3) 递归地对两个序列进⾏快速排序，直到序列为空或者只有⼀个元素；三. 选择基准元的⽅式对于分治算法，当每次划分时，算法若都能分成两个等长的⼦序列时，那么分治算法效率会达到最⼤。
也就是说，基准的选择是很重要的。
选择基准的⽅式决定了两个分割后两个⼦序列的长度，进⽽对整个算法的效率产⽣决定性影响。
最理想的⽅法是，选择的基准恰好能把待排序序列分成两个等长的⼦序列。
⽅法⼀：固定基准元（基本的快速排序）思想：取序列的第⼀个或最后⼀个元素作为基准元。
/// <summary>/// 1.0 固定基准元（基本的快速排序）/// </summary>public static void QsortCommon(int[] arr, int low, int high){if (low >= high) return; //递归出⼝int partition = Partition(arr, low, high); //将 >= x 的元素交换到右边区域，将 <= x 的元素交换到左边区域QsortCommon(arr, low, partition - 1);QsortCommon(arr, partition + 1, high);}/// <summary>/// 固定基准元，默认数组第⼀个数为基准元，左右分组，返回基准元的下标/// </summary>public static int Partition(int[] arr, int low, int high){int first = low;int last = high;int key = arr[low]; //取第⼀个元素作为基准元while (first < last){while (first < last && arr[last] >= key)last--;arr[first] = arr[last];while (first < last && arr[first] <= key)first++;arr[last] = arr[first];}arr[first] = key; //基准元居中return first;}注意：基本的快速排序选取第⼀个或最后⼀个元素作为基准。
【十大经典排序算法(动图演示)】 必学十大经典排序算法
【十大经典排序算法（动图演示）】必学十大经典排序算法0.1 算法分类十种常见排序算法可以分为两大类：比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
0.2 算法复杂度0.3 相关概念稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后a 可能会出现在b 的后面。
时间复杂度：对排序数据的总的操作次数。
反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述比较相邻的元素。
如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。
1.2 动图演示1.3 代码实现1.unction bubbleSort(arr) {2. varlen = arr.length;3. for(vari = 0; i arr[j+1]) {// 相邻元素两两对比6. vartemp = arr[j+1];// 元素交换7. arr[j+1] = arr[j];8. arr[j] = temp;9. }10. }11. }12. returnarr;13.}2、选择排序（Selection Sort）选择排序(Selection-sort)是一种简单直观的排序算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
参考文献 [1] 卢开澄, 组合数学算法与分析(下册)[M].北京：清华大学出版社，1983 [2] 严蔚敏,吴伟民, 数据结构[M].北京：清华大学出版社，1997 [3] 周建钦,赵志远,排序和查找理论及算法[M].北京：科学出版社，1993 [4] 唐向阳,分段快速排序法[J].软件学报,1993,4(2):53-57
２
PDF created with pdfFactory Pro trial version
周建钦
超快速排序算法
[5] 王向阳,任意分布数据的基数分配链接排序算法[J].计算机学报,2000,23(7):774-778 [6] D.Cantone,G.Cincotti, QuickHeapsort: an efficient mix of classical sorting algorithms, Theoretical Computer Science
一般的基数排序算法结构较复杂，分配和收集数据时需要占用大量额外内存。超快速排序算法最多需要存放 m-1 次 递归调用的变量，不需要其他额外内存。
2．实验结果和结论
表 1 是对快速排序，归并排序，基数排序（8 进制）和超快速排序用 C 语言在 Celeron2.0G 上做的一个比较,表中同 一列分别为用快速排序，归并排序，基数排序（8 进制）和超快速排序处理同样数量的随机数据(由 RAND 函数产生)所 用时间,单位为毫秒 ms.
Abstract: Sorting algorithms have been widely studied in both theory and algorithm design. We present super quick sort, a new practical “in-place” sorting algorithm obtained by merging some characteristics of radix sort and quick sort. Both theoretical analysis and experimental tests confirm the merits of super quick sort. The time complexity and space complexity of the new algorithm is much better than that of both radix sort and quick sort. Keywords: sort; algorithm; quick sort; radix sort; super quick sort
若 n 个待排序数据存储于数组 a[],下标从 0 到 n-1。假设所有数据小于 2 m+1 , m 为一整数，则调用该算法的形式为： bq_sort(0,n-1, 2 m )。若 a[i]& 2 m 为 1,即 a[i]作为二进制,其 m 位为 1；反之，若 a[i]& 2 m 为 0,即 a[i]作为二进制,其 m 位为 0。第二次以形式 bq_sort(low,i, 2 m−1 )调用该算法，即根据 m-1 位来分组 a[low]到 a[i]的数据。
关键词: 排序；算法；快速排序；基数排序；超快速排序
中图法分类号: TP251;
文献标识码: A
排序(Sorting), 就是将数据元素(或记录)的一个任意序列,重新排列成一个按关键字有序的序列。由于排序是计算机科 学中一项复杂而重要的技术,无论在系统软件还是在应用软件中使用频率都很高,因此许多专家、学者对排序问题进行了 深入的探讨,给出了许多时间复杂度仅为 O(N)的高效排序方法[1—5]。基数排序是典型的时间复杂度仅为 O(N)的算法之 一，但其算法结构较复杂，对于一些特殊数据要占用大量额外内存，故使用频率并不高。快速排序算法采用分治原则， 算法结构简单,平均性能较佳为 O(NlogN)，因而被广泛使用。但快速排序算法，在数据部分相等或有序时，时间复杂度 最坏为 O(N 2 )。侧重速度稳定排序算法的时候，往往使用归并排序或堆排序。
结合快 速 排 序的 分 治算 法结构 和基 数 排序 的 原 则 ，本 文提 出超 快速排 序算 法 。新 算法 保 留了 快 速 排序 算 法 结 构的简 洁性，同时速度稳定且优于快速排序算法和基数排序算法。
1．算法描述与分析
我们首先讨论无符号整数的排序. 关于十进制整数的基数排序，假设所有数据的最高位数为 m, 则先根据最高位（m 位）的数字将数据分成 10 个小组； 对于每个小组的数据，根据次高位（m-1 位）的数字将数据分成 10 个小组；……，依此类推，最后根据个位（1 位）的 数字将数据分成 10 个小组,依此收集各个小组的数据，便将数据排序。其算法结构较复杂，对于一些特殊数据要占用大 量额外内存。 二进制整数的基数排序是一个非常特殊的情形，因为只有两个数字 0 和 1，故每次将数据分成 2 个小组。假设所有 数据属于[0，2 m+1 -1], m 为一整数，则先根据最高位（m 位）的数字将数据分成 2 个小组，分别属于[0，2 m -1]和[2 m ， 2 m+1 -1]；根据次高位（m-1 位）的数字将[0，2 m -1]的数据分成 2 个小组，分别属于[0，2 m−1 -1]和[2 m−1 ，2 m -1]，将[2 m ， 2 m+1 -1]的数据分成 2 个小组，分别属于[2 m ，2 m +2 m−1 -1]和[2 m +2 m−1 ，2 m+1 -1]；……，这完全类似于快速排序的分治 算法结构，因而可以类似于快速排序实现该算法。 下面的算法 1 是递归形式的超快速排序算法,。 算法 1：超快速排序 设待排序数据存储于数组 a[]，下标范围为从 low 到 high，所有数据小于 2 m+1 , 令 k=2 m 。 bq_sort(int *a , int low, int high, int k) {
285(2002)25-42
Super quick sort algorithm
Jianqin Zhou Dept. of Computer Science Anhui University of Technology Ma’anshan,Anhui 243002,PRC E-mail: zhou63@
对于有符号整数,在调用 bq_sort 之前, 首先根据符号位将所有数据分成两部分, 只是符号位为 1 的数据放在前面, 符 号位为 0 的数据放在后面，然后再分别调用 bq_sort 即可。在计算机中，副整数是以补码形式存放的，因而 bq_sort 最终 将所有数据按由小到大顺序排序。
对于浮 点 型 数据 ，容 易 转换 为 整数 ，然 后可以 使用 超 快速 排序 。对 于 非数 字型数 据， 如英文 单词 的 排序 ，可 以先将
---------------------------------------------------------------------------------------------------------
*** 《超快速排序算法》一文的附件一
***
RESUME
------------------------------------------------------------------------------------------------
Education:
1986-1989
Statistics Department, Fudan University, Shanghai,
P.R.China, Master of Science in Statistics.
1979-1983
Mathematics Department, East China Normal University,
来自自然界和社会的数据都有一定的变化范围,例如年龄和经济数据等。另外, 计算机处理的数据也有字长的限制, 因而可以假设所有数据小于 2 m+1 , m 为一整数。如果关键字数据类型为字长 16 比特的整数类型，则 m 最大为 15。在数 据分布不均匀的情况，可能出现某个小组数据个数小于 2，或者根据最低位分组后仍有多个相等数据，两种情况下超快 速排序算法都会终止相应的递归，因而其最坏时间复杂度为 O(N(m+1))=O(N)。
表1
数据个数
20,000
200,000
2,000,000
20,000,000
快速排序
4
42
466
13608
归并排序
4
52
573
6191
基数排序(8 进制) 4
32
400
110000
超快速排序
4
32
297
2978
实验表明, 算法 1 实现的超快速排序算法不但继承了基数排序速度稳定的优点，而且其速度明显快于快速排序、归 并排序和基数排序(8 进制)。由此看来，超快速排序算法是名副其实的。
Paul Erdos et al. Research interests include theoretical
computer science, combinatorics and algorithm.
英文单词截成长度为 5 的等长字符串（长度小于 5 时用空格补齐），令空格，A，B，…，Z 分别对应 0，1，2，…，26， 则等长字符串即对应 27 进制整数。使用超快速排序算法排序后，对应的英文单词已经基本有序，只有长度大于 5 的英 文单词可能未排序。再使用简单插入排序算法（该算法当数据基本有序时速度相当快）直接排序即可。
周建钦
超快速排序算法
x=a[j]; a[j]=a[i]; a[i]=x; } else { if(a[j]&k)i--; else j++; break; } } if(k>1) { if(low<i)bq_sort(a,low,i,k/2); if(j<high)bq_sort(a,j,high,k/2); } }