（第20讲）关于排序的各种算法的汇总的题目

来源：互联网发布：动画剧场版神作知乎编辑：程序博客网时间：2024/06/11 14:24

1、排序算法的稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

稳定的排序算法有：冒泡、插入、归并

不稳定的有：选择、希尔、快排、堆排

2、一个递归必须包含：终止条件和递归部分

3、快排在什么情况下最弱：排有序序列，降成N的平方

一、选择题

1．某内排序方法的稳定性是指( )。

A．该排序算法不允许有相同的关键字记录 B．该排序算法允许有相同的关键字记录

C．平均时间为0（n log n）的排序方法D．以上都不对

2．下面给出的四种排序法中( )排序法是不稳定性排序法。

A. 插入 B. 冒泡 C. 二路归并 D. 堆积

3．下列排序算法中，其中（）是稳定的。

A. 堆排序，冒泡排序 B. 快速排序，堆排序

C. 直接选择排序，归并排序 D. 归并排序，冒泡排序

4．稳定的排序方法是（）

A．直接插入排序和快速排序 B．折半插入排序和起泡排序

C．简单选择排序和四路归并排序 D．树形选择排序和shell排序

5．下列排序方法中，哪一个是稳定的排序方法？（　）

A．直接选择排序 B．二分法插入排序 C．希尔排序 D．快速排序

6．若要求尽可能快地对序列进行稳定的排序，则应选（A．快速排序 B．归并排序 C．冒泡排序）。

7．如果待排序序列中两个数据元素具有相同的值，在排序前后它们的相互位置发生颠倒，则称该排序算法是不稳定的。（）就是不稳定的排序方法。

A．起泡排序 B．归并排序 C．Shell排序 D．直接插入排序 E．简单选择排序

8．若要求排序是稳定的，且关键字为实数，则在下列排序方法中应选（）排序为宜。

A．直接插入 B．直接选择 C．堆 D．快速 E．基数

9．若需在O(nlog2n)的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是）。

A. 快速排序 B. 堆排序 C. 归并排序 D. 直接插入排序

10．下面的排序算法中，不稳定的是（）

A.起泡排序 B.折半插入排序 C.简单选择排序 D.希尔排序 E.基数排序 F.堆排序。

11．下列内部排序算法中：

A．快速排序 B.直接插入排序 C.二路归并排序 D.简单选择排序 E.起泡排序 F. 堆排序

（1）其比较次数与序列初态无关的算法是（）

（2）不稳定的排序算法是（）

（3）在初始序列已基本有序（除去n个元素中的某k个元素后即呈有序，k<<n）的情况下，排序效率最高的算法是（）

（4）排序的平均时间复杂度为O(n•logn)的算法是（）为O(n•n)的算法是（）

12．排序趟数与序列的原始状态有关的排序方法是( )排序法。

A．插入 B. 选择 C. 冒泡 D. 快速

13．下面给出的四种排序方法中，排序过程中的比较次数与排序方法无关的是。( )

A．选择排序法 B. 插入排序法 C. 快速排序法 D. 堆积排序法

14．对下列四种排序方法，在排序中关键字比较次数同记录初始排列无关的是( )。

A．直接插入 B. 二分法插入 C. 快速排序 D. 归并排序

15．在下列排序算法中,哪一个算法的时间复杂度与初始排序无关（）。

A．直接插入排序 B. 气泡排序 C. 快速排序 D. 直接选择排序

16．比较次数与排序的初始状态无关的排序方法是( )。

A．直接插入排序 B．起泡排序 C．快速排序 D．简单选择排序

17．数据序列（8，9，10，4，5，6，20，1，2）只能是下列排序算法中的( )的两趟排序后的结果。

A．选择排序 B.冒泡排序 C.插入排序 D.堆排序

18．数据序列（2，1，4，9，8，10，6，20）只能是下列排序算法中的( )的两趟排序后的结果。

A. 快速排序 B. 冒泡排序 C. 选择排序 D. 插入排序

19．对一组数据（84，47，25，15，21）排序，数据的排列次序在排序的过程中的变化为

（1） 84 47 25 15 21 （2） 15 47 25 84 21 （3） 15 21 2584 47 （4） 15 21 25 47 84

则采用的排序是 ( )。

A. 选择 B. 冒泡 C. 快速 D. 插入

20．对序列{15，9，7，8，20，-1，4}进行排序，进行一趟后数据的排列变为{4，9，-1，8，20，7，15}；则采用的是（）排序。

A. 选择 B. 快速 C. 希尔 D. 冒泡

21．若上题的数据经一趟排序后的排列为{9，15，7，8，20，-1，4}，则采用的是（）排序。

A．选择 B. 堆 C. 直接插入 D. 冒泡

22．下列排序算法中( )不能保证每趟排序至少能将一个元素放到其最终的位置上。

A.快速排序 B. shell排序 C.堆排序 D.冒泡排序

23．下列排序算法中( )排序在一趟结束后不一定能选出一个元素放在其最终位置上。

A. 选择 B. 冒泡 C. 归并 D. 堆

24．下列序列中，（）是执行第一趟快速排序后所得的序列。

A. [68，11，18，69] [23，93，73] B. [68，11，69，23] [18，93，73]

C. [93，73] [68，11，69，23，18] D. [68，11，69，23，18] [93，73]

25．有一组数据（15，9，7，8，20，-1，7，4）用快速排序的划分方法进行一趟划分后数据的排序为 ( )（按递增序）。

A．下面的B，C，D都不对。 B．9，7，8，4，-1，7，15，20

C．20，15，8，9，7，-1，4，7 D. 9，4，7，8，7，-1，15，20

26．一组记录的关键码为（46，79，56，38，40，84），则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为（）。

A．(38,40,46,56,79,84) B. (40,38,46,79,56,84)

C．(40,38,46,56,79,84) D. (40,38,46,84,56,79)

27. 在下面的排序方法中，辅助空间为O（n）的是( ) 。

A．希尔排序 B. 堆排序 C. 选择排序 D. 归并排序

28．下列排序算法中，在待排序数据已有序时，花费时间反而最多的是( )排序。

A．冒泡 B.希尔 C.快速 D.堆

29.下列排序算法中，在每一趟都能选出一个元素放到其最终位置上，并且其时间性能受数据初始特性影响的是：（）。

A. 直接插入排序 B. 快速排序 C. 直接选择排序 D. 堆排序

30. 对初始状态为递增序列的表按递增顺序排序，最省时间的是（）算法，最费时间的是（）算法。

A. 堆排序 B. 快速排序 C. 插入排序 D. 归并排序

31. 就平均性能而言，目前最好的内排序方法是( )排序法。

A. 冒泡 B. 希尔插入 C. 交换 D.快速

32．如果只想得到1000个元素组成的序列中第5个最小元素之前的部分排序的序列，用（）方法最快。

A．起泡排序 B．快速排列 C．Shell排序 D．堆排序 E．简单选择排序

答案：

1.D

2.D

3.D

4.B

5.B

6.B

7.C,E

8.A

9.C

10.C,D,F

11.1D,C 11.2A,D,F

11.3B 11.4(A,C,F)(B,D,E)

12.C,D

13.A

14.B,D

15.D

16.D

17.C

18.A

19.A

20.C

21.C

22.B

23.C

24.C

25.A

26.C

27.D

28.C

29.B

30.C,B

31.D

32.D

部分答案解释如下：

18.对于后三种排序方法两趟排序后，序列的首部或尾部的两个元素应是有序的两个极值，而给定的序列并不满足。

20.本题为步长为3的一趟希尔排序。 24.枢轴是73。

49.小根堆中，关键字最大的记录只能在叶结点上，故不可能在小于等于n/2的结点上。

64.因组与组之间已有序，故将n/k个组分别排序即可，基于比较的排序方法每组的时间下界为O(klog2k),全部时间下界为O(nlog2k)。

二、判断题：

1．当待排序的元素很大时，为了交换元素的位置，移动元素要占用较多的时间，这是影响时间复杂度的主要因素。（）

2．内排序要求数据一定要以顺序方式存储。（）

3．排序算法中的比较次数与初始元素序列的排列无关。（）

4．排序的稳定性是指排序算法中的比较次数保持不变，且算法能够终止。（）

5．在执行某个排序算法过程中，出现了排序码朝着最终排序序列位置相反方向移动，则该算法是不稳定的。（）

6．直接选择排序算法在最好情况下的时间复杂度为O（N）。（）

7．两分法插入排序所需比较次数与待排序记录的初始排列状态相关。（）

8．在初始数据表已经有序时，快速排序算法的时间复杂度为O(nlog2n )。（）

9．在待排数据基本有序的情况下，快速排序效果最好。（）

10．当待排序记录已经从小到大排序或者已经从大到小排序时，快速排序的执行时间最省。（）

11．快速排序的速度在所有排序方法中为最快,而且所需附加空间也最少。（）

12．堆肯定是一棵平衡二叉树。（）

13．堆是满二叉树。（）【

14．（101，88，46，70，34，39，45，58，66，10）是堆。（）

15．在用堆排序算法排序时，如果要进行增序排序，则需要采用“大根堆”。（）

16．堆排序是稳定的排序方法。（）

17．归并排序辅助存储为O（1）。（）

18．在分配排序时，最高位优先分配法比最低位优先分配法简单。（）

19．冒泡排序和快速排序都是基于交换两个逆序元素的排序方法,冒泡排序算法的最坏时间复杂性是O(n*n),而快速排序算法的最坏时间复杂性是O(nlog2n),所以快速排序比冒泡排序算法效率更高。（）

20．交换排序法是对序列中的元素进行一系列比较，当被比较的两个元素逆序时，进行交换，冒泡排序和快速排序是基于这类方法的两种排序方法，冒泡排序算法的最坏时间复杂性是O（n*n），（）而快速排序算法的最坏时间复杂性是O（nlog2n）；所以快速排序比冒泡排序效率更高。

21．快速排序和归并排序在最坏情况下的比较次数都是O(nlog2n)。（）

22．在任何情况下，归并排序都比简单插入排序快。（）

23．归并排序在任何情况下都比所有简单排序速度快。（）

24．快速排序总比简单排序快。（）

25. 中序周游（遍历）平衡的二叉排序树，可得到最好排序的关键码序列。（）

三、填空题

1．若不考虑基数排序，则在排序过程中，主要进行的两种基本操作是关键字的______和记录的_____。

2. 外排序的基本操作过程是_______和_______。

3. 属于不稳定排序的有__________。

4．分别采用堆排序，快速排序，冒泡排序和归并排序，对初态为有序的表，则最省时间的是_____算法，最费时间的是______算法。

5. 不受待排序初始序列的影响，时间复杂度为O(N2)的排序算法是_____，在排序算法的最后一趟开始之前，所有元素都可能不在其最终位置上的排序算法是_____。

6．直接插入排序用监视哨的作用是_______。

7．对n个记录的表r[1..n]进行简单选择排序，所需进行的关键字间的比较次数为_______。

8. 用链表表示的数据的简单选择排序，结点的域为数据域data，指针域 next；链表首指针为head，链表无头结点。

selectsort(head)

p=head;

while(p(1)_______)

{q=p;r=(2)_______

while((3)______ )

{if ((4)_______) q=r;

r=(5)_______ ;

}

tmp=q->data; q->data=p->data; p->data=tmp;p= (6)_______ ;

}

9．下面的c函数实现对链表head进行选择排序的算法,排序完毕,链表中的结点按结点值从小到大链接。请在空框处填上适当内容,每个空框只填一个语句或一个表达式：

#include<stdio.h>

typedef structnode {char data; struct node *link; }node;

node*select(node *head)

{node*p,*q,*r,*s;

p=(node*)malloc(sizeof(node));

p->link=head; head=p;

while(p->link!=null)

{q=p->link; r=p;

while ((1)____)

{ if (q->link->data<r->link->data) r=q;

q=q->link;

}

if ((2)____) {s=r->link; r->link=s->link; s->link= ((3)_____);((4)_____);}

((5)____) ;

}

p=head;head=head->link; free(p); return(head);

}

10．下面的排序算法的思想是：第一趟比较将最小的元素放在r[1]中，最大的元素放在r[n]中，第二趟比较将次小的放在r[2]中，将次大的放在r[n-1]中，…,依次下去，直到待排序列为递增序。（注：<-->）代表两个变量的数据交换）。

void sort(SqList&r,int n) {

i=1;

while((1)__) {

min=max=1;

for(j=i+1;(2)____ ;++j)

{if((3)____)min=j; else if(r[j].key>r[max].key) max=j; }

if((4)_____)r[min] < ---- >r[j];

if(max!=n-i+1){if((5)___) r[min] < ---- > r[n-i+1]; else ((6)__); }

i++;

}

}//sort

习题答案

二、判断题

1.√

2.×

3.×

4.×

5.×

6.×

7.×

8.×

9.×

10.×

11.×

12.×

13.×

14.√

15.√

16.×

17.×

18.×

19.×

20.×

21.×

22.×

23.×

24.×

25.√

部分答案解释如下：

5. 错误。例如冒泡排序是稳定排序，将4,3,2,1按冒泡排序排成升序序列，第一趟变成3,2,1,4，此时3就朝向最终位置的相反方向移动。 12. 错误。堆是n个元素的序列，可以看作是完全二叉树，但相对于根并无左小右大的要求，故其既不是二叉排序树，更不会是平衡二叉树。

22. 错误。待排序序列为正序时，简单插入排序比归并排序快。

三、填空题

1. 比较,移动 2.生成有序归并段（顺串）,归并 3.希尔排序、简单选择排序、快速排序、堆排序等

4. 冒泡,快速 5. (1)简单选择排序 (2)直接插入排序（最小的元素在最后时）

6. 免去查找过程中每一步都要检测整个表是否查找完毕，提高了查找效率。 7.n(n-1)/2

8.题中p指向无序区第一个记录，q指向最小值结点，一趟排序结束，p和q所指结点值交换，同时向后移p指针。(1)!=null (2)p->next (3)r!=null (4)r->data<q->data(5)r->next (6)p->next

9. 题中为操作方便，先增加头结点（最后删除），p指向无序区的前一记录，r指向最小值结点的前驱，一趟排序结束，无序区第一个记录与r所指结点的后继交换指针。

(1)q->link!=NULL(2)r!=p (3)p->link(4)p->link=s (5)p=p->link

10.(1)i<n-i+1(2)j<=n-i+1 (3)r[j].key<r[min].key (4)min!=i (5)max==i(6)r[max]<-->r[n-i+1]

1、以下关于运算符优先顺序的描述中正确的是______。（）D
A、关系运算符＜算术运算符＜赋值运算符＜逻辑与运算符
B、逻辑与运算符＜关系运算符＜算术运算符＜赋值运算符
C、算术运算符＜关系运算符＜赋值运算符＜逻辑与运算符
D、赋值运算符＜逻辑与运算符＜关系运算符＜算术运算符

2、C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式是 B

C语言规定,数组名做实参时,它和对应形参之间的数据传递方式是 A

A.    地址传递B.单向的值传递C.由实参传给形参，再由形参传回给实参D.由用户指定传递方式

形参：函数定义中的参数

实参：函数调用时的参数

参数传送只有两种传递方式：

值传递，又称单向传递，只能把实参数值传给形参，形参最后的结果不影响实参（形参改变大小，实参大小不变）

地址传递，通过指针，把实参的地址给形参，形参的大小可以影响实参

3、2048游戏理想情况下最大值：131072最小值：4

因为假设四格，第一个2，第二个4，第三个8，第四个16，这样最大是2的四次方，但如果第一个是4（因为游戏随机出现的可能会是4），这样最大的就是2的五次方，同理。

1、下面的排序算法中，初始数据集的排列顺序对算法的性能无影响的是（）

A、插入排序 B、堆排序 C、冒泡排序 D、快速排序

2、以下关于Cache的叙述中，正确的是（）

A、CPU中的Cache容量应大于CPU之外的Cache容量

B、Cache的设计思想是在合理成本下提高命中率

C、Cache的设计目标是容量尽可能与主存容量相等

D、在容量确定的情况下，替换算法的时间复杂度是影响Cache命中率的关键因素

3、数据存储在磁盘上的排列方式会影响I/O服务的性能，一个圆环的磁道上有10个物理块，10个数据记录R1------R10存放在这个磁道上，记录的安排顺序如下表所示：

物理块

逻辑记录

R10

假设磁盘的旋转速度为20ms/周，磁盘当前处在R1的开头处，若系统顺序扫描后将数据放入单缓冲区内，处理数据的时间为4ms（然后再读取下个记录），则处理这10个记录的最长时间为（）

A、180ms B、200ms C、204ms D、220ms

4、随着IP网络的发展，为了节省可分配的注册IP地址，有一些地址被拿出来用于私有IP地址，以下不属于私有IP地址范围的是（）

A、10.6.207.84 B、172.23.30.28 C、172.32.50.80 D、192.168.1.100

5、下列关于一个类的静态成员的描述中，不正确的是（）

A、该类的对象共享其静态成员变量的值 B、静态成员变量可被该类的所有方法访问

C、该类的静态方法只能访问该类的静态成员变量 D、该类的静态数据成员变量的值不可修改

6、已知一个线性表（38，25，74，63，52，48），假定采用散列函数h（key) = key%7计算散列地址，并散列存储在散列表A【0....6】中，若采用线性探测方法解决冲突，则在该散列表上进行等概率成功查找的平均查找长度为（）

A、1.5 B、1.7 C、2.0 D、2.3

7、表达式“X=A+B*（C--D）/E”的后缀表示形式可以为（）

A、XAB+CDE/-*= B、XA+BC-DE/*= C、XABCD-*E/+= D、XABCDE+*/=

8、（）设计模式将抽象部分与它的实现部分相分离。

A、Singleton（单例） B、 Bridge（桥接）

C、 Composite（组合） D、 Facade（外观）

9、下面程序的输出结果为多少？

void Func(charstr_arg[100])

{

printf("%d\n",sizeof(str_arg));

}

intmain(void)

{

char str[]="Hello";

printf("%d\n",sizeof(str));

printf("%d\n",strlen(str));

char *p = str;

printf("%d\n",sizeof(p));

Func(str);

}

10、C++将父类的析构函数定义为虚函数，下列正确的是哪个？
A、释放父类指针时能正确释放子类对象
B、释放子类指针时能正确释放父类对象
C、这样做是错误的
D、以上全错

11、下列哪一个不属于关系数据库的特点？
A、数据冗余度小
B、数据独立性高
C、数据共享性好
D、多用户访问

12、下面程序的输出结果为多少？

void Func(charstr_arg[2])

{

int m = sizeof(str_arg);

int n = strlen(str_arg);

printf("%d\n",m);

printf("%d\n",n);

}

intmain(void)

{

char str[]="Hello";

Func(str);

}

13、typedef char *String_t;和 #define String_d char *这两句在使用上有什么区别？

14、到商店里买200的商品返还100优惠券（可以在本商店代替现金）。请问实际上折扣是多少？

15、题目：已知rand7()可以产生 1~7的7个数（均匀概率），利用rand7() 产生rand10() 1~10（均匀概率）

16、给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。

17、对一个正整数作如下操作：如果是偶数则除以2，如果是奇数则加1，如此进行直到1时操作停止，求经过9次操作变为1的数有多少个？

算法编程题：

1、给定一个字符串，求出其最长的重复子串。

参考答案

1. B。若序列事先已经基本有序，则插入法和冒泡法会明显减少比较次数，快速排序法与主元的选择有关，若一般选子序列左侧第一个元素比较，则第一个元素最好是大小居中的，以使得分成的两个子数组长度大致相等，性能才能最佳，所以快速排序也与初始输入集有关的。堆排序受数据集输入顺序影响最小。

2. B。Cache（高速缓冲器）容量小于主存，但速度快于主存，慢于CPU，相当于CPU和主存间的一个缓冲器，Cache中存放最近使用过的内存内容（基于最近使用过的内容很可能被再次使用的原理）。若CPU寻访的内容在Cache中存放，则优先从Cache中读取，称为命中，否则称为脱靶，脱靶只能从主存中读取内容了。当Cache存储满的时候，用替换算法清理掉不用的内容，保留下最新或最常使用的内容，称为替换。Cache设计目标是提高命中率。替换算法确实是影响Cache命中率，但还有Cache容量、存储单元大小、组数多少、地址比较方法、写操作方法等都会影响Cache命中率。

3. C。这道题终于会做了。是这样的原理，磁盘会一直朝某个方向旋转，不会因为处理数据而停止。本题要求顺序处理R1到R10，起始位置在R1，一周是20ms，共10个记录，所以每个记录的读取时间为2ms。首先读R1并处理R1，读R1花2ms，读好后磁盘处于R1的末尾或R2的开头，此时处理R1，需要4ms，因为磁盘一直旋转，所以R1处理好了后磁盘已经转到R4的开始了，这时花的时间为2+4=6ms。这时候要处理R2，需要等待磁盘从R5一直转到R2的开始才行，磁盘转动不可反向，所以要经过8*2ms才能转到R1的末尾，读取R2需要2ms，再处理R2需要4ms，处理结束后磁盘已经转到R5的开头了，这时花的时间为2*8+2+4=22ms。等待磁盘再转到R3又要8*2ms，加上R3自身2ms的读取时间和4ms的处理时间，花的时间也为22ms，此时磁盘已经转到R6的开头了，写到这里，大家已经可以看到规律了，读取并处理后序记录都为22ms，所以总时间为6+22*9=204ms。

4. C。见实习生笔试里的解释。

5. D。静态成员只要不是const的，每个对象都对其进行可以修改，但注意静态成员只有一份，修改后所有对象再访问的时候，都是最近修改后的数值了。

6. C。解释如下，先分别求这六个数的余7后的结果，分别为3,4,4,0,3,6。列出一个表格，如下所示：

位置

记录

查找次数

38的余数是3，所以放在3号位置对应的记录里，25放在位置4，74求余的结果也是4，这就出现冲突了，线性探测就是往后移一格再存，所以放在5号位置了，按照这个方法依次放置到相应的位置。查找时，比如此时查找52，余数是3，本应位于3号位置，但3号位置被38占了，所以继续向后查找，4号位置没有，5号位置也没有，6号位置才查到，所以查找次数就是4次了。平均查找长度就是各数查找次数之和/6。

7. C。后缀形式，复习一下，其实不难的，注意运算优先级，”＝”应是最后做的。

8. B。看看设计模式的书。

9. 6,5,4,4。第一个是求数组的大小，不要忘了’\0’，第二个是求字符串长度，注意strlen返回的长度是不包括’\0’的，指针的sizeof都是4字节（32位系统）。函数中形参虽是数组的形式，但实际传入的是指针（数组首地址），所以后面[100]其实没有用，还是4字节。

10. A。虚析构函数，C++多态。

11. D。

12. 4,5。同第9题解释，函数中的[2]其实是没有用的，因为只传数组首地址，就是指针，所以sizeof(指针)=4（32位系统），求strlen时是遇’\0’停止计数的，且不包括’\0’，所以是5。

13. 前者声明一个类型的别名，在编译时处理，有类型检查；后者是一个简单的替换，在预编译时处理，无类型检查。从使用上来说，String_t a,b; a和b都是char*类型的，但String_d a,b;只有a是char*类型的，b是char型的。

14. 需要自己去完善条件。比如优惠券本次消费是否就可以使用，还是要等到下次消费才可用，优惠券在消费多少时才可以使用等。举个简单的例子，比如只能下次消费使用，且满200才可以使用其中的50元优惠券，这样实际折扣为（200+200-50）/400＝8.9折，继续买下去，折扣可以在8折左右。

15.如下：

1int rand10()

2 {

3int temp;

4int temp2;

5do

6 {

7 temp = rand7();

8 }while (temp > 5);//temp 1到5

9do

10 {

11 temp2 = rand7();

12while (temp2 >2);//temp2 1到2

13return temp + (temp2 -1) * 5;

14 }

16. 解法同15。

17. 最后一个必是2/2＝1，前一个也必是4/2＝2，再往前可以自己推几个，可以发现从9th到5th间隔内的分叉数依次是0,1,1,2,3,5，每次分叉就会多出一个可能的数，找规律可以推测是Fabbonaci数列，所以结果应该1+1+2+3+5+8+13＝33，别忘了即使是0分叉也包含了自身一个数，所以最终结果是34。

排序法

最差时间分析

平均时间复杂度

稳定度

空间复杂度

冒泡排序

O(n²)

稳定

O(1)

快速排序

O(n²)

O(n*log₂n)

不稳定

O(log₂n)~O(n)

选择排序

O(n²)

稳定

O(1)

二叉树排序

O(n²)

O(n*log₂n)

不一顶

O(n)

插入排序

O(n²)

稳定

O(1)

堆排序

O(n*log₂n)

不稳定

O(1)

希尔排序

不稳定

O(1)

一、单选题

12．设有5000个无序的元素，希望用最快的速度挑选出其中前50个最大的元素，最好选用( )法。

A．冒泡排序 B．快速排序 C．堆排序 D．归并排序

1．已知持排序的n个元素可分为n/k个组，每个组包含k个元素，各组间分块有序，若采用基于比较的排序，其时间下界应为：( )

A．O(nlog₂n) B．O(nlog₂k) C．O(klog₂n) D．O(klog₂k)

2．最好和最坏时间复杂度均为O( )且稳定的排序方法是( )。

A．快速排序 B．堆排序 C．归并排序 D．基数排序

3．下列排序算法中，当初始数据有序时，花费时间反而最多的是( )。

A．起泡排序 B．希尔排序 C．堆排序 D．快速排序

4．若需在O（nlog₂n）的时间内完成排序，且要求稳定，则可选择（）

A．快速排序 B．堆排序 C．归并排序 D．直接插入排序

5．排序趟数与序列的原始状态有关的排序方法是( )排序法。

A．插入 B．选择 C．希尔 D．快速

6．已知数据表每个元素距离其最终位置不远，则最省时间的排序算法是( )。

A．堆排序 B．直接插入排序 C．快速排序 D．直接选择排序

7．关键字比较次数与数据的初始状态无关的排序算法是( )。

A．直接选择排序 B．冒泡排序 C．直接插入排序 D．希尔排序

8. 若一个元素序列基本有序，则选用（）方法较快。

A．直接插入排序 B．直接选择排序 C．堆排序 D．快速排序

9. 若要从1000个元素中得到4个最小值元素，最好采用（）方法。

A．直接插入排序 B．直接选择排序 C．堆排序 D．快速排序

10. 若要对1000个元素排序，要求既快又稳定，则最好采用（）方法。

A．直接插入排序 B．归并排序 C．堆排序 D．快速排序

11. 若要对1000个元素排序，要求既快又节省存储空间，则最好采用（）方法。

A．直接插入排序 B．归并排序 C．堆排序 D．快速排序

12. 在下列排序方法中，空间复杂性为O(log₂n)的方法为（）。

A．直接选择排序 B．归并排序 C．堆排序 D．快速排序

13. 在平均情况下速度最快的排序方法为（）。

A．直接选择排序 B．归并排序 C．堆排序 D．快速排序

14、设有关键字初始序列{Q,H,C,Y,P,A,M,S,R,D,F,X}，则用下列哪种排序方法进行第一趟扫描的结果为{F,H,C,D,P,A,M,Q,R,S,Y,X}？

A．直接插入排序 B．二路归并排序

C．以第一元素为基准的快速排序 D．基数排序

15．从未排序序列中依次取出一个元素与已排序序列中的元素依次进行比较，然后将其放在已排序序列的合适位置，该排序方法称为( )排序法。

A．插入 B．选择 C．希尔 D．二路归并

16．下面排序法中，( )排序法是不稳定的。

A．插入 B．冒泡 C．二路归并 D．堆

17.下列排序方法中，不稳定的是（）

A．直接插入排序 B．冒泡排序 C．归并排序 D．直接选择排序

18. 在直接插入排序的第i趟排序前，有序表中的元素个数为（）。

A．i B．i+1 C．i-1 D．1

19. 在直接插入排序的第i趟排序时，为寻找插入位置最多需要进行（）次元素的比较，假定第0号元素作监视哨。

A．i B．i-1 C．i+1 D．1

20. 若对n个元素进行直接插入排序，在进行第i趟排序时，假定元素r[i+1]的插入位置为r[j]，则需要移动元素的次数为（）。

A．j-i B．i-j-1 C．i-j D．i-j+1

21. 对n个元素进行直接插入排序，则各趟排序中寻找插入位置的平均时间复杂性为（）。

A．O(1) B．O(n) C．O(n²) D．O(log₂n)

22. 在对n个元素进行直接插入排序的过程中，共需要进行（）趟。

A．n B．n+1 C．n-1 D．2n

23. 对n个元素进行直接插入排序时间复杂性为（）。

A．O(1) B．O(n) C．O(n²) D．O(log₂n)

24、n个记录直接插入排序时所需的记录最小比较次数是( )

A．n-1 B．n C．n(n-1)/2 D．n(n+1)/2

25. 对n个元素进行直接插入排序，空间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

26. 对n个元素进行冒泡排序，第一趟至多需要进行（）对相邻元素之间的交换。

A．n B．n-1 C．n+1 D．n/2

27. 对n个元素进行冒泡排序，最好情况下的时间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(n)

28. 对n个元素进行冒泡排序，至少需要（）趟完成。

A．1 B．n C．n-1 D．n/2

6．快速排序的记录移动次数（）比较次数，其总执行时间为0（nlog2n）。

A）大于 B）大于等于 C）小于等于 D）小于

29. 对n个元素进行快速排序，第一次划分最多需要移动（）次元素，假定包括基准和临时量之间的移动。

A．n/2 B．n-1 C．n D．n+1

30.对序列（3, 7, 5, 9, 1）进行快速排序，则第一次划分时需要移动元素的次数为（），假定不包括基准和临时量之间的移动。

A．1 B．2 C．3 D．4

31. 对n个元素进行快速排序，最好情况下需要进行（）趟。

A．n B．n/2 C．log₂n D．2n

32. 对n个元素进行快速排序，最坏情况下需要进行（）趟。

A．n B．n-1 C．n/2 D．log₂n

33. 对n个元素进行快速排序，平均情况下的时间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

34. 对n个元素进行快速排序，最坏情况下的时间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

35. 对n个元素进行快速排序，平均情况下的空间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

36. 对n个元素进行快速排序，最坏情况下的空间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

37. 对下列四个序列进行快速排序，各以第一个元素为基准进行第一次划分，则在该次划分过程中需要移动元素次数最多的序列为（）。

A．1, 3, 5, 7, 9 B． 9, 7, 5, 3, 1 C．5, 3, 1, 7, 9 D．5, 7, 9, 1, 3

38. 假定对元素序列（7, 3, 5, 9, 1, 12, 8, 15）进行快速排序，则进行第一次划分后，得到的左区间中元素的个数为（）。

A．2 B．3 C．4 D．5

39．对n个元素进行直接选择排序，需要进行（）趟选择和交换。

A．n B．n+1 C．n-1 D．n/2

40．对n个元素进行直接选择排序，在第i趟需要从（）个元素中选择最小者。

A．n-i+1 B．n-I C．I D．i+1

41. 对n个元素进行直接选择排序，则各趟寻找最小值元素所需时间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(n)

5．堆排序在最坏情况下，其时间复杂性为（）。

A） B） C） D）

42. 对n个元素进行堆排序，在构成初始堆的过程中需要进行（）次筛运算。

A．1 B．n/2 C．n D．n-1

43. 对n个元素进行堆排序，建初始堆后，还要进行( )次筛选运算。

A．n+1 B．n/2 C．n D．n-1

44. 对n个元素进行堆排序，每次筛运算的时间复杂性为( )。

A．O(1) B．O(log₂n) C．O(n²) D．O(n)

45. 对n个元素进行堆排序，时间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

46. 对n个元素进行堆排序，空间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n²) D．O(nlog₂n)

12．对排序码(47、78、61、33、39、80)用堆排序的方法建立的初始堆为( )。

A．78、47、61、33、39、80 B．80、78、61、33、39、47

C．80、78、61、47、39、33 D．80、61、78、39、47、33

47. 假定用小根堆对（7, 3, 5, 9, 1, 12）进行堆排序，则初始堆为（）。

A．1, 3, 5, 7, 9, 12 B．1, 3, 5, 9, 7, 12

C．1, 5, 3, 7, 9, 12 D．1, 5, 3, 9, 12, 7

48. 假定初始堆为(1, 5, 3, 9, 12, 7, 15,10)，则第一趟堆排序后的结果为（）。

A．3, 5, 7, 9, 12, 10, 15,1 B．3, 5, 9, 7, 12, 10, 15,1

A．3, 7, 5, 9, 12, 10, 15,1 B．3, 5, 7, 12, 9, 10, 15,1

49．将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（）

A．n B．2n－1 C．2n D．n-1

50. 若对n个元素进行归并排序，则进行归并的趟数为（）。

A．n B．n-1 C．n/2 D．élog₂nù

51. 若对n个元素进行归并排序，则进行每一趟归并的时间复杂性为（）。

A．O(1) B．O(log₂n) C．O(n) D．O(n²)

二、判断题

如果某种排序算法是不稳定的，则该方法没有实际的应用价值。

对数据按关键字进行排序能够有效地提高查找速度。

直接插入排序是稳定的，而Shell排序就是调用若干趟直接插入排序，所以也是稳定的。

用直接选择排序方法分别对序列S1=(1,2,3,4,5,6,7)和序列S2=(7,5,3,2,4,1,6)进行排序，两者的比较次数不相同。

直接选择排序的比较次数与序列的初始状态无关。

堆排序法在最好和最坏情况下时间复杂性都是O(nlog₂n)。

堆的存储表示是顺序的。

以中序方式遍历一个堆，则得到一个有序序列。

二路归并排序的核心操作是把两个有序序列合并为一个有序序列。

快速排序法总是效率最高的排序法。

顾名思义，快速排序法是在所有情况下，速度最快的排序方法。

三、填空题

11．最简单的交换排序方法是________________排序。

11．直接插入排序需要___________个记录的辅助空间。

12．在插入和选择排序中，若初始数据基本正序，则选用___________；若初始数据基本反序，则选用___________。

1．评价排序效率的主要标准是________。

2．在时间复杂性为O(n²)的所有排序方法中，____直接选择____排序方法是不稳定的。

3．在所有排序方法中，____快速____排序方法采用的是二分法的思想。

4．在所有排序方法中，____堆排序____方法使数据的组织采用的是完全二叉树的结构。

5．在所有排序方法中，____归并排序____方法采用的是两两有序表合并的思想。

3．采用冒泡排序对有n个记录的表A按键值递增排序，若L的初始状态是按键值递增，则排序过程中记录的比较次数为____3___。若A初始状态为递减排列，则记录的交换次数为____4___。

6．____冒泡____排序方法使键值大的记录逐渐下沉，使键值小的记录逐渐上浮。

7．____直接插入____排序方法能够每次使无序表中的第一个记录插入到有序表中。

8．____直接选择____排序方法能够每次从无序表中顺序查找出一个最小值。

9．每次从无序表中取出一个元素，把它插入到有序表中的适当位置，此种排序方法叫做__插入__排序；每次从无序表中挑选出一个最小或最大元素，把它交换到有序表的一端，此种排序方法叫做__选择__排序。

10．每次直接或通过基准元素间接比较两个元素，若出现逆序排列时就交换它们的位置，此种排序方法叫做__交换__排序；每次使两个相邻的有序表合并成一个有序表的排序方法叫做__归并__排序。

11．对n个数据进行直接插入排序，最少比较次数为_________。

12. 若对一组记录(46,79,56,38,40,80,35,50,74)进行直接插入排序，当把第8个记录插入到前面已排序的有序表时，为寻找插入位置需比较____4____次。

13．取增量为3，对记录(46,79,56,38,40,80,35,50,74)进行一趟希尔排序的结果为＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿。

14. 对n个记录进行冒泡排序时，最多比较次数为_______、最少的比较次数为__ n-1__，最少的趟数为____1___。

15．用起泡法对n个关键码排序，在最好情况下，只需做 n-1 次比较和 0 次移动；在最坏的情况下要做_________次比较。

16.两个序列：L1={25,57,48,37,92,86,12,33}、L2={25,37,33,12,48,57,86,92}

用冒泡排序方法分别对序列L1和L2进行排序，交换次序较少的是序列____________。

17. 对(46,79,56,38,40,84)进行冒泡排序，第一趟排序后的结果为__(46,56,38,40,79,84)__。

18. 对(46,79,56,64,38,40,84,43)进行冒泡排序，第一趟排序时，元素79将最终下沉到其后第__4__个元素的位置。

19. 快速排序的平均时间复杂性为__O(nlog₂n)__，最坏时间复杂性为____O(n²)____。

20．快速排序的平均空间复杂性为__O(log₂n)__，最坏空间复杂性为____O(n)____。

21．快速排序每次划分时，是从当前待排序区间的__两端__向__中间__依次查找出处于逆序的元素并交换之，最后将基准元素交换到一个确定位置，从而以该位置把当前区间划分为前后两个子区间。

22. 对(46,79,56,38,40,80)进行快速排序，对应判定树的深度为_____，分支结点数为_____。

23. 对(46,79,56,38,40,80)进行快速排序，共需要____3____趟排序。

24. 对(46,79,56,38,40,80)进行快速排序，含有两个或两个以上元素的排序区间的个数为____4____个。

25. 对(46,79,56,25,76,38,40,80)进行快速排序，第一次划分后，右区间内元素的个数为_____4_____。

26．对(46,79,56,38,40,80)进行快速排序，第一次划分后的结果为__[40 38]46[56 79 80]__。

27．在直接选择排序中，记录比较次数的时间复杂度为__O(n²)__，记录移动次数的时间复杂度为__O(n)__。

28. 对记录(46,79,56,38,40,80,35,50,74)进行直接选择排序，用k表示最小值元素的下标，k初值为1，则在第一趟选择最小值的过程中，k的值被修改__2__次。

29. 在堆排序的过程中，对n个记录建立初始堆需要进行__ën/2û__次筛运算，由初始堆到堆排序结束，需要对树根结点进行__n-1__次筛运算。

30．在堆排序的过程中，对任一分支结点进行筛运算的时间复杂性为__O(log₂n) _____，整个堆排序过程的时间复杂性为__O(nlog₂n)__。

31．对n个元素建立初始堆时，最多进行_____次关键字比较。

32．对(46,79,56,38,40,84)进行堆排序，初始小根堆为__(38,40,56,79,46,84)__，大根堆为___________________。

33．对(76,38,62,53,80,74,83,65,85)进行堆排序，已知除第一个元素外，以其余元素为根的子树都已是堆，则对第一个元素进行筛运算时，它将最终被筛到下标为__8__的位置。

34．假定一个堆为(38,40,56,79,46,84)，则利用堆排序方法进行第一趟交换和对根结点筛运算后得到的结果为__(40,46,56,79,84,38)__。

35．在一个堆的顺序存储中，若一个元素的下标为i，则它的左孩子元素的下标为__2i__，右孩子元素的下标为__2i+1__。

36．在一个小根堆中，堆顶结点的值是所有结点中的__最小的__，在一个大根堆中，堆顶结点的值是所有结点中的__最大的__。

37.将长度分别为m和n（m>n）的有序表归并成一个有序表，至少进行__n__次键值比较。

38．在二路归并排序中，对n个记录进行归并的趟数为__élog₂nù__。

39. 在归并排序中，进行每趟归并的时间复杂性为__O(n) __，整个排序过程的时间复杂性为__O(nlog₂n)__，空间复杂性为__O(n)__。

40．对20个记录进行归并排序时，共需要进行__5__趟归并，在第三趟归并时是把长度为__4__的有序表两两归并为长度为__8__的有序表。

41．假定一组记录为(46,79,56,38,40,80,46,75)，对其进行归并排序的过程中，第二趟归并后的第2个子表为__[40 46 75 80]__。

42．假定一组记录为(46,79,56,38,40,80,46,75,28,46)，对其进行归并排序的过程中，第二趟归并后的子表个数为__3__。

43．假定一组记录为(46,79,56,38,40,80,46,75,28,46)，对其进行归并排序的过程中，第三趟归并后的第2个子表为__[28 46]__。

44．假定一组记录为(46,79,56,38,40,80,46,75,28,46)，对其进行归并排序的过程中，供需要__4__趟完成。

45．假定一组记录为(46,79,56,38,40,80)，对其进行归并排序的过程中，第二趟归并后的结果为__[38 46 56 79][40 80]__。

46. 在时间复杂性为O(nlog₂n)的所有排序方法中，__归并__排序方法是稳定的。

四、应用题、综合题

1．试给出由5个数据{1，2，3，4，5}组成的一个序列，使得在快速排序的第一趟划分时，移动次数最多。

2．试给出由5个数据{1，2，3，4，5}组成的一个序列，使得用直接选择排序时，移动次数最多。

3、设有50个值不同的元素存于内存一片连续单元中，若用顺序选择的方法，选出这50个元素的最大值和最小值则至少需要97次比较。请给出另一种选出最大值和最小值的方法，其比较次数一定少于97次，说明该方法的操作过程和比较次数。

4、快速排序在什么情况下，所需记录之关键码的比较次数为最多？此时记录之关键码比较次数应为多少？

5. 已知一组记录为(46,74,53,14,26,38,86,65,27,34)，给出采用直接插入排序法进行排序时每一趟的排序结果。

(0) [46] 74 53 14 26 38 86 65 27 34

(1) [46 74] 53 14 26 38 86 65 27 34

(2) [46 53 74]14 26 38 86 65 27 34

(3) [14 46 53 74] 26 38 86 65 27 34

(4) [14 26 46 53 74] 38 86 65 27 34

(5) [14 26 38 46 53 74]86 65 27 34

(6) [14 26 38 46 53 74 86] 65 27 34

(7) [14 26 38 46 53 65 74 86] 27 34

(8) [14 26 27 38 46 53 65 74 86]34

(9) [14 26 27 34 38 46 53 65 74 86]

6. 已知一组记录为(46,74,53,14,26,38,86,65,27,34)，给出采用冒泡排序法进行排序时每一趟的排序结果。

(0) [46 74 53 14 26 38 86 65 27 34]

(1) [46 53 14 26 38 74 65 27 34]86

(2) [46 14 26 38 53 65 27 34] 74 86

(3) [14 26 38 46 53 27 34] 65 74 86

(4) [14 26 38 46 27 34]53 65 74 86

(5) [14 26 38 27 34]46 53 65 74 86

(6) [14 26 27 34] 38 46 53 65 74 86

(7) [14 26 27 34] 38 46 53 65 74 86

7. 已知一组记录为(46,74,53,14,26,38,86,65,27,34)，给出采用快速排序法进行排序时每一趟的排序结果。

(0) [46 74 53 14 26 38 86 65 27 34]

(1) [34 27 38 14 26]46 [86 65 53 74]

(2) [26 27 14]34 38 46 [74 65 53] 86

(3) 14 26 27 34 38 46 [53 65] 74 86

(4) 14 26 27 34 38 46 53 65 74 86

8. 已知一组记录为(46,74,53,14,26,38,86,65,27,34)，给出采用直接选择排序法进行排序时每一趟的排序结果。

(0) [46 74 53 14 26 38 86 65 27 34]

(1) 14 [74 53 46 26 38 86 65 27 34]

(2) 14 26[53 46 74 38 86 65 27 34]

(3) 14 26 27 [46 74 38 86 65 53 34]

(4) 14 26 27 34 [74 38 86 65 53 46]

(5) 14 26 27 34 38[74 86 65 53 46]

(6) 14 26 27 34 38 46 [86 65 53 74]

(7) 14 26 27 34 38 46 53 [65 86 74]

(8) 14 26 27 34 38 46 53 65 [86 74]

(9) 14 26 27 34 38 46 53 65 74 [86]

9. 已知一组记录为(46,74,53,14,26,38,86,65,27,34)，给出采用堆排序法进行排序时每一趟的排序结果。

构成初始堆（即建堆）的过程：

1 2 3 4 5 6 7 8 9 10

(0) 46 74 53 14 26 38 86 65 27 34

(1) 46 74 53 14 26 38 86 65 27 34

(2) 46 74 53 14 26 38 86 65 27 34

(3) 46 74 38 14 26 53 86 65 27 34

(4) 46 14 38 27 26 53 86 65 74 34

(5) 14 26 38 27 34 53 86 65 74 46

进行堆排序的过程：

(0) 14 26 38 27 34 53 86 65 74 46

(1) 26 27 38 46 34 53 86 65 74 [14]

(2) 27 34 38 46 74 53 86 65[26 14]

(3) 34 46 38 65 74 53 86 [27 26 14]

(4) 38 46 53 65 74 86 [34 27 26 14]

(5) 46 65 53 86 74[38 34 27 26 14]

(6) 53 65 74 86 [46 38 34 27 26 14]

(7) 65 86 74 [53 46 38 34 27 26 14]

(8) 74 86[65 53 46 38 34 27 26 14]

(9) 86 [74 65 53 46 38 34 27 26 14]

10. 已知一组记录为(46,74,53,14,26,38,86,65,27,34)，给出采用归并排序法进行排序时每一趟的排序结果。

(0)[46][74][53][14][26][38][86][65][27][34]

(1) [46 74][14 53][26 38][65 86][27 34]

(2) [14 46 53 74][26 38 65 86][27 34]

(3) [14 26 38 46 53 65 74 86][27 34]

(3) [14 26 27 34 38 46 53 65 74 86]

09信管《数据结构》单元测验四

一、填空题

1. 在数据的存放无规律而言的线性表中进行检索的最佳方法是顺序查找（线性查找）。

2. 线性有序表（a₁，a₂，a₃，…，a₂₅₆)是从小到大排列的，对一个给定的值k，用二分法检索表中与k相等的元素，在查找不成功的情况下，最多需要检索 8 次。设有100个结点，用二分法查找时，最大比较次数是 7 。

3. 假设在有序线性表a[20]上进行折半查找，则比较一次查找成功的结点数为1；比较两次查找成功的结点数为 2 ；比较四次查找成功的结点数为 8 ；平均查找长度为 3.7 。

4．折半查找有序表（4，6，12，20，28，38，50，70，88，100），若查找表中元素20，它将依次与表中元素 28，6，12，20 比较大小。

5. 在各种查找方法中，平均查找长度与结点个数n无关的查找方法是散列查找。

6. 散列法存储的基本思想是由关键字的值决定数据的存储地址。

7. 有一个表长为m的散列表，初始状态为空，现将n（n<m）个不同的关键码插入到散列表中，解决冲突的方法是用线性探测法。如果这n个关键码的散列地址都相同，则探测的总次数是 n(n-1)/2

8. 大多数排序算法都有两个基本的操作：比较和移动。

9. 在对一组记录（54，38，96，23，15，72，60，45，83）进行直接插入排序时，当把第7个记录60插入到有序表时，为寻找插入位置至少需比较 6 次。

10. 在插入和选择排序中，若初始数据基本正序，则选用插入；若初始数据基本反序，则选用选择。

11. 在堆排序和快速排序中，若初始记录接近正序或反序，则选用堆排序；若初始记录基本无序，则最好选用快速排序。

12. 对于n个记录的集合进行冒泡排序，在最坏的情况下所需要的时间是 O(n²) 。若对其进行快速排序，在最坏的情况下所需要的时间是 O(n²) 。

13. 对于n个记录的集合进行归并排序，所需要的平均时间是 O(nlog₂n)

，所需要的附加空间是 O(n) 。

14．对于n个记录的表进行2路归并排序，整个归并排序需进行┌log₂n┐ 趟（遍）。15. 设要将序列（Q, H,C, Y, P, A, M, S, R, D, F, X）中的关键码按字母序的升序重新排列，则：

冒泡排序一趟扫描的结果是 H C Q P A M S R D F X Y ；

初始步长为4的希尔（shell）排序一趟的结果是P A C S Q D F X R H M Y ；

二路归并排序一趟扫描的结果是 H Q C Y A P M S D R F X；

快速排序一趟扫描的结果是 F H C D P A M Q R S Y X ；（以Q为基准）

堆排序初始建堆的结果是 A D C R F Q M S Y P H X 。（小根堆）

16. 在堆排序、快速排序和归并排序中，

若只从存储空间考虑，则应首先选取堆方法，其次选取快速排序方法，最后选取归并排序方法；

若只从排序结果的稳定性考虑，则应选取归并排序方法；

若只从平均情况下最快考虑，则应选取快速排序方法；

若只从最坏情况下最快并且要节省内存考虑，则应选取堆排序方法。

二、单项选择题

（ B ）1．在表长为ｎ的链表中进行线性查找，它的平均查找长度为

Ａ. ＡＳＬ＝ｎ; Ｂ. ＡＳＬ＝（ｎ＋１）／２;

Ｃ. ＡＳＬ＝＋１; Ｄ. ＡＳＬ≈ｌｏｇ_２（ｎ＋１）－１

（ A ）2．折半查找有序表（4，6，10，12，20，30，50，70，88，100）。若查找表中元素58，则它将依次与表中比较大小，查找结果是失败。

A．20，70，30，50 B．30，88，70，50 C．20，50 D．30，88，50

（ C ）3．对22个记录的有序表作折半查找，当查找失败时，至少需要比较次关键字。

A．3 B．4 C．5 D． 6

（ A ）4. 链表适用于查找

A．顺序 B．二分法 C．顺序，也能二分法 D．随机

（C ）5. 折半搜索与二叉搜索树的时间性能

A. 相同 B. 完全不同 C. 有时不相同 D. 数量级都是O（log₂n）

6．从供选择的答案中，选出应填入下面叙述？内的最确切的解答，把相应编号写在答卷的对应栏内。

要进行线性查找，则线性表 A ；要进行二分查找，则线性表 B ；要进行散列查找，则线性表 C 。

某顺序存储的表格，其中有90000个元素，已按关键项的值的上升顺序排列。现假定对各个元素进行查找的概率是相同的，并且各个元素的关键项的值皆不相同。当用顺序查找法查找时，平均比较次数约为 D ，最大比较次数为 E 。

供选择的答案：

A~C：①必须以顺序方式存储 ② 必须以链表方式存储 ③必须以散列方式存储

④ 既可以以顺序方式，也可以以链表方式存储

⑤必须以顺序方式存储且数据元素已按值递增或递减的次序排好

⑥必须以链表方式存储且数据元素已按值递增或递减的次序排好

D，E： ① 25000 ② 30000 ③ 45000 ④ 90000

答案： A= ④ B= ⑤ C= ③ D＝ ③ E＝ ④

7.从供选择的答案中，选出应填入下面叙述？内的最确切的解答，把相应编号写在答卷的对应栏内。

数据结构反映了数据元素之间的结构关系。链表是一种 A ，它对于数据元素的插入和删除 B 。通常查找线性表数据元素的方法有 C 和 D 两种方法，其中 C 是一种只适合于顺序存储结构但 E 的方法；而 D 是一种对顺序和链式存储结构均适用的方法。

供选择的答案：

A：①顺序存储线性表 ②非顺序存储非线性表 ③顺序存储非线性表 ④非顺序存储线性表

B： ①不需要移动结点，不需改变结点指针 ②不需要移动结点，只需改变结点指针

③只需移动结点，不需改变结点指针 ④既需移动结点，又需改变结点指针

C：①顺序查找 ②循环查找 ③条件查找 ④二分法查找

D：①顺序查找 ②随机查找 ③二分法查找 ④分块查找

E：①效率较低的线性查找 ②效率较低的非线性查找

③ 效率较高的非线性查找 ④效率较高的线性查找

答案：A＝ ④ B＝ ② C＝ ④ D＝ ① E＝ ③

8. 从供选择的答案中，选出应填入下面叙述？内的最确切的解答，把相应编号写在答卷的对应栏内。

在二叉排序树中，每个结点的关键码值 A ， B 一棵二叉排序，即可得到排序序列。同一个结点集合，可用不同的二叉排序树表示。

供选择的答案

A：①比左子树所有结点的关键码值大，比右子树所有结点的关键码值小

②比左子树所有结点的关键码值小，比右子树所有结点的关键码值大

③比左右子树的所有结点的关键码值都大

④与左子树所有结点的关键码值和右子树所有结点的关键码值无必然的大小关系

B: ①前序遍历 ②中序（对称）遍历 ③ 后序遍历 ④层次遍历

答案：A＝ ① B＝ ②

9. 从供选择的答案中，选出应填入下面叙述？内的最确切的解答，把相应编号写在答卷的对应栏内。

散列法存储的基本思想是根据 A 来决定 B ，碰撞（冲突）指的是 C ，处理碰撞的两类主要方法是 D 。

供选择的答案

A，B： ①存储地址 ②元素的符号 ③ 元素个数 ④关键码值

⑤ 非码属性 ⑥平均检索长度 ⑦ 负载因子 ⑧散列表空间

C: ①两个元素具有相同序号 ②两个元素的关键码值不同，而非码属性相同

③ 不同关键码值对应到相同的存储地址 ④负载因子过大 ⑤ 数据元素过多

D：① 线性探查法和双散列函数法 ②建溢出区法和不建溢出区法

③ 除余法和折叠法 ④拉链法和开地址法

答案：A＝ ④ B＝ ① C＝ ③ D＝ ④

10.考虑具有如下性质的二叉树：除叶子结点外，每个结点的值都大于其左子树上的一切结点的值。并小于等于其右子树上的一切结点的值。

现把9个数1，2，3，…，8，9填入右图所示的二叉树的9个结点中，并使之具有上述性质。此时，n1的值是 A ，n2的值是 B ，n9的值是 C 。现欲把放入此树并使该树保持前述性质，增加的一个结点可以放在 D 或 E 。

供选择的答案

A～C：①1 ② 2 ③ 3 ④ 4 ⑤ 5 ⑥ 6 ⑦ 7 ⑧ 8 ⑨ 9

D～E： ① n7下面 ② n8下面 ③ n9下面 ④ n6下面

⑤ n1与n2之间 ⑥ n2与n4之间 ⑦ n6与n9之间 ⑧ n3与n6之间

答案：A＝ ⑦ B＝ ④ C＝ ⑥ D＝ ② E＝ ⑥

（ C ）11．将5个不同的数据进行排序，至多需要比较次。

Ａ. 8 Ｂ. 9 Ｃ. 10 Ｄ. 25

（ C ）12．排序方法中，从未排序序列中依次取出元素与已排序序列（初始时为空）中的元素进行比较，将其放入已排序序列的正确位置上的方法，称为

Ａ. 希尔排序Ｂ. 冒泡排序Ｃ. 插入排序Ｄ. 选择排序

（ D ）13．从未排序序列中挑选元素，并将其依次插入已排序序列（初始时为空）的一端的方法，称为

Ａ. 希尔排序Ｂ. 归并排序Ｃ. 插入排序Ｄ. 选择排序

（ B ）14．对ｎ个不同的排序码进行冒泡排序（递增），在下列哪种情况下比较的次数最多。

Ａ. 从小到大排列好的Ｂ. 从大到小排列好的Ｃ. 元素无序Ｄ. 元素基本有序

（ D ）15．对ｎ个不同的排序码进行冒泡排序，在元素无序的情况下比较的次数为

Ａ. n+1 Ｂ. n Ｃ. n-1 Ｄ. n(n-1)/2

（ C ）16．快速排序在下列哪种情况下最易发挥其长处。

Ａ. 被排序的数据中含有多个相同排序码Ｂ. 被排序的数据已基本有序

Ｃ. 被排序的数据完全无序Ｄ. 被排序的数据中的最大值和最小值相差悬殊

（ B ）17．对有n个记录的表作快速排序，在最坏情况下，算法的时间复杂度是

A．O(n) B．O(n²) C．O(nlog₂n) D．O(n³)

（ C ）18．若一组记录的排序码为（46,79, 56, 38, 40, 84），则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为

Ａ. 38, 40, 46, 56, 79, 84 Ｂ. 40, 38, 46 , 79, 56, 84

Ｃ. 40, 38，46, 56, 79, 84 Ｄ. 40, 38, 46, 84, 56, 79

（ D ）19．下列关键字序列中，是堆。

Ａ. 16, 72, 31, 23, 94, 53 Ｂ. 94, 23, 31, 72, 16, 53

Ｃ. 16, 53, 23, 94，31, 72 Ｄ. 16, 23, 53, 31, 94, 72

（ B ）20．堆是一种排序。

Ａ. 插入Ｂ.选择Ｃ. 交换Ｄ. 归并

（ C ）21．堆的形状是一棵

Ａ. 二叉排序树Ｂ.满二叉树Ｃ. 完全二叉树Ｄ. 平衡二叉树

（ B ）22．若一组记录的排序码为（46,79, 56, 38, 40, 84），则利用堆排序的方法建立的初始（大根）堆为

Ａ. 79, 46, 56, 38, 40, 84 Ｂ. 84, 79,56, 38, 40, 46

Ｃ. 84, 79, 56, 46, 40, 38 Ｄ. 84, 56,79, 40, 46, 38

（ C ）23．下述几种排序方法中，要求内存最大的是

Ａ. 插入排序Ｂ.快速排序Ｃ. 归并排序Ｄ. 选择排序

三、简答题

1.假定对有序表：（3，4，5，7，24，30，42，54，63，72，87，95）进行折半查找，试回答下列问题：

（1）画出描述折半查找过程的判定树；

（2）若查找元素54，需依次与哪些元素比较？

（3）若查找元素90，需依次与哪些元素比较？

（4）假定每个元素的查找概率相等，求查找成功时的平均查找长度。

解：

（1）先画出判定树如下（注：mid=ë(1+12)/2û=6）：

5 63

3 7 42 87

4 24 54 72 95

(2) 查找元素54，需依次与30, 63,42, 54比较；

(3) 查找元素90，需依次与30,63,87, 95比较；

（4）求ASL之前，需要统计每个元素的查找次数。判定树的前3层共查找1＋2×2＋4×3=17次；

但最后一层未满，不能用8×4，只能用5×4=20次，

所以ASL＝1/12（17＋20）＝37/12≈3.08

2.设哈希（Hash）表的地址范围为0～17，哈希函数为：H（K）＝K MOD 16。

K为关键字，用线性探测法再散列法处理冲突，输入关键字序列：

（10，24，32，17，31，30，46，47，40，63，49）

造出Hash表，试回答下列问题：

（1）画出哈希表的示意图；

（2）若查找关键字63，需要依次与哪些关键字进行比较？

（3）若查找关键字60，需要依次与哪些关键字比较？

（4）假定每个关键字的查找概率相等，求查找成功时的平均查找长度。

解：（1）画表如下：

（2）查找63,首先要与H(63)=63%16=15号单元内容比较，即63 vs 31 ,no;

然后顺移，与46,47,32,17,63相比，一共比较了6次！

（3）查找60,首先要与H(60)=60%16=12号单元内容比较，但因为12号单元为空（应当有空标记），所以应当只比较这一次即可。

（4）ASL=1/11（6+6＋2＋3×3）＝23/11

四、分析题1. 画出对长度为10的有序表进行折半查找的判定树，并求其等概率时查找成功的平均查找长度。

解：判定树应当描述每次查找的位置：

2 8

1 3 6 9

4 7 10

2.在一棵空的二叉查找树中依次插入关键字序列为12，7，17，11，16，2，13，9，21，4，请画出所得到的二叉查找树。

答：

7 17

2 11 16 21

4 9 13

验算方法：用中序遍历应得到排序结果： 2,4,7,9,11,12,13,16,17，21

3.已知如下所示长度为12的表：

（Jan, Feb, Mar, Apr, May, June, July, Aug, Sep, Oct, Nov, Dec）

(1) 试按表中元素的顺序依次插入一棵初始为空的二叉排序树，画出插入完成之后的二叉排序树，并求其在等概率的情况下查找成功的平均查找长度。

(2) 若对表中元素先进行排序构成有序表，求在等概率的情况下对此有序表进行折半查找时查找成功的平均查找长度。

Jan

Feb

Apr

Aug

Dec

Mar

June

May

Sep

Oct

Nov

July

解：ASL=(1+2x2+3x3+4x3+5x2+6x1)/12=3.5

4. 选取散列函数H（key）=（3*key）%11，用链地址法处理冲突，对下列关键码序列构造一个散列地址空间为0～10，表长为11的散列表，{22，41，53，08，46，30，01，31，66}。

解：由题意知，m=11(刚好为素数)

∧

一、 基础知识题

10.1 基本概念：内排序，外排序，稳定排序，不稳定排序，顺串，败者树，最佳归并树。

【解答】

⑴内排序和外排序若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序（简称内排序）；反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序（简称外排序）。内部排序适用于记录个数不多的文件，不需要访问外存，而外部排序适用于记录很多的大文件，整个排序过程需要在内外存之间多次交换数据才能得到排序的结果。

⑵稳定排序和不稳定排序假设待排序记录中有关键字K_i=K_j（i≠j），且在排序前的序列中R_i领先于R_j。经过排序后，R_i与R_j的相对次序保持不变（即R_i仍领先于R_j），则称这种排序方法是稳定的，否则称之为不稳定的。

⑶顺串外部排序通常经过两个独立的阶段完成。第一阶段，根据内存大小，每次把文件中一部分记录读入内存，用有效的内部排序方法（如快速排序、堆排序等）将其排成有序段，这有序段又称顺串或有序归并段。

⑷败者树败者树是为提高外部排序的效率而采用的，是由参加比赛的n个元素作叶子结点而得到的完全二叉树。每个非叶（双亲）结点中存放的是两个子结点中的败者数据,而让胜者去参加更高一级的比赛。另外,还需增加一个结点,即结点0,存放比赛的全局获胜者。

⑸最佳归并树在外部排序的多路平衡归并的k叉树中，为了提高效率减少对外存的读写次数，按哈夫曼树构造的k叉树称最佳归并树。这棵树中只有度为0和度为k的结点。若用m表示归并段个数，用n_k表示度为k的个数，若(m-1)%(k-1)=0，则不需增加虚段，否则应附加k-(m-1)%(k-1)-1个虚段（即第一个k路归并使用(m-1)%(k-1)+1个归并段）。

10.2 设待排序的关键字序列为(15， 21， 6， 30， 23， 6′， 20， 17)，试分别写出使用以下排序方法每趟排序后的结果。并说明做了多少次比较。

(1) 直接插入排序 (2) 希尔排序(增量为5，2，1) (3)起泡排序

(4) 快速排序 (5) 直接选择排序 (6) 锦标赛排序

(7) 堆排序 (8) 二路归并排序 (9) 基数排序

【解答】

(1) 直接插入排序

初始关键字序列： 15，21，6，30，23，6′，20，17

第一趟直接插入排序：【15，21】

第二趟直接插入排序：【6，15，21】

第三趟直接插入排序：【6，15，21，30】

第四趟直接插入排序：【6，15，21，23，30】

第五趟直接插入排序：【6，6′，15，21，23，30】

第六趟直接插入排序：【6，6′，15，20，21，23，30】

第七趟直接插入排序：【6，6′，15，17，20，21，23，30】

(2)希尔排序(增量为5，2，1)

初始关键字序列： 15，21，6，30，23，6′，20，17

第一趟希尔排序： 6′，20，6，30，23，15，21，17

第二趟希尔排序： 6′，15，6，17，21，20，23，30

第三趟希尔排序： 6′，6，15，17，20，21，23，30

(3) 起泡排序

初始关键字序列：15，21，6，30，23，6′，20，17

第一趟起泡排序：15，6，21，23，6′，20，17，30

第二趟起泡排序：6，15，21，6′，20，17，23，30

第三趟起泡排序：6，15，6′，20，17，21，23，30

第四趟起泡排序：6，6′，15，17，20，21，30，23

第五趟起泡排序：6，6′，15，17，20，21，30，23

(4) 快速排序

初始关键字序列： 15，21，6，30，23，6′，20，17

第一趟快速排序：【6′，6】15【30，23，21，20，17】

第二趟快速排序： 6′，6， 15【17，23，21，20】30

第三趟快速排序： 6′，6， 15，17【23，21，20】30

第四趟快速排序： 6′，6， 15，17，【20，21】23，30

第五趟快速排序： 6，6′，15，17，20，21，30，23

(5) 直接选择排序

初始关键字序列： 15，21，6，30，23，6′，20，17

第一趟直接选择排序： 6，21，15，30，23，6′，20，17

第二趟直接选择排序： 6，6′，15，30，23，21，20，17

第三趟直接选择排序： 6，6′，15，30，23，21，20，17

第四趟直接选择排序： 6，6′，15，17，23，21，20，30

第五趟直接选择排序： 6，6′，15，17，20，21，23，30

第六趟直接选择排序： 6，6′，15，17，20，21，23，30

第七趟直接选择排序： 6，6′，15，17，20，21，23，30

(6) 锦标赛排序

初始关键字序列： 15，21，6，30，23，6′，20，17

锦标赛排序的基本思想是：首先对n个待排序记录的关键字进行两两比较，从中选出én/2ù个较小者再两两比较，直到选出关键字最小的记录为止，此为一趟排序。我们将一趟选出的关键字最小的记录称为“冠军”，而“亚军”是从与“冠军”比较失败的记录中找出，具体做法为：输出“冠军”后，将（冠军）叶子结点关键字改为最大，继续进行锦标赛排序，直到选出关键字次小的记录为止，如此循环直到输出全部有序序列。上面给出了排在前三个的记录，详细过程略。

