(严蔚敏)第10章 内部排序 习题答案

84] 83 84] 83 84 96] 63 83 84 96]
（2）简单选择排序 ）简单选择排序
初始 第1趟 趟 第2趟 趟 3趟 第3趟 第4趟 趟 第5趟 趟 第6趟 趟 第7趟 趟 0 83 13 13 13 13 13 13 13 1 40 [40 35 35 35 35 35 35 2 63 63 [63 40 40 40 40 40 3 13 83 83 [83 57 57 57 57 4 84 84 84 84 [84 63 63 63 5 35 35 40 63 63 [84 83 83 6 96 96 96 96 96 96 [96 84 7 57 57] 57] 57] 83] 83] 84] [96]
第10章 内部排序 章 习题及答案
一、单项选择题 ( C ) 1. 一组记录的关键码为 ( 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
二、填空题 1.在最好的情况下，对于具有n个元素的有 在最好的情况下，对于具有 个元素的有 在最好的情况下 序序列，若采用冒泡排序， 序序列，若采用冒泡排序，所需的比较次 数为_______次。 数为 n-1 次 2.对于具有 个元素的有序序列，若采用冒 对于具有n个元素的有序序列 对于具有 个元素的有序序列， 泡排序，最多需要进行 n-1 趟起泡 趟起泡。 泡排序，最多需要进行_______趟起泡。
( B ) 6. 若对序列 （ 15, 30, 26, 22, 69, 50, 53, 87 ） 采用二路归并法排序， 采用二路归并法排序，则进行一趟归并后产生 的序列为。 的序列为。 A. 15, 22, 26, 30, 50, 53, 69, 87 B. 15, 30, 22, 26, 50, 69, 53, 87 C. 15, 26, 30, 22, 50, 69, 53, 87 D. 15, 26, 22, 30, 50, 53, 69, 87
( D ) 7. 排序算法中，第一趟排序后，任 排序算法中，第一趟排序后， 一元素都不能确定其最终位置的算法是。 一元素都不能确定其最终位置的算法是。 A.选择排序 选择排序 B.快速排序 快速排序 C.冒泡排序 冒泡排序 D.插入排序 插入排序
( C ) 8.采用排序算法对 n 个元素进行 采用排序算法对 排序， 排序，其排序趟数肯定为 n-1 趟的排序 方法是。 方法是。 A.插入和快速 插入和快速 C.选择和插入 选择和插入 B.冒泡和快速 冒泡和快速 D.选择和冒泡 选择和冒泡
输出
3
6
56 23 29 61 40 38
输出
3
6
20
23 29 56 61 40 38
输出
3
6
20
40 29 56 61 38
输出
3
6
20
23
29 40 56 61 38
输出
3
6
20
23
61 40 56 38
输出
3
6
20
23
29
38 40 56 61
输出
3
6
20
23
29
56 40 61
参考程序为： 参考程序为： #include <iostream> using namespace std; //直接插入排序法 直接插入排序法 void InsertSort ( int r[ ], int n ) { for ( int i=2; i<=n; i++ ) if (r[i] < r[i-1]) { r[0] = r[i]; // 复制为监视哨 for ( int j = i-1 ; r[0] < r[j]; j-- ) r[j+1] = r[j]; // 记录后移 r[j+1] = r[0]; // 插入到正确位置 } }
3. 在插入排序和选择排序中，若原始记录已 在插入排序和选择排序中， 基本有序，则较适合选用 插入排序 。 基本有序，则较适合选用____________。 4. 在对一组记录 （54，38，96，23，15，72，60，45，83） ， ， ， ， ， ， ， ， ） 进行直接插入排序时， 进行直接插入排序时，当把 记录 60 插入到 前面的有序表中时， 前面的有序表中时，为寻找插入位置需比较 3 _________次。 次 5. 堆排序的时间复杂性为 O(n log2n) 堆排序的时间复杂性为_____________ 。
(3) 快速排序第一趟过程 快速排序第一趟过程 排序第一趟 1
初始
第1次交换 次交换 第2次交换 次交换 第3次交换 次交换
2
Biblioteka Baidu
3
4
5
6
7 96 96
8 57 83
83 40 63 13 84 35 [57] 40 63 13 84 35 [57 40 63 13] 83 35
96 [84]
[57 40 63 13 35] 83 [96 84]
三、应用题 1. 已知关键码序列 （83, 40, 63, 13, 84, 35, 96, 57） ） 分别画出用直接插入排序、简单选择排序、 分别画出用直接插入排序、简单选择排序、 直接插入排序 快速排序对上述序列进行操作的各趟结果。 快速排序对上述序列进行操作的各趟结果。 对上述序列进行操作的各趟结果
//折半查找法 折半查找法 int Search_Bin ( int e[ ], int n, int key ) { int low, high, mid ; low = 1; high = n ; // 置区间初值 while ( low <= high ) { mid = ( low + high ) / 2; if ( key == e[mid] ) return mid; // 找到待查元素 else if ( key <= e[mid] ) high = mid - 1; // 在前半区间进行查找 else low = mid + 1; // 在后半区间进行查找 } return 0; // 顺序表中不存在待查元素 }
2. 判别以下序列是否为堆 如果不是 , 把它调 判别以下序列是否为堆, 整为堆; 再进行堆排序。 整为堆 再进行堆排序。
( 6, 56, 20, 3, 23, 40, 38, 29, 61 )
( 6, 56, 20, 3, 23, 40, 38, 29, 61） 不是堆 ） 6 56 3 29 61 23 40 20 38
（1）直接插入排序 ） 1 2 3 初始 [83] 40 63 i=2 [40 83] i=3 [40 63 83] i=4 [13 40 63 i=5 [13 40 63 i=6 [13 35 40 i=7 [13 35 40 i=8 [13 35 40
4 13
5 84
6 35
7 96
8 57
83] 83 63 63 57
（3）各趟快速排序过程 ）各趟快速排序过程 1
第1趟 趟 第2趟 趟 第3趟 趟 第4趟 趟
2 40
3 63
4 13
5
6
7
8
[57 [35 [13 13
35 ] 83 [96 84]
40 13] 57 [63 ] 83 [84 96] 35 35 40 63 57 57 63] 63 83 [84 96] 83 84 96
void main ( ) { int i , j, key , e[6]={ 0, 7, 1, 9, 5, 3 } ; InsertSort ( e , 5 ) ; //直接插入排序 直接插入排序 cout<<"排序后的序列为："<<endl; 排序后的序列为： 排序后的序列为 for ( i=1; i<=5; i++ ) cout<<e[i]<<" "; cout<<endl<<"请输入查找值 key = " ; 请输入查找值 cin>>key ; j = Search_Bin ( e , 5, key) ; //折半查找 //折半查找 if ( j == 0 ) cout<<"该元素值不存在 ! " <<endl; 该元素值不存在 else cout<<"第 "<<j<<" 个元素的值为 "<< 第 key<<endl<<endl ; }
6 3 29 56 61 23 40 20 38
是小堆 3 6 29 56 61 23 40 20 38
61 6 29 56
输出
20 23 40 38
3
6 23 29 56
输出
20 61 40 38
3
56 23 29 61 40 20 38
输出
3
6
20 23 29 61 40 38 56
输出
3
6
20
23
29
38
40 56 61
输出
3
6
20
23
29
38
61 56
输出
3 40
6
20
23
29
38
56 61
输出
3 40
6
20
23
29
38
61
输出
3 40
6 56
20
23
29
38
输出
3 40
6 56
20 61
23
29
38
四、算法设计题 设有关键码序列 设有关键码序列 ( 7, 1, 9, 5, 3 ) 存放在一个顺序表：整型数组e[6]中的 中的e[1]～e[5]。 存放在一个顺序表：整型数组 中的 ～ 。 编写程序实现： 编写程序实现： (1)先采用一种简单排序法 如直接插入排序、冒泡排 先采用一种简单排序法(如直接插入排序 先采用一种简单排序法 如直接插入排序、 简单选择排序)，把该顺序表调整为有序表： 序、简单选择排序 ，把该顺序表调整为有序表： void InsertSort ( int r[ ], int n ) (2) 再用折半查找法，在有序表中查找值为 key 的元 再用折半查找法， 素： int Search_Bin ( int e[ ], int n, int key )
( A ) 3. 下列关键码序列中，属于堆的是。 下列关键码序列中，属于堆的是。 A.（15, 30, 22, 93, 52, 71） （ ） B.（15, 71, 30, 22, 93, 52） （ ） C.（15, 52, 22, 93, 30, 71） （ ） D.（93, 30, 52, 22, 15, 71） （ ）
( D ) 4．直接插入排序算法的时间复杂性为。 ．直接插入排序算法的时间复杂性为。 A. O(1) B. O(n) C. O(nlog2n) D. O(n2) ( C ) 5.下列排序方法中 属于稳定的排序方法是。 下列排序方法中,属于稳定的排序方法是 下列排序方法中 属于稳定的排序方法是。 A. 希尔排序 B. 快速排序 C. 冒泡排序 D. 堆排序
( B ) 2. 已知 个数据元素为 已知10个数据元素为 （ 54, 28, 16, 34, 73, 62, 95, 60, 26, 43 ） 对该数列按从小到大排序， 对该数列按从小到大排序，经过一趟冒泡排序 (大数下沉 后的序列为。 大数下沉)后的序列为 大数下沉 后的序列为。 A. 16, 28, 34, 54, 73, 62, 60, 26, 43, 95 B. 28, 16, 34, 54, 62, 73, 60, 26, 43, 95 C. 28, 16, 34, 54, 62, 60, 73, 26, 43, 95 D. 16, 28, 34, 54, 62, 60, 73, 26, 43, 95