第3章 排序==归并排序
算法导论第三章思考题
算法导论第三章思考题
以下是算法导论第三章思考题的一些例子：
1. 在排序算法中，插入排序和归并排序都是稳定的算法。
请解释什么是稳定的排序算法，并举一个不稳定的排序算法的例子。
2. 有一个长度为n的纸牌序列（每张牌由一个整数表示），请设计一个O(n)时间复杂度的算法，将纸牌序列拆分为奇数序
列和偶数序列，使得奇数序列中的牌排在前面，偶数序列中的牌排在后面。
3. 请设计一个算法，在已经排序的整数数组中，找到两个数的和等于给定目标值的索引。
4. 有一个长度为n的整数数组，每个元素的值都在1到n之间（包括1和n）。
请设计一个O(n)时间复杂度的算法，找到数
组中重复的数字。
5. 请设计一个时间复杂度为O(nlogn)的算法，找到一个整数数组中的第k个最小元素。
这些问题旨在帮助读者巩固对算法导论第三章内容的理解，并应用已学的算法知识解决问题。
通过思考这些问题并给出解答，读者可以进一步理解排序、查找、平衡树等算法的应用和效率。
数据结构及应用算法教程习题第三章 排序
第三章排序一、选择题1．某内排序方法的稳定性是指( D )。
A．该排序算法不允许有相同的关键字记录、B．该排序算法允许有相同的关键字记录C．平均时间为0（n log n）的排序方法 D．以上都不对2．下面给出的四种排序法中( )排序法是不稳定性排序法。
A. 插入B. 冒泡C. 二路归并D. 快速排序3．下列排序算法中，其中（ CD ）是稳定的。
A. 堆排序，冒泡排序B. 快速排序，堆排序C. 直接选择排序，归并排序D. 归并排序，冒泡排序6．若要求尽可能快地对序列进行稳定的排序，则应选（ B ）。
A．快速排序 B．归并排序 C．冒泡排序12．排序趟数与序列的原始状态有关的排序方法是( D )排序法。
A．插入 B. 选择 C. 冒泡 D. 快速17．数据序列（8，9，10，4，5，6，20，1，2）只能是下列排序算法中的( C )的两趟排序后的结果。
A．选择排序 B.冒泡排序 C.插入排序18．数据序列（2，1，4，9，8，10，6，20）只能是下列排序算法中的( A )的两趟排序后的结果。
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 25 8447 （4） 15 21 25 47 84，则采用的排序是 ( A )。
A. 选择B. 冒泡C. 快速D. 插入24．下列序列中，（ D ）是执行第一趟快速排序后所得的序列。
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]28．下列排序算法中，在待排序数据已有序时，花费时间反而最多的是( C )排序。
5. 5排序算法--快速与归并 课件-2021-2022学年浙教版（2019）高中信息技术选修1
快速排序算法
·快速排序算法(用栈实现)
代码：
def quick_sort(array, l, r): if l >= r: return stack = [] stack.append(l) stack.append(r) while stack: low = stack.pop(0) hight = stack.pop(0) if hight - low <= 0: continue k = array[hight] i = low - 1 for j in range(low, hight):
选修1《数据与数据结构》
第五章 数据结构与算法
5.5 排序算法 --快速与归并
学习目标
快速排序算法 归并排序算法
排序算法
快速排序算法
排序算法
·快速排序的基本思路
快速排序使用分治法策略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：
1、 在数组中选一个基准数（通常为数组第一个）。 2、将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边。 3、对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只 有一个元素，即为全部有序。
排序算法
k = l #归并子数组的索引 while i < n1 and j < n2:
if L[i] <= R[ j]: arr[k] = L[i] i += 1
else: arr[k] = R[ j] j += 1
k += 1 while i < n1:
arr[k] = L[i] i += 1 k += 1 while j < n2: arr[k] = R[ j] j += 1 k += 1
归并排序详解
归并排序详解归并排序是一种常见的排序算法，它采用了分治的思想，将待排序的序列分成若干个小的子序列，然后每个子序列内部进行排序，最后将所有子序列合并成一个有序的序列。
归并排序的时间复杂度为O(nlogn)，具有稳定性。
归并排序的过程可以分为以下三个步骤：1.分：将待排序的序列分成若干个子序列，然后对每个子序列进行排序。
其中，子序列的长度为1时即认为这个子序列有序，然后将这些有序的子序列合并成更长的有序序列（长度为2）；最终再合并成更长的有序序列（长度为4），以此类推。
2.治：合并两个有序序列，使之成为一个有序序列。
可以采用双指针法，比较两个有序序列当前位置的元素，将小的元素放入临时数组中，重复此步骤直到所有的元素都被放入新数组中。
3.合：将所有子序列合并成一个有序序列。
下面是归并排序的示例代码：```pythondef merge_sort(arr):if len(arr) < 2:return arr # 当序列只有一个元素时，认为它是有序的mid = len(arr) // 2 # 找到序列中间的位置left = merge_sort(arr[:mid]) # 对左半部分进行排序right = merge_sort(arr[mid:]) # 对右半部分进行排序return merge(left, right) # 合并左右两个有序序列def merge(left, right):res = [] # 临时数组i, j = 0, 0 # 双指针，分别指向左右两个有序序列的起点while i < len(left) and j < len(right):if left[i] <= right[j]:res.append(left[i])i += 1else:res.append(right[j])j += 1res += left[i:] # 如果左半部分有剩余，将其全部放入临时数组 res += right[j:] # 如果右半部分有剩余，将其全部放入临时数组 return res```归并排序是一种相对简单的排序算法，稳定性好，应用领域很广。
第3章 排序答案
第3章排序自测卷答案姓名班级一、填空题（每空1分，共24分）1. 大多数排序算法都有两个基本的操作：比较（两个关键字的大小）和移动（记录或改变指向记录的指针）。
2. 在对一组记录（54，38，96，23，15，72，60，45，83）进行直接插入排序时，当把第7个记录60插入到有序表时，为寻找插入位置至少需比较3次。
(可约定为，从后向前比较)3. 在插入和选择排序中，若初始数据基本正序，则选用插入排序（到尾部）；若初始数据基本反序，则选用选择排序。
4. 在堆排序和快速排序中，若初始记录接近正序或反序，则选用堆排序；若初始记录基本无序，则最好选用快速排序。
5. 对于n个记录的集合进行冒泡排序，在最坏的情况下所需要的时间是O(n2) 。
若对其进行快速排序，在最坏的情况下所需要的时间是O(n2) 。
6. 对于n个记录的集合进行归并排序，所需要的平均时间是O(nlog2n) ，所需要的附加空间是O(n) 。
7．【计研题2000】对于n个记录的表进行2路归并排序，整个归并排序需进行log2n 趟（遍），共计移动n log2n次记录。
(即移动到新表中的总次数！共log2n趟，每趟都要移动n个元素)8.设要将序列（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；堆排序初始建堆的结果是A, D, C, R, F, Q, M, S, Y，P, H, X。
9. 在堆排序、快速排序和归并排序中，若只从存储空间考虑，则应首先选取堆排序方法，其次选取快速排序方法，最后选取归并排序方法；若只从排序结果的稳定性考虑，则应选取归并排序方法；若只从平均情况下最快考虑，则应选取快速排序方法；若只从最坏情况下最快并且要节省内存考虑，则应选取堆排序方法。
算法21--内部排序--归并排序
实现这种递归调用的关键是为过程建立递归调用工作栈。通 常，在一个过程中调用另一过程时，系统需在运行被调用过 程之前先完成3件事:
（1）将所有实参指针，返回地址等信息传递给被调用过程； （2）为被调用过程的局部变量分配存储区； （3）将控制转移到被调用过程的入口。 在从被调用过程返回调用过程时，系统也相应地要完成3件事： （1）保存被调用过程的计算结果； （2）释放分配给被调用过程的数据区； （3）依照被凋用过程保存的返回地址将控制转移到调用过程.
实际的意义：可以把一个长度为n 的无序序列看成 是 n 个长度为 1 的有序子序列 ，首先做两两归 并，得到 n/2 个长度为 2 的子序列；再做两两 归并，…，如此重复，直到最后得到一个长度为 n
的有序序列。
归并排序
初始序列
[49] [38] [65] [97 [76] [13] [27]
第一步 第二步
T(1)=1 T(n)=kT(n/m)+f(n)
2019/10/20
归并排序时间复杂性分析
• 合并趟数： log2n • 每趟进行比较的代价 n • 总的代价为 T(n) = O ( nlog2n ) • 在一般情况下：
c
n=1
T(n) =
T( n/2 ) + T( n/2 ) + cn n>1
优缺点：Ω的这个定义的优点是与O的定义对称，缺点 是当 f(N) 对自然数的不同无穷子集有不同的表达式， 且有不同的阶时，未能很好地刻画出 f(N)的下界。
2019/10/20
f(n) cg(n)
n0
n
2019/10/20
代入法解递归方程
方法的关键步骤在于预先对解答作出推测，然后用 数学归纳法证明推测的正确性。
概述插入排序交换排序选择排序归并排序基数排序外部排序小结
Type getKey ( ) { return key; } //提取关键字 void setKey ( const Type x ) { key = x; } //修改 Element<Type> & operator = //赋值 ( Element<Type> & x ) { this = x; } int operator == ( Type & x ) //判this == x { return ! ( this->key >x || x < this->key ); } int operator != ( Type & x ) //判this != x { return this->key < x || x < this->key ; } int operator <= ( Type & x ) //判this x { return ! (this->key > x ); } int operator >= ( Type & x ) //判this x { return ! (this->key < x ); } int operator < ( Type & x ) //判this < x { return this->key > x; }
KCN i n(n 1) / 2 n / 2,
2 i 1 n 1
RMN (i 2) (n 4)(n 1) / 2 n / 2
2 i 1
n 1
若待排序对象序列中出现各种可能排列的概 率相同，则可取上述最好情况和最坏情况的 平均情况。在平均情况下的关键字比较次数 和对象移动次数约为 n2/4。因此，直接插入 排序的时间复杂度为 o(n2)。 直接插入排序是一种稳定的排序方法。
数据结构-排序
实现“一趟插入排序”可分三步进行： 实现“一趟插入排序”可分三步进行： 三步进行 1．在 有序区 中查找 R[i] 的插入位置， ． 的插入位置， 2．记录后移一个位置； ．记录后移一个位置； 3．将 R[i] 插入（复制）到 相应 的位置上。 ． 插入（复制） 的位置上。
第8页
直接插入排序
R0 初始状态 i =2 i =3 i =4 i =5 76 38
49 } // InsertSort 7趟 i =6 13 13 38 49 65 76 97 27 49 排序 排序过程： 个记录看成是一个有序子序列， 排序过程：先将序列中第 1 个记录看成是一个有序子序列， i =7 27 13 27 38 49 65 76 97 49 个记录开始，逐个进行插入，直至整个序列有序。 然后从第 2 个记录开始，逐个进行插入，直至整个序列有序。 i =8 49 13 27 38 49 49 65 76 97
数据结构(C++语言版)
第1页
目 录
1 2 3 3 4 3 5 3 6 3
第2页
排序的基本概念 插入类排序 交换类排序 选择类排序 归并排序 小结
概念
排序：将数据元素的一个任意序列，重新排列成一个按关键 排序：将数据元素的一个任意序列，重新排列成一个按关键 字有序的序列 的序列。 字有序的序列。 R1, R2, R3, R4, R5, R6, R7, R8 例：将关键字序列：52, 49, 80, 36, 14, 58, 61, 23 将关键字序列： K1, K2, K3, K4, K5, K6, K7, K8 Kp1 ≤Kp2 ≤Kp3 ≤Kp4 ≤Kp5 ≤ Kp6 ≤Kp7 ≤Kp8 调整为：14, 23, 36, 49, 调整为： Rp1, Rp2, Rp3, Rp4, 52, 58, Rp5, Rp6, 61 , 80 Rp7, Rp8
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
else TR[k] = SR[j++];
}
5
if (i<=m) TR[k..n] = SR[i..m]; // 将剩余的 SR[i..m] 复制到 TR
if (j<=n) TR[k..n] = SR[j..n]; // 将剩余的 SR[j..n] 复制到 TR
} // Merge
6
平分MSort
二、归并排序 归并排序的过程基于下列基本思想进行： 将两个或两个以上的有序表 “归并”
为一个新的有序表。
1
在内部排序中，通常采用的是2-路归并 排序。即：将两个位置相邻的记录有序子序 列
有序子序列 R[l..m] 有序子序列 R[m+1..n]
归并为一个记录的有序序列。 有 序 序 列 R[l..n]
49
MSort(SR,TR2,2,2)
38
Merge(TR2,TR1,1,1,2) 11
38,49
三、堆排序
简单选择排序 堆排序
（具体实现细节见第6章）
12
一、简单选择排序
假设排序过程中，待排记录序列的状态为：
有序序列R[1..i-1]
第i趟 简单选择排序
无序序列 R[i..n]
从中选出 关键字最小的记录
可以得出，对 n 个记录进行归并排序 的时间复杂度为Ο(nlogn)。即：
每一趟归并的时间复杂度为 O(n)， 总共需进行 logn 趟。
10
例如，对线性表L：49,38,65,97,76,13,27，进行归并 排序执行过程：
MSort(L.r,L.r,1,7)
49,38,65,97,76,13,27
else
{m = (s+t)/2; // 将SR[s..t]平分为SR[s..m]和SR[m+1..t]
Msort (SR, TR2, s, m); // 递归地将SR[s..m]归并为有序的TR2[s..m]
Msort (SR, TR2, m+1, t); //递归地SR[m+1..t]归并为有序的TR2[m+1..t]
int i, int m, int n) { // 将相邻有序的记录序列 SR[i..m] 和 SR[m+1..n] // 归并为有序的记录序列 TR[i..n]
for (j=m+1, k=i; i<=m && j<=n; ++k)
{
// 将SR中记录由小到大归并为TR
if (SR[i].key<=SR[j].key) TR[k] = SR[i++];
<初态> (49) (38) (65) (97) (76) (13) (27)
<第1趟> (38 49) (65 97) (13 76) (27)
<第2趟> (38 49 65 97) (13 27 76)
fo<r第(3j=趟m>+1(,1k3 =i;27i<=m38 &&49j<=6n5; ++7k6) 97)
SR[s..t]平分为两部分SR[s..m]、SR[m+1..t]后，再归
并为TR[s..t]。这样平分为递归过程。 合并Merge 7
归并排序的算法
如果记录无序序列 SR[s..t] 的两部分 SR[s .. (s+t)/2 ] 和 SR[ (s+t)/2+1 .. t] 已经分别按关键字有序， 则利用上述归并算法很容易将它们归并成 整个记录序列是一个有序序列。
有序序列R[1..i]
无序序列 R[i+1..n] 13
简单选择排序的算法描述如下：
void SelectSort (Elem R[], int n ) { // 对记录序列R[1..n]作简单选择排序。
for (i=1; i<n; ++i) { // 选择第 i 小的记录，并交换到位
j = SelectMinKey(R, i); // 在 R[i..n] 中选择关键字最小的记录
MSort(SR,TR2,1,4)
MSort(SR,TR2,5,7)
49,38,65,97
Merge(TR2,TR1,1,4,7)
MSort(SR,TR2,1,2)
49,38
MSort(SR,TR2,3,4)
65,97
Merge(TR2,TR1,1,2,4)
38,49,65,97
MSort(SR,TR2,1,1)
归并排序过程
SR[1] SR[2] SR[3] SR[4] SR[5] SR[6] SR[7]
<初态> 49 38 65 97 76 13 27
第1次平分（ 49 38 65 97）（ 76 13 27 ）
第2次平分（ 49 38 ）38 ）（ 65）（97）（ 76）（ 13）（ 27 ）
Merge (TR2, TR1, s, m, t);
// 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
}
9
} // Msort
void MergeSort (SqList &L) {
// 对顺序表 L 作2-路归并排序
Msort(L.r, L.r, 1, L.length); } // MergeSort
{2-路归并排序的核心操作：将一维数 组// 将中相前邻后的相SR邻中的记两录由个小有到序大充归列并归为并TR 为一if (个SR有[i序].k序ey列<=。SR[j].key) TR[k] = SR[i++];
else TR[k] = SR[j++];
4
}
算法3.9 void Merge (RcdType SR[], RcdType TR[],
由此，应该先分别对这两部分进行 2-路归 并排序。
8
void Msort ( RcdType SR[], RcdType TR1[], int s, int t ) {
// 将SR[s..t] 归并排序为 TR1[s..t]
RcdType *TR2=new RcdType[t-s+1];
if (s= =t) TR[s]=SR1[s];
这个操作对顺序表而言，是轻而易举的。 2
❖基本思想：将一个具有n个待排 序记录的序列看成是n个长度为1 的有序序列，然后进行两两归并， 得到n/2个长度为2的有序序列， 再进行两两归并，…如此重复， 直至得到一个长度为n的有序序 列为止。
❖这种排序方法称为2-路归并排序。
3
归并排序过程
SR[1] SR[2] SR[3] SR[4] SR[5] SR[6] SR[7]