(7) 堆排序

初始关键字序列：15，21，6，30，23，6′，20，17

初始堆： 6，17，6’，21，23，15，20，30

第一次调堆： 6’，17，15， 21，23，30，20，【6】

第二次调堆： 15，17，20，21，23，30，【6’，6】

第三次调堆： 17，21，20，30，23，【15，6’，6】

第四次调堆： 20，21，23，30，【17，15，6’，6】

第五次调堆： 21，30，23，【20，17，15，6’，6】

第六次调堆： 23，30，【21，20，17，15，6’，6】

第七次调堆： 30，【23，21，20，17，15，6’，6】

堆排序结果调堆：【30，23，21，20，17，15，6’，6】

(8) 二路归并排序

初始关键字序列： 15，21，6，30，23，6′，20，17

二路归并排序结果：15，17，20，21，23，30，6’，6

final↑↑first

(9) 基数排序

初始关键字序列：p→15→21→6→30→23→6′→20→17

第一次分配得到:

B[0].f→30→20←B[0].e

B[1].f→21←B[1].e

B[3].f→23←B[3].e

B[5].f→15←B[5].e

B[6].f→6→6’←B[6].e

B[7].f→17←B[7].e

第一次收集得到:

p→30→20→21→23→15→6→6’→17

第二次分配得到

B[0].f→6→6’←B[0].e

B[1].f→15→17←B[1].e

B[2].f→20→21→23←B[5].e

B[3].f→30←B[3].e

第二次收集得到

p→6→6’→15→17→20→21→23→30

基数排序结果：6，6′，15，17，20，21，23，30

注：每种排序“做了多少次比较”略

10.3 在各种排序方法中，哪些是稳定的？哪些是不稳定的？并为每一种不稳定的排序方法举出一个不稳定的实例。

【解答】见下表：

排序方法

平均时间

最坏情况

辅助空间

稳定性

不稳定排序举例

直接插入排序

O(n²)

O(1)

稳定

折半插入排序

O(n²)

O(1)

稳定

二路插入排序

O(n²)

O(n)

稳定

表插入排序

O(n²)

O(1)

稳定

起泡排序

O(n²)

O(1)

稳定

直接选择排序

O(n²)

O(1)

不稳定

2,2’,1

希尔排序

O(n^1.3)

O(1)

不稳定

3,2,2’,1(d=2,d=1)

快速排序

O(nlog₂n)

O(n²)

O(log₂n)

不稳定

2,2’,1

堆排序

O(nlog₂n)

O(1)

不稳

2,1,1’(极大堆)

2-路归并排序

O(nlog₂n)

O(n)

稳定

基数排序

O(d*(rd+n))

O (rd )

稳定

10.4在执行某种排序算法的过程中出现了排序码朝着最终排序序列相反的方向移动，从而认为该排序算法是不稳定的，这种说法对吗？为什么？

【解答】这种说法不对。因为排序的不稳定性是指两个关键字值相同的元素的相对次序在排序前、后发生了变化，而题中叙述和排序中稳定性的定义无关，所以此说法不对。对4，3，2，1进行起泡排序就可否定本题结论。

10.5 在堆排序、快速排序和归并排序方法中：

(1)若只从存储空间考虑，则应首先选取哪种排序，其次选取哪种排序，最后选取哪种排序？

(2)若只从排序结果的稳定性考虑，则应选取哪种排序方法？

(3)若只从平均情况下排序最快考虑，则应选取哪种排序方法？

(4)若只从最坏情况下排序最快并且要节省内存考虑，则应选取哪种排序方法？

【解答】

(1)堆排序，快速排序，归并排序

(2)若要求稳定排序则选取归并排序

(3)快速排序

(4)堆排序

10.6 设要求从大到小排序。问在什么情况下冒泡排序算法关键字交换的次数为最多。

【解答】对冒泡算法而言，初始序列为反序时交换次数最多。若要求从大到小排序，则表现为初始是上升序时关键字交换的次数为最多。

10.7 快速排序的最大递归深度是多少？最小递归深度是多少？

【解答】设待排序记录的个数为n,则快速排序的最小递归深度为ëlog₂nû+1,最大递归深度n。

10.8 我们知道，对于n个元素组成的顺序表进行快速排序时，所需进行的比较次数与这n个元素的初始排序有关。问：

(1) 当n=7时，在最好情况下需进行多少次比较？请说明理由。

(2) 当n=7时，给出一个最好情况的初始排序的实例。

(3) 当n=7时，在最坏情况下需进行多少次比较？请说明理由。

(4) 当n=7时，给出一个最坏情况的初始排序的实例。

【解答】

(1) 在最好情况下,每次划分能得到两个长度相等的子文件。假设文件的长度n=2^k-1,那么第一遍划分得到两个长度均为ën/2û的子文件,第二遍划分得到4个长度均为ën/4û的子文件,以此类推,总共进行k=log₂(n+1)遍划分,各子文件的长度均为1,排序完毕。当n=7时,k=3,在最好情况下,第一遍需比较6次,第二遍分别对两个子文件（长度均为3,k=2）进行排序,各需2次,共10次即可。

(2) 在最好情况下快速排序的原始序列实例：4,1,3,2,6,5,7。

(3) 在最坏情况下,若每次用来划分的记录的关键字具有最大(或最小)值,那么只能得到左(或右)子文件,其长度比原长度少1。因此,若原文件中的记录按关键字递减次序排列,而要求排序后按递增次序排列时,快速排序的效率与冒泡排序相同,其时间复杂度为O(n²)。所以当n=7时,最坏情况下的比较次数为21次。

(4) 在最坏情况下快速排序的初始序列实例： 7,6,5,4,3,2,1,要求按递增排序。

10.9判断下面的每个结点序列是否表示一个堆，如果不是堆，请把它调整成堆。

(1) 100，90，80，60，85，75，20，25，10，70，65，50

(2) 100，70，50，20，90，75，60，25，10，85，65，80

【解答】

(1) 是堆

(2) 不是堆。调成大堆：100,90,80,25,85,75,60,20,10,70,65,50

10.10 在多关键字排序时，LSD和MSD两种方法的特点是什么？

【解答】

最高位优先（MSD）法：先对最高位关键字K⁰进行排序,将序列分成若干子序列,每个子序列中的记录都具有相同的K⁰值,然后,分别就每个子序列对关键字K¹进行排序,按K¹值不同再分成若干更小的子序列,……,依次重复,直至最后对最低位关键字排序完成,将所有子序列依次连接在一起,成为一个有序子序列。

最低位优先（LSD）法：先对最低位关键字K^d-1进行排序,然后对高一级关键字K^d-2进行排序,依次重复,直至对最高位关键字K⁰排序后便成为一个有序序列。进行排序时,不必分成子序列,对每个关键字都是整个序列参加排序,但对Kⁱ (0<=i<d-1)排序时,只能用稳定的排序方法。另一方面,按LSD进行排序时,可以不通过关键字比较实现排序,而是通过若干次“分配”和“收集”来实现排序。

10.11 给出如下关键字序列321，156，57，46，28，7，331，33，34，63试按链式基数排序方法，列出一趟分配和收集的过程。

【解答】

按LSD法 →321→156→57→46→28→7→331→33→34→63

分配 [0] [1] [2] [3][4] [5] [6] [7] [8] [9]

321 33 34 156 57 28

331 63 46 7

收集 →321→331→33→63→34→156→46→57→7→28

10.12 奇偶交换排序如下所述：对于初始序列A[1]，A[2]，…，A[n]，第一趟对所有奇数i(1<=i<n)，将A[i]和A[i+1]进行比较，若A[i]>A[i+1]，则将两者交换；第二趟对所有偶数i(2<=i<n)，将A[i]和A[i+1]进行比较，若A[i]>A[i+1]，则将两者交换。第三趟对所有奇数i(1<=i<n)；第四趟对所有偶数i(2<=i<n)，…，依次类推直至到整个序列有序为止。

(1) 分析这种排序方法的结束条件。

(2) 写出用这种排序方法对35，70，33，65，24，21，33进行排序时，每一趟的结果。

【解答】

(1) 排序结束条件为，连续的第奇数趟排序和第偶数趟排序都没有交换。

(2)

第一趟奇数：35,70,33,65,21,24,33

第二趟偶数：35,33,70,21,65,24,33

第三趟奇数：33,35,21,70,24,65,33

第四趟偶数：33,21,35,24,70,33,65

第五趟奇数：21,33,24,35,33,70,65

第六趟偶数：21,24,33,33,35,65,70

第七趟奇数：21,24,33,33,35,65,70(无交换)

第八趟偶数：21,24,33,33,35,65,70(无交换)结束

10.13 设某文件经内排序后得到100个初始归并段(初始顺串)，若使用多路归并排序算法，并要求三趟归并完成排序，问归并路数最少为多少？

【解答】 设归并路数为k,归并趟数为s,则s=élog_k100ù。

因élog_k100ù=3,且k为整数，故k=5,即最少5路归并可以完成排序。

10.14 证明：置换-选择排序法产生的初始归并段的长度至少为m。(m是所用缓冲区的长度)。

【证明】由置换选择排序思想,第一个归并段中第一个元素是缓冲区中最小的元素,以后每选一个元素都不应小于前一个选出的元素,故当产生第一个归并段时（即初始归并段）,缓冲区中m个元素中除最小元素之外,其他m-1个元素均大于第一个选出的元素,即使以后读入元素均小于输出元素时,初始归并段中也至少能有原有的m个元素。证毕。

10.15 设有11个长度(即包含记录的个数)不同的初始归并段，它们所包含的记录个数分别为25，40，16，38，77，64，53，88，9，48，98。试根据它们做4路平衡归并，要求：

(1)指出总的归并趟数；

(2)构造最佳归并树；

(3)根据最佳归并树计算每一趟及总的读记录数。

【解答】

因为(11-1)%(4-1)=1,所以加“虚段”,第一次由两个段合并。

(1)三趟归并

(2)最佳归并树如图

(3)设每次读写一个记录

第一趟50次读写

第二趟740次读写

第三趟1112次读写

总的读写次数：1902

[(9+16)*3+(25+38+40)*2+

(48+53+64+77)*2+(88+98)]*2＝1902

10.16 对输入文件(101，51，19，61，3，71，31，17，19，100，55，20，9，30，50，6，90)，当k=6时，使用置换-选择算法，写出建立的初始败者树及生成的初始归并段。

【解答】

初始败者树

初始归并段： R₁:3,19,31,51,61,71,100,101

10.17 选择题：下面给出的四种排序方法中，排序过程中的比较次数与排序方法无关的是。

A．选择排序法 B. 插入排序法 C. 快速排序法 D. 堆排序法

【解答】A

10.18 选择题：一个排序算法的时间复杂度与以下哪项有关。

A．排序算法的稳定性 B. 所需比较关键字的次数

C. 所采用的存诸结构 D. 所需辅助存诸空间的大小

【解答】B

二、算法设计题

10.19 请编写一个算法，在基于单链表表示的关键字序列上进行简单选择排序。

