选择排序算法的改进
快速排序算法的改进与分析
快速排序算法的改进与分析快速排序算法是一种经典的排序算法，被广泛应用于各个领域。
然而，快速排序在某些情况下存在效率较低的问题。
在本文中，我们将对快速排序算法进行改进与分析，以提高其在各种情况下的排序效率。
首先，我们来简要介绍一下快速排序算法。
快速排序算法的核心思想是通过选取一个基准元素，将待排序序列分割为独立的两部分，其中一部分的所有元素小于等于基准元素，另一部分的所有元素大于等于基准元素。
然后，对这两部分分别进行递归地快速排序，最终得到有序序列。
虽然快速排序算法在大多数情况下表现出色，但在某些特殊情况下，其效率可能降低到O(n^2)。
这种情况主要发生在待排序序列已经部分有序的情况下，即存在大量的重复元素。
为了解决这一问题，可以对快速排序算法进行改进。
一种改进方法是随机选择基准元素。
原始的快速排序算法通常选择待排序序列的第一个元素作为基准元素，而随机选择基准元素能够有效地避免最坏情况的发生。
通过随机选择基准元素，可以在很大程度上降低分割的不均匀性，进而提高排序效率。
另一种改进方法是三路快速排序。
三路快速排序算法在处理大量重复元素的情况下，能够进一步提高排序效率。
其思想是将待排序序列分成小于、等于和大于基准元素三个部分，并分别对这三个部分进行递归地快速排序。
这种方法能够更加均匀地分割序列，避免重复元素的过多交换，从而加快排序速度。
除了基于元素的改进方法外，还可以考虑基于算法的改进。
例如，引入插入排序。
当待排序序列的规模较小时，插入排序比快速排序更加高效。
因此，在快速排序的递归过程中，可以设置一个阈值，当待排序序列的规模小于该阈值时，采用插入排序而非继续使用快速排序。
这样做可以在一定程度上提高快速排序的效率。
综上所述，快速排序算法是一种高效的排序算法，但在某些情况下存在效率较低的问题。
为了提高快速排序算法的性能，可以采取多种改进方法，如随机选择基准元素、三路快速排序以及引入插入排序等。
这些改进方法能够有效地降低最坏情况的发生概率，提高排序效率。
八大排序算法
八大排序算法排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
我们这里说说八大排序就是内部排序。
基本思想:将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。
即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。
要点：设立哨兵，作为临时存储和判断数组边界之用。
直接插入排序示例：如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。
所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
算法的实现：1.void print(int a[], int n ,int i){2. cout<<i <<":";3.for(int j= 0; j<8; j++){4. cout<<a[j] <<" ";5. }6. cout<<endl;7.}8.9.10.void InsertSort(int a[], int n)11.{12.for(int i= 1; i<n; i++){13.if(a[i] < a[i-1]){ //若第i个元素大于i-1元素，直接插入。
小于的话，移动有序表后插入14.int j= i-1;15.int x = a[i]; //复制为哨兵，即存储待排序元素16. a[i] = a[i-1]; //先后移一个元素17.while(x < a[j]){ //查找在有序表的插入位置18. a[j+1] = a[j];19. j--; //元素后移20. }21. a[j+1] = x; //插入到正确位置22. }23. print(a,n,i); //打印每趟排序的结果24. }25.26.}27.28.int main(){29.int a[8] = {3,1,5,7,2,4,9,6};30. InsertSort(a,8);31. print(a,8,8);32.}效率：时间复杂度：O（n^2）.其他的插入排序有二分插入排序，2-路插入排序。
中国农业大学_821数据结构_《数据结构》习题(9)
第9章内部排序一、问答题1. 什么是内部排序？什么是排序方法的稳定性？2. 对于本章介绍的内部排序方法，哪几种是稳定的？哪几种是不稳定的？对不稳定的排序方法试举例说明。
3. 对于给定的一组记录的关键字：23，13，17，21，30，60，58，28，30，90。
试分别写出用下列排序方法对其进行排序时，每一趟排序后的结果：(1)直接插入排序；(2)希尔排序；(3)冒泡排序；(4)直接选择排序；(5)快速排序(6)堆排序(7)归并排序。
4. 对长度为n的记录序列进行快速排序时，所需要的比较次数依赖于这n个元素的初始序列。
(1)n = 8时，在最好的情况下需要进行多少次比较？试说明理由。
(2)给出n = 8时的一个最好情况的初始排列实例。
5 试为下列各种情况选择合适的排序方法：(1)n = 30，要求在最坏的情况下，排序速度最快；(2)n = 30，要求排序速度既要快，又要排序稳定。
6. 判别以下序列是否为堆（所有的非叶子结点的关键字值k i均不大于其左右两个分支结点的关键字值k2和k2i+1。
），如果不是，则把它调整为堆。
(1)( 100, 86, 48, 73, 35, 39, 42, 57, 66, 21 )；(2)( 12, 70, 33, 65, 24, 56, 48, 92, 86, 33 )；(3)( 103, 97, 56, 38, 66, 23, 42, 12, 30, 52, 06, 20 )；(4) ( 05, 56, 20, 03, 23, 40, 38, 29, 61, 05, 76, 28, 100 )。
7. 一组待排序记录的关键字是：986，321，123，432，500，654，018，765，987，210。
按照LSD方法写出基数排序的过程和结果。
8. 试证明：如果对于一个长度为n的任意文件进行排序，则至少需进行nlog2n次比较。
9. 试构造对5个整数元素进行排序，最多只用7次比较的算法思想。
比较冒泡算法,选择算法,希尔排序算法
一、算法简介冒泡排序算法、选择排序算法和希尔排序算法是三种常用的排序算法。
这三种算法的共同点是都属于比较排序算法，即通过比较元素之间的大小，进行排序。
下面将分别对这三种算法进行介绍。
二、冒泡排序算法冒泡排序算法的基本思想是对相邻的元素进行比较，如果逆序则交换它们的位置，直到整个序列有序为止。
具体实现过程如下：1. 设置循环次数为 n-1，n 为待排序序列长度。
2. 对于每一次循环，从第一个元素开始，依次比较相邻的两个元素，如果逆序则交换它们的位置。
3. 每一次循环结束后，待排序序列中最大的元素就会被排到末尾。
4. 重复执行上述步骤，直到整个序列有序。
冒泡排序算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，稳定性较好，适用于数据量较小的情况。
三、选择排序算法选择排序算法的基本思想是从待排序序列中选择最小的元素，放到已排序序列的末尾，直到整个序列有序为止。
具体实现过程如下：1. 设置循环次数为 n-1，n 为待排序序列长度。
2. 对于每一次循环，从第一个元素开始，找到待排序序列中最小的元素，并将其放到已排序序列的末尾。
3. 重复执行上述步骤，直到整个序列有序。
选择排序算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，稳定性较差，适用于数据量较小的情况。
四、希尔排序算法希尔排序算法也称为缩小增量排序算法，是插入排序算法的一种改进。
希尔排序算法的基本思想是将待排序序列分成若干个子序列，对每个子序列进行插入排序，然后再对整个序列进行一次插入排序，直到整个序列有序为止。
具体实现过程如下：1. 设置一个增量值 gap，将待排序序列分成若干个子序列，每个子序列包含的元素个数为 gap。
2. 对于每个子序列，进行插入排序。
3. 减小增量值 gap，重复执行上述步骤，直到 gap=1。
4. 对整个序列进行一次插入排序，使得序列有序。
希尔排序算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，稳定性较差，适用于数据量较大的情况。
7排序
数据结构
例： 初始
49 38 65 97 76 13 27
48
55
4
取d1=5 一趟分组：49 38 65 97 76 13 27
48
55
4
一趟排序：13 27 48 55 4
49 38
65
97
76
取d2=3 13 27 48 55 4 二趟分组：
49 38
65
97
76
二趟排序：13
4
48 38 27
做出相应的调整，那样排序的总体效率会非常高。
• 堆排序(Heap Sort)就是对简单选择排序的一种改进。堆排序 算法是Floyd和Williams在1964年共同发明，同时发明了“堆” 这样的数据结构。
数据结构
堆的定义
一、定义
16 11 9
10 1 2
2
5 4
6
大顶堆
8
1
6 9
小顶堆
数据结构
11 4 12 16 5
• R[0]为监视哨（Sentinel），省略下标越界检查“j>0”：一 旦越界，j=0<1，循环条件R[0]<R[j]不成立，自动控制 while循环的结束。
例：有监视哨，第3趟
0 1 2 3 4 5 6 7 8 9 10 m
初始：
i=3: j=2: j=1: j=0:
49 38 13 76 27 49 38 49 13 76 27 49 13 38 49 13 76 27 49 13 38 49 49 76 27 49 13 38 38 49 76 27 49 13 13 38 49 76 27 49
8
堆的定义
一、定义 • 堆是具有下列性质的完全二叉树：任一结点关键字大于等于 其孩子结点的关键字，称为大顶堆；任一结点关键字小于等 于其孩子结点的关键字，称为小顶堆。 • 将R[1]到R[n]看成完全二叉树的顺序存储结构。根据二叉树 的性质5，如果双亲下标为i，其左右孩子的下标分别为2i和 2i+1. 当且仅当任一R[i]满足以下关系时，称之为堆： R[i] ≤ R[2i]且R[i] ≤ R[2i+1] (1 ≤ i ≤ n/2) 或者 R[i] ≥ R[2i]且R[i] ≥ R[2i+1] (1 ≤ i ≤ n/2) 且分别称之为小顶堆和大顶堆。
基于排序选择的改进遗传算法优化的神经网络控制
对应中间值。另外再 随机选 取一些个体 ， 使规模 超过初始
种群规模 ｎ 然后再从 中选 出适应度最 大 的 ｎ个个 体作为 ，
初始 种 群 。这 样 选 择 的 初 始 种 群 在 解 空 间 中 分 布 比 较 均 匀 ， 利 于 加快 收敛 速度 。 有
来的概率 Ｊ 。 ２ １ 加入适应值 信息的非 线性 排序选择方法 ． 按序 号选择 的规 则有 线性 和非 线性两 种 。设 群体 规
收敛速度慢等缺点 ， 出了使用一种基于排序选择 的改进遗 传算法 。用改进 的遗 传算法优化 调整神经 网络的权 提 值 。仿真研究表 明， 用此算法能够充分发挥其全局寻优 的特点 ， 且能够 很好 的弥补 Ｂ Ｐ算 法训练 时间长 ， 响应速
度 慢 的不 足 。
关键词 ： 遗传算法 ； 神经网络 ； 排序选择 中 图分 类 号 ：Ｐ ８ Ｔ １３ 文 献标 识 码 ： Ａ 遗传算法用 于神经 网络 主要 是用遗 传算 法学 习神 经 网络 的权重和学习神经网络 的拓扑结构 ， 而最 主要 的是学
其 中：ｅ ｇｎ表示世代数 ； Ｘ Ｅ ＭＡ Ｇ Ｎ表示最大世代 数。这种方 法有助于加快算法的前期收敛 和防止算法 的后期早熟。
２３ 初 始 种 群 产 生 方 法 的修 改 ．
将解空间划分为 ｉ ， 维 参数 ｉ 为个 体基 因数 ， 即寻优 参
数 的个 数 。 选 取 ｉ 空 间 中 ３ 个 向 量 ， 一 维 取 ０ ０ ５ １ 维 ‘ 每 ，． ，
式中 ：ｊ ｖ 表示前一层第 个节点 的输 出； 表示 网络 的连接 权值 。第 ｉ 个节点 的输 出表示为
＝ｇ Ｕ ） （。
个输 出层 ， 表示为第 ｉ 的节点数 ， 层 每个 节点含有一个 阀
王永伟冒泡排序
Next i
A. 118 118 15 2 36 98
B. 2 15 36 98 118 118
C. 2 15 36 118 98 118 D. 98 15 2 36 118 118
冒泡排序：前大后小才交换，按升序。
(二)选择排序
1．选择排序算法的概念 选择排序算法是对冒泡排序算法的改进 。这种方法是对 参加排序数组的所有元素中找出最小(或最大)数据的元素， 使它与第一个元素中数据相互交换位置。然后在余下的元素 中找出最小(或最大)的数据的元素，与第二个元素中的数据 交换位置。以此类推，直到所有元素成为一个有序的序列。
使用流程图描述对分查找的算法如下图所示：
4．对分查找算法程序的实现要点
(1)由于比较次数难以确定，所以用Do语句来实现循环； (2)在Do循环体中用If语句来判断查找是否成功； (3)若查找成功则输出查找结果，并结束循环(Exit Do)； (4)若查找不成功，则判断查找键在数组的左半区间还是右 半区间，从而缩小范围。 对分查找的程序结构如下(升序序列)：
第2遍：寻找从d(2)到d(4)范围 内的最小数据d(k)，即k＝3，将 d(2)与d(k)互换数据：
共比较数据2次，交换数据1次。
第3遍：寻找从d(3)到d(4)范围内 的最小数据d(k)，即k＝4，将d(3)与 d(k)互换数据：
总共比较数据1次，交换数据1次。
显然，通过上述3遍处理，数组d中最小、第2小、第3小 的数据已经分别存储在数组元素d(1)、d(2)、d(3)中，即数组 元素d(1)到d(3)变为有序，而剩下的d(4)中的数据自然是数组 中的最大数据。因此，通过3遍这样的处理，整个数组内的数 据将是有序的。
对分查找程序的基本框架：
几种排序的算法时间复杂度比较
几种排序的算法时间复杂度比较1.选择排序：不稳定，时间复杂度 O(n^2)选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。
这样，经过i遍处理之后，前i个记录的位置已经是正确的了。
2.插入排序：稳定，时间复杂度 O(n^2)插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。
第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i] 又是排好序的序列。
要达到这个目的，我们可以用顺序比较的方法。
首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。
图1演示了对4个元素进行插入排序的过程，共需要(a),(b),(c)三次插入。
3.冒泡排序：稳定，时间复杂度 O(n^2)冒泡排序方法是最简单的排序方法。
这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。
在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。
所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。
如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。
显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。
在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。
一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。
4.堆排序：不稳定，时间复杂度 O(nlog n)堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
406
max col= j; times + + ; }
佳
木
斯
大
学
学
报 (自
然
科
学
版) 2001 年
/ * 将剩余的未排序元素中最大者的下标赋于变量 ma xcol* / / * 统计每轮交换数据的次数* /
if ( array [ j] < min) { min = array [ j] ; mincol= j; times + + ; } } if ( max col! = i) { tem p= array[ max col] ; array[ max col] = array [ i] ; arra y[ i] = tem p; / * 第 i 个元素与第 m axco l 个元素相交换* / if ( minco l= = i) { / * 若剩余的未排序元素中最小者即是先前假定的原来第 i 个元* / / * 第 i 轮双向选择前剩余的未排序元素中最小者应为排序后第 i 小的元素, 故应将其值赋于第( n + 1- i) 个元素* / tem p= array[ max col] ; arra y[ m ax co l] = array[ n- i+ 1] ; arra y[ n- i+ 1] = tem p; else / * 若剩余的未排序元素中最小者不是先前假定的原来第 i 个元素* / { tem p= array[ mincol] ; arra y[ m incol ] = arra y[ n- i+ 1] ; arra y[ n - i+ 1] = tem p; } } else / * 若剩余的未排序元素中最大者即是先前假定的原来第 i 个元素, 故无需将第 i 个元素与第 max col 个元素相交换* / { if ( minco l! = n+ 1- i) { / * 若剩余的未排序元素中最小者的不是原来第( n + 1- i) 个元素* / / * 第 i 轮双向选择前剩余的未排序元素中最小者应为排序后第 i 小的元素, 故应将第 minco l 个元素与第 ( n+ 1- i) 个元素相交换* / tem p= array[ mincol] ; arra y[ m incol ] = arra y[ n + 1- i] ; arra y[ n+ 1- i] = tem p; } } printf( "经第% d 轮双向选择后: ", i) ; fo r ( j= 1; j< = n; j+ + ) { if ( j= = i) printf ( " % c%d " , 24, array [ j] ) ; / * 被选择的最“ 大” 数前面加上一个符号“ ↑” 以强调显示* / else if( j= = n+ 1- i) printf ( " %d% c " , array[ j] , 25) ; / * 被选择的最“ 小” 数后面加上一个符号“ ↓” 以强调显示* / else printf ( " %d " , array[ j] ) ; } printf( "/ n" ) ; tem pchar= get ch( ) ; if ( times= = 0) break; } printf( "/ n" ) ; if ( i> n/ 2) i- - ; / * 若需进行[ n/ 2] 轮排序, 则上面用于排序的循环结束后, i> [ n/ 2] , 须进行调整* / / * 显示每一轮排序的结果后换行* / / * 显示每一轮排序的结果后暂停, 用户按任一键后继续进行下一轮排序* / / * 若某一轮排序过程中没有进行数据交换, 则可提前结束循环* / / * 显示每一轮经双向选择排序的结果* / / * 第 i 轮双向选择前剩余的未排序元素中最小者应为排序后第 i 小的元素, 故应将其值赋于第( n+ 1- i) 个元素* / / * 将第 m incol 个元素与第( n- i+ 1) 个元素相交换* / / * 因原来第 i 个元素已交换至第 m axco l 个元素, 故应将第 max col 个元素与第( n- i+ 1) 个元素相交换* / / * 若剩余的未排序元素中最大者不是先前假定的原来第 i 个元素而是原来第 ma xcol 个元素* / / * 将剩余的未排序元素中最小者的值赋于变量 min * / / * 将剩余的未排序元素中最小者的下标赋于变量 mincol* / / * 统计每轮交换数据的次数* /
{ times = 0; max = array[ i] ; m axco l= i; min = array [ i] ; mincol= i; / * 每轮交换数据的次数初值设为 0* / / * 第 i 轮选择浮沉前, 先假定第 i 个元素为剩余的未排序元素中最大者, 相应地最大元素的下标初值置为 i* / / * 第 i 轮选择浮沉前, 先假定第 i 个元素为剩余的未排序元素中最小者, 相应地最小元素的下标初值置为 i* /
2 算法的实现
上述改进后的选择排序算法原理简单, 容易实现 , 且不存在存贮空间及运行时间方面的浪费. 笔者利 用 C 语言编程实现了该算法, 参考程序如下 :
# incl ude< s t dio. h> # incl ude< all oc. h> void m ain ( ) { / * 该程序利用改进后的选择法进行非递增排序 * / int n, i, j, t imes , t emp, m ax , mi n, max col, min col; int * array; ch ar t empchar; cl rscr( ) ; print f ( " 请输入需排序的数据个数 n : ") ; scanf ( "% d", &n) ; ar ray= ( int * ) malloc( ( n + 1) * sizeof( int ) ) ; print f ( " 请输入 % d 个数据 : ", n ) ; f or ( i= 1; i< = n; i+ + ) scanf ( "% d", array+ i) ; print f ( " 原始顺序为 : / n") ; f or ( i= 1; i< = n; i+ + ) print f ( "% d", array [ i] ) ; print f ( "/ n") ; f or ( i= 1; i< = n/ 2; i+ + ) / * 利用双向选择法排序, 最多只需进行[ n/ 2] 轮循环( 符号[ n/ 2] 指不大于( n/ 2) 的最大整数, 下同) * /
1 问题的分析
易知, 若需对第 1 ～n 个项目组成的序列采用改进后的选择法进行排序 , 无需进行 ( n- 1) 趟排序 , 最 多只需进行[ n/ 2] 趟排序 ( 符号 [ n/ 2] 指不大于 ( n/ 2) 的最大整数, 下同 ) . 第 i 趟排序前, 关键字最大的 ( i1) 个项目及最小的 ( i- 1) 个项目已被交换至它们应在的位置, 故第 i 趟排序仅需对剩下的第 i ～( n - i + 1) 个项目进行. 在第 i 个项目的关键字与其后的第 ( i+ 1) ～ n 个项目的关键字都比较完后, 选择第 i～n 个项 目中关键字最“ 大” 项目交换至第 i 个项目的位置, 并选择关键字第 i“ 小” 的元素交换至第( n- i+ 1) 个项 目的位置. 所以改进后的选择法排序的关键在于在进行第 i 趟排序时, 在第 i～ ( n - i+ 1) 项目中找出关键 字最“ 大” 的项目的下标序号 ( 即位置 ) 及关键字最“ 小” 的项目的下标序号, 然后将关键字最“ 大” 的项目及 关键字最“ 小” 的项目进行合理高效的移动 . 在进行第 i 趟排序时, 容易做到在 i～( n- i+ 1) 项目中既找出关键字最“ 大” 的项目的下标序号 max 小” 的项目的下标序号 m incol, 但在进行将关键字最“ 大” 的项目移至第 i 个项目的位 col , 又找出关键字最“
第 19 卷 第 4 期 2001 年 12 月
佳 木
斯
大
学
学
报
(自
然
科
学
版)
Vol. 19 No. 4 Dec. 2001
Journal of Jiamusi Universi ty( Natural Science Edi tion)
文章编号 : 1008- 1402( 2001) 04- 0404- 04
0 问题的提出
比较交换排序算法是一种最简单的且为人们所熟知的籍助“ 交换” 进行排序的算法 . 其方法是在由第 1～ n 个项目组成的序列中, 首先将第一个项目的关键字与其后第 2 ～n 个项目的关键字进行比较 , 若发现 逆序( 即与所要求的次序不一致 ) 就交换这两个项目 , 经过一趟排序将关键字最大或最小的项目交换到第 一个项目的位置; 然后将第 2 个项目与其后第 3～n 个项目的关键字进行比较 , 凡与所要求的次序不一致, 就交换这两个项目 , 经第 2 趟排序后将关键字次大或次小的项目交换至第 2 个项目的位置; …, 将第 i 个 项目的关键字与其后的第( i+ 1) ～ n 个项目的关键字进行比较, 凡出现逆序, 就交换这两个项目 , 经第 i 趟 排序将关键字第 i 大或第 i 小的项目交换至第 i 个项目的位置 ; …… , 经过( n- 1) 趟排序, 将待排序的无序 序列按要求完成排序工作. 选择法排序算法是对比较交换排序算法的改进 , 其方法是在进行第 i 趟排序 时 , 将第 i 个项目的关键字与其后的第 ( i+ 1) ～n 个项目的关键字进行比较过程中, 不必凡出现逆序, 就交 换这两个项目 , 而是在第 i 个项目的关键字与其后的第 ( i+ 1) ～n 个项目的关键字都比较完后 , 选择第 i～ n 个项目中关键字最大或最小的项目交换并将其交换至第 i 个项目的位置. 该算法在一定程度上克服了比 较交换排序算法交换次数过多的缺陷, 但其效率仍较为低下 , 能否在进行第 i 趟排序时 , 在第 i～n 个项目 中既选择一个关键字最大的项目 , 又选择一个关键字最小的项目, 然后将其交换至它们应在的位置以进一 步提高效率呢 ?