【算法10.19】

void LinkedListSelectSort(LinkedList head);

∥本算法一趟找出一个关键字最小的结点,其数据和当前结点进行交换

{p=head->next;

while(p)

{q=p->next; r=p; ∥设r是指向关键字最小的结点的指针

while(q!=null)

{if(q->data<r->data) r=q;

q=q->next;

}

if (r!=p)r->data<-->p->data;

p=p->next; ∥选下一个最小元素

}

【算法讨论】本算法只交换两个结点的数据，若要交换结点，则须记下当前结点和最小结点的前驱指针

10.20 设单链表头结点指针为L，结点数据为整型。试写出对链表L按“直接插入方法”排序的算法。

【算法10.20】

void LinkInserSort(LinkedList L)

//本算法对单链表L按“直接插入方法”进行排序

{ p=L->next->next; //链表至少一个结点,p初始指向链表中第二结点（若存在）

L->next->next=null; //初始假定第一个记录有序

while(p!=null)

{q=p->next; //q指向p的后继结点}

s=L;

while(s->next!=null&& s->next->data<p->data)

s=s->next; //向后找插入位置

p->next=s->next;

s->next=p; //插入结点

p=q; //恢复p指向当前结点

}

10.21 试设计一个双向冒泡排序算法，即在排序过程中交替改变扫描方向。

【算法10.21】

void BubbleSort2(int a[],int n)∥相邻两趟向相反方向起泡的冒泡排序算法

{change=1;low=0;high=n-1; ∥冒泡的上下界

while(low<high&& change)

{change=0; ∥设不发生交换

for(i=low;i<high;i++) ∥气泡上浮,大元素下沉（向右）

if(a[i]>a[i+1])

{a[i]<-->a[i+1];change=1;}∥有交换,修改标志change

high--; ∥修改上界

for(i=high;i>low;i--) ∥气泡下沉,小元素上浮（向左）

if(a[i]<a[i-1]){a[i]<-->a[i-1];change=1;}

low++; ∥修改下界

}∥while }∥BubbleSort2

10.22 写出快速排序的非递归算法。

【算法10.22】

void QuickSort(rectyper[n+1]，int n)

{∥对r[1..n]进行快速排序的非递归算法

typedef struct{int low,high; }node

node s[n+1]；∥栈,容量足够大

int quickpass(rectype r[],int,int); ∥函数声明

int top=1; s[top].low=1; s[top].high=n;

while(top>0)

{ss=s[top].low;tt=s[top].high; top--;

if(ss<tt)

{k=quickpass(r,ss,tt);

if(k-ss>1) {s[++top].low=ss; s[top].high=k-1;}

if(tt-k>1){s[++top].low=k+1; s[top].high=tt;}

}

} ∥算法结束

int quickpass(rectype r[]，int s, int t)

{i=s; j=t;rp=r[i]; x=r[i].key;

while （i<j）

{while(i<j && r[j].key>=x) j--;

if(i<j) r[i++]=r[j];

while(i<j && r[i].key<=x) i++;

if(i<j) r[j--]=r[i];;

}

r[i]=rp;

return (i);

} ∥一次划分算法结束

[算法讨论]可对以上算法进行两点改进：一是在一次划分后,先处理较短部分,较长的子序列进栈；二是用“三者取中法”改善快速排序在最坏情况下的性能。下面是部分语句片段：

int top=1; s[top].low=1; s[top].high=n;

ss=s[top].low;tt=s[top].high; top--; flag=true;

while(flag|| top>0)

{k=quickpass(r,ss,tt);

if(k-ss>tt-k) ∥一趟排序后分割成左右两部分

{s[++top].low=ss; s[top].high=k-1;∥左部子序列长度大于右部,左部进栈

if(tt-k>1) ss=k+1; ∥右部短的直接处理

else flag=false; ∥右部处理完,需退栈

}

else

{s[++top].low=k+1; s[top].high=tt; ∥右部子序列长度大于左部,右部进栈

if(k-ss>1) tt=k-1 ∥左部短的直接处理

else flag=false ∥左部处理完,需退栈

}

if(!flag && top>0) ∥退栈

{ss=s[top].low;tt=s[top].high; top--; flag=true;}

} ∥ end of while(flag ||top>0)

} ∥算法结束

int quickpass(rectype r[],int s, int t)

∥用“三者取中法”进行快速排序的一次划分

{ int i=s, j=t,mid=(s+t)/2;

rectype tmp;

if(r[i].key>r[mid].key) ∥先将3个位置的值排序

{tmp=r[i];r[i]=r[mid];r[mid]=tmp}

if(r[mid].key>r[j].key)

{tmp=r[j];r[j]=r[mid];

if(tmp>r[i])r[mid]=tmp; else {r[mid]=r[i];r[i]=tmp }

}

{tmp=r[i];r[i]=r[mid];r[mid]=tmp } ∥取中值做枢轴

∥三者取中：最佳2次比较3次赋值；最差3次比较10次赋值

rp=r[i];x=r[i].key;

while（i<j）

{while(i<j && r[j].key>=x) j--;

if(i<j) r[i++]=r[j];

while(i<j && r[i].key<=x) i++;

if(i<j) r[j--]=r[i];;

}

r[i]=rp;

return (i);

} ∥一次划分算法结束

10.23 假设由1000个关键字为小于10000的整数的记录序列，请设计一种排序方法，要求以尽可能少的比较次数和移动次数实现排序，并按你的设计编写算法。

【题目分析】设关键字小于10000的整数的记录序列存于数组中，再设容量为10000的临时整数数组，按整数的大小直接放入下标为该整数的数组单元中，然后对该数组进行整理存回原容量为1000的数组中。

【算法10.23】

void IntSort(int R[],int n)

{//关键字小于10000的1000个整数存于数组R中，本算法对整数进行排序

int R1[10000]={0}; //初始化为0

for(i=0;i<1000;i++)

R1[R[i]]=R[i];

for(i=0,k=0;i<10000;i++)

if(R1[i]!=0)

R[k++]=R1[i];

}

10.24 荷兰国旗问题：设有一个仅有红、白、蓝三种颜色的条块组成的条块序列。编写一个时间复杂度为O(n)的算法，使得这些条块按红、白、蓝的顺序排好，即排成荷兰国旗图案

【题目分析】设用整型数组R表示荷兰国旗,元素值1、2和3分别表示红、白和篮色。再设整型变量i,j和k,排序结束后R[1..i-1]表示红色,R[i..j-1]表示白色,R[j..n]表示篮色。i,j和k的初始值分别是1，1和n。

【算法10.24】

void DutchFlag(int R[],int n)

∥对红、白、篮三种颜色的条块,经排序形成荷兰国旗

{int i=1,j=1,k=n; ∥指针初始化,j到k是待排序元素

while(j<=k)

if(r[j]==1) ∥红色

{r[i]<-->r[j]; i++;j++; }

else if(r[j]==2) j++; ∥白色

else {r[j]<-->r[k]; k--;}∥兰色

}

[算法讨论]象将元素值为正数、负数和零的序列，排成前面都是负数,接着是零,最后是正数的排序；以及字母字符、数字字符和其它字符的序列的排序等,都属于这类荷兰国旗问题。排序后,红、白和蓝色的元素个数分别为i-1,j-i,n-j+1。

10.25 已知记录序列a[1..n]中的关键字各不相同，可按如下所述实现计数排序：另设数组c[1..n]，对每个记录a[i]，统计序列中关键字比它小的记录个数存于c[i]，则c[i]=0的记录必为关键字最小的记录，然后依c[i]值的大小对a中记录进行重新排列，编写算法实现上述排序方法。

【算法10.25】

void CountSort(rectyper[],int n)

{//对r[1..n]进行计数排序

c[1..n] =0; ∥c数组初始化，元素值指其在r中的位置

for(i=1;i<n;i++) ∥一趟比较选出大小，给数组 c赋值

for(j=i+1;j<=n;j++)

if(r[i].key>r[j].key)

c[i]++;else c[j]++;

i=1;

while(i<n) ∥若c[i]+1= i，则r[i]正好是第i个元素;否则，需要调整

{if(c[i]+1!=i)

{j=i; rc=r[i];

while(c[j]+1!=i)

{k=c[j]+1;rt=r[k]; //暂时保存r[k]/

r[k]=rc; j=c[k]; //取下一 j值

c[k]=k-1; //第k个已排好

rc=rt

}

r[i]=rc; c[i]=i-1； //完成了一个小循环，第i个已排好

}//if

i=i+1

}// while

上述调整也可用如下逻辑简单但效率低下的算法：

c[1..n]=c[1..n]+1 {c数组元素值指其在r中的位置。

while( i<n )

{ while( c[i]!=i)

{j=c[i]; c[i]ß à c[j]; r[i]ß à r[j]}

i=i+1;

}

10.26 若待排序序列用单链表存储，试给出其快速排序算法。

[题目分析]快速排序的思想是以第一个元素作“枢轴”,通过一趟的比较,将枢轴元素放在其排序的最终位置,使它左面的元素都小于等于它,而它右面的元素都大于等于它,从而再对其左右两部分递归进行快速排序。在链表中实现快速排序也必须使用这一原则。

【算法10.26】

void LinkQuickSort(LinkedListstart, LinkedList end)

∥对单链表start进行快速排序,end是链表的尾指针,初始调用时为null

{LinkedListstart1,end1,end2,p;

int flag=0; ∥tag是结束排序的标志

if(start!=null|| start!=end) ∥空表或只有一个结点

{start1=end1=start;∥start1和end1是右半链表头结点的前驱和尾结点的指针

if(end1!=end) flag=1;

p=start->next; ∥p为工作指针

while(flag) ∥进行一趟快速排序

{if(p->data<start->data) ∥结点插入前一半

{end1->next=p->next; ∥保留后继结点

if(p==end) flag=0; ∥一趟快速排序结束

if(start==end1) end0=p;

∥end0是遍历遇到的第一个小于枢轴的结点,将为前半的尾结点

p->next=start; start=p;∥修改左半部链表头指针

p=end1->next; ∥恢复当前待处理结点

}

else ∥处理右半部链表

{if(p==end) flag=0; ∥已到链表尾

end1->next=p; end1=p; ;∥end1和p是前驱和后继关系

p=p->next;

}∥else

}∥while

LinkQuickSort(start,end0); ∥对枢轴元素最终位置前的单链表快速排序

LinkQuickSort(start1->next,end1);∥对枢轴元素最终位置后的单链表快速排序

}∥LinkQuickSort

10.27 在数组A[0..n-1]中存放有n个不同的整数，其值均在1到n之间。写出一个函数或过程，将A中的n个数从大到小排序后存入B[0..n-1]数组中，要求算法的时间复杂度为O(n)。

【题目分析】因为n个值不同且大小在1到n之间的整数,要求逆序放入另一数组,只要逐个取出放到适当位置即可。即值为i(1<=i<=n)的元素就是数组下标为n-i的元素。

【算法10.27】

void ReArrange(int A[], int B[],int n)

{for(i=0;i<n;i++)

B[n-A[i]]=A[i];

}

0 0