数据结构第十章内部排序-插入排序
合集下载
数据结构-内排序
Shell排序的性能分析
Shell排序的时间复杂度在O(nlog2n)和O(n2)间， Knuth的 统计结论是，平均比较次数和记录平均移动次数在n1.25与 1.6n1.25之间
Shell排序是一种不稳定的排序方法
最后谈一下delta的取法。 Shell最初的方案是delta=n/2， delta=delta/2，直到delta=1。Knuth的方案是delta=delta/3 +1。其它方案有：都取奇数为好；或delta互质为好等等。 而使用象1, 2, 4, 8, …或1, 3, 6, 9, …这样的增量序列就不太 合适，因为这样会使几个元素多次被分到一组中，从而造 成重复排序，产生大量无用的比较操作
另外，在无序子表中向前移动的过程中，如果没 有交换元素，则说明无序子表已有序，无须再做 排序
24
冒泡排序算法实现
1 void bubble_sort(RecType R[ ], int n) { 2 //待排序元素用一个数组R表示，数组有n个记录
3 int i, j; 4 bool swap=TRUE; //判断无序子表是否已有序的变量
内排序和外排序 按照排序过程中使用内、外存的不 同将排序方法分为内排序和外排序。若待排序记录全 部在内存中，称为内排序；若待排序记录的数量很大， 以致内存一次不能容纳全部记录，在排序过程中需要 进行内、外存交换，称为外排序。本章仅讨论内排序
内排序可分为五大类：插入排序、交换排序、选择排 序、归并排序和基数排序
直接插入排序(straight insert sort) 折半插入排序(binary insert sort) Shell排序(Shell sort)
10
10.2.1 直接插入排序举例
严蔚敏 数据结构第十章 内部排序的具体代码(c++,附测试数据)
int i = 1;
int exchange = 1;
SortData temp;
while ( i < n && exchange ){
exchange = 0; //标志置为0,假定未交换
for ( int j = n-1; j >= i; j-- )
QSort(L,1,L.length);
}//QuickSort
//**************************************************
//直接选择排序
void SelectSort ( SortData V[ ], int n ) {
for ( int i = 0; i < n-1; i++ ) {
if LT(L.r[i].key,L.r[i-1].key){
L.r[0]=L.r[i];
for ( j = i-1; LT(L.r[0].key,L.r[j].key); --j )
L.r[j+1]=L.r[j];
L.r[j+1]=L.r[0];
//*******************************************
//直接插入排序
void InsertSort ( SqList &L ) {
//按非递减顺序对表进行排序,从后向前顺序比较
int i,j;
for ( i = 2; i <= L.length; ++ i)
low=1;high=i-1; //查找范围由1到i-1
while(low<=high){
int exchange = 1;
SortData temp;
while ( i < n && exchange ){
exchange = 0; //标志置为0,假定未交换
for ( int j = n-1; j >= i; j-- )
QSort(L,1,L.length);
}//QuickSort
//**************************************************
//直接选择排序
void SelectSort ( SortData V[ ], int n ) {
for ( int i = 0; i < n-1; i++ ) {
if LT(L.r[i].key,L.r[i-1].key){
L.r[0]=L.r[i];
for ( j = i-1; LT(L.r[0].key,L.r[j].key); --j )
L.r[j+1]=L.r[j];
L.r[j+1]=L.r[0];
//*******************************************
//直接插入排序
void InsertSort ( SqList &L ) {
//按非递减顺序对表进行排序,从后向前顺序比较
int i,j;
for ( i = 2; i <= L.length; ++ i)
low=1;high=i-1; //查找范围由1到i-1
while(low<=high){
数据结构-第十章-内部排序
0
1
2
3
4
5
6
7
8
i=5
MAXINT 49 2 3
MAXINT 49 6 3 MAXINT 49 6 3 MAXINT 49 6 8
38 1
38 1 38 1 38 1
65 97 5 0
65 5 65 5 65 5 97 0 97 0 97 0
76 4
76 4 76 4 76 4
13
27
49
i=6
最坏情况下,待排记录按关键字非递增有序 排列（逆序）时，第 i 趟时第 i＋1 个对象 必须与前面 i 个对象都做排序码比较, 并且 每做1次比较就要做1次数据移动。总比较 次 数 为 (n+2)(n-1)/2 次 ， 总 移 动 次 数 为 (n+4)(n-1)/2。 在平均情况下的排序码比较次数和对象移 动次数约为 n2/4。因此，直接插入排序的 时间复杂度为 O(n2)。 直接插入排序是一种稳定的排序方法。
折半插入排序 (Binary Insertsort)
基本思想 既然每个要插入记录之前的纪录 已经按关键字有序排列，在查找插入位 臵时就没有必要逐个关键字比较，可以 使用折半查找来实现。由此进行的插入 排序称之为折半插入排序。
折半插入排序的算法
void BInsertSort (SqList &L){ for (i=2;i<=L.length;++i){ L.r[0]=L.r[i]; low=1;high=i-1; //查找范围由1到i-1 while(low<=high){ m=(low+high)/2; if LT(L.r[0].key,L.r[m].key) high=m-1; else low=m+1; }//while 折半查找 for (j=i-1;j>=high+1;--j) L.r[j+1]=L.r[j]; //折半查找结束后high+1位臵即为插入位臵 L.r[high+1]=L.r[0]; }//for }//BInsertSort
源代码--数据结构与算法(Python版)chap10 排序
20
交换类
（2）快速排序 快速排序采用分而治之(Divide and Conquer)
的策略将问题分解成若干个较小的子问题，采用 相同的方法一一解决后，再将子问题的结果整合 成最终答案。快速排序的每一轮处理其实就是将 这一的基准数定位，直到所有的数都排序完成 为止。
21
快速排序的基本步骤：
1. 选定一个基准值（通常可选第一个元素）； 2. 将比基准值小的数值移到基准值左边，形
14
• 交换类
交换类排序的基本思想是：通过交换无序序列 中的记录得到其中关键字最小或最大的记录，并将 其加入到有序子序列中，最终形成有序序列。交换 类排序可分为冒泡排序和快速排序等。
15
交换类
（1）冒泡排序 两两比较待排序记录的关键字，发现两
个记录的次序相反时即进行交换，直到没有 反序的记录为止。因为元素会经由交换慢慢 浮到序列顶端，故称之为冒泡排序。
3. 最后对这个组进行插入排序。步长的选法 一般为 d1 约为 n/2，d2 为 d1 /2， d3 为 d2/2 ，…， di = 1。
11
【例】给定序列（11，9，84，32，92，26，58，91，35， 27，46，28，75，29，37，12 ），步长设为d1 =5、d2 =3、 d3 =1，希尔排序过程如下：
for i in range(1,len(alist)):
#外循环n-1
for j in range(i,0,-1):
#内循环
if alist[j]<alist[j-1]:
alist[j],alist[j-1]=alist[j-1],alist[j] #交换
li=[59,12,77,64,72,69,46,89,31,9] print('before: ',li) insert_sort(li) print('after: ',li)
交换类
（2）快速排序 快速排序采用分而治之(Divide and Conquer)
的策略将问题分解成若干个较小的子问题，采用 相同的方法一一解决后，再将子问题的结果整合 成最终答案。快速排序的每一轮处理其实就是将 这一的基准数定位，直到所有的数都排序完成 为止。
21
快速排序的基本步骤：
1. 选定一个基准值（通常可选第一个元素）； 2. 将比基准值小的数值移到基准值左边，形
14
• 交换类
交换类排序的基本思想是：通过交换无序序列 中的记录得到其中关键字最小或最大的记录，并将 其加入到有序子序列中，最终形成有序序列。交换 类排序可分为冒泡排序和快速排序等。
15
交换类
（1）冒泡排序 两两比较待排序记录的关键字，发现两
个记录的次序相反时即进行交换，直到没有 反序的记录为止。因为元素会经由交换慢慢 浮到序列顶端，故称之为冒泡排序。
3. 最后对这个组进行插入排序。步长的选法 一般为 d1 约为 n/2，d2 为 d1 /2， d3 为 d2/2 ，…， di = 1。
11
【例】给定序列（11，9，84，32，92，26，58，91，35， 27，46，28，75，29，37，12 ），步长设为d1 =5、d2 =3、 d3 =1，希尔排序过程如下：
for i in range(1,len(alist)):
#外循环n-1
for j in range(i,0,-1):
#内循环
if alist[j]<alist[j-1]:
alist[j],alist[j-1]=alist[j-1],alist[j] #交换
li=[59,12,77,64,72,69,46,89,31,9] print('before: ',li) insert_sort(li) print('after: ',li)
数据结构答案 第10章 排序学习与指导
第10章排序10.1 知识点分析1．排序基本概念：（1）排序将数据元素的任意序列，重新排列成一个按关键字有序（递增或递减）的序列的过程称为排序。
（2）排序方法的稳定和不稳定若对任意的数据元素序列，使用某个排序方法，对它按关键字进行排序，若对原先具有相同键值元素间的位置关系，排序前与排序后保持一致，称此排序方法是稳定的；反之，则称为不稳定的。
（3）内排序整个排序过程都在内存进行的排序称为内排序，本书仅讨论内排序。
（4）外排序待排序的数据元素量大，以致内存一次不能容纳全部记录，在排序过程中需要对外存进行访问的排序称为外排序。
2．直接插入排序直接插入排序法是将一个记录插到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。
3．二分插入排序二分插入排序法是用二分查找法在有序表中找到正确的插入位置，然后移动记录，空出插入位置，再进行插入的排序方法。
4．希尔排序希尔排序的基本思想是：先选取一个小于n的整数d1作为第一个增量，把待排序的数据分成d1个组，所有距离为d1的倍数的记录放在同一个组内，在各组内进行直接插入排序，每一趟排序会使数据更接近于有序。
然后，取第二个增量d2，d2< d1，重复进行上述分组和排序，直至所取的增量d i=1（其中d i< d i-1 < ……< d2< d1），即所有记录在同一组进行直接插入排序后为止。
5．冒泡排序冒泡法是指每相邻两个记录关键字比大小，大的记录往下沉（也可以小的往上浮）。
每一遍把最后一个下沉的位置记下，下一遍只需检查比较到此为止；到所有记录都不发生下沉时，整个过程结束。
6．快速排序快速排序法是通过一趟排序，将待排序的记录组分割成独立的两部分，其中前一部分记录的关键字均比枢轴记录的关键字小；后一部分记录的关键字均比枢轴记录的关键字大，枢轴记录得到了它在整个序列中的最终位置并被存放好。
第二趟再分别对分割成两部分子序列，再进行快速排序，这两部分子序列中的枢轴记录也得到了最终在序列中的位置而被存放好，并且它们又分别分割出独立的两个子序列……。
第十章_排序方法(数据结构ppt-严蔚敏)
第二个问题解决方法——筛选
方法：输出堆顶元素之后，以堆中最后一个元素替代之；然 后将根结点值与左、右子树的根结点值进行比较，并与其中 小者进行交换；重复上述操作，直至叶子结点，将得到新的 堆，称这个从堆顶至叶子的调整过程为“筛选”
例 38 50 97 76
13 27 65 49 13 38
97 27 38 50 76
2 (n 4)(n 1) 记录移动次数： (i 1) 2 i 2
i 2 n
若待排序记录是随机的，取平均值 n2 关键字比较次数： T(n)=O(n² ) 4 记录移动次数：
空间复杂度：S(n)=O(1)
n2 4
折半插入排序
排序过程：用折半查找方法确定插入位置的排序叫~
初始时令i=s,j=t 首先从j所指位置向前搜索第一个关键字小于x的记录，并和rp 交换 再从i所指位置起向后搜索，找到第一个关键字大于x的记录， 和rp交换 重复上述两步，直至i==j为止 再分别对两个子序列进行快速排序，直到每个子序列只含有 一个记录为止
x 例 初始关键字： 27 49 i 完成一趟排序： ( 27 38 13 49 65 i 13) 49 97 76 j 97 49 13 j 97 65 49 27 50 j 50)
13 38
76 65 27 49
堆排序：将无序序列建成一个堆，得到关键字最小 （或最大）的记录；输出堆顶的最小（大）值后，使 剩余的n-1个元素重又建成一个堆，则可得到n个元素 的次小值；重复执行，得到一个有序序列，这个过程 叫~ 堆排序需解决的两个问题：
如何由一个无序序列建成一个堆？ 如何在输出堆顶元素之后，调整剩余元素，使之成为一个新 的堆？
按排序所需工作量
北航数据结构课件 (10)
（ 1，4，6 ， 12 8，8 12 ， 6，11，… ）
例
49
temp
temp＞K[j] j=0 38 97 76 65 13 27 50
… (若干趟后)
K[j+1]=K[ j ]； j=j−1；
65
38
49
76 65
76 97
65 97
13
27
50
K[j+1]=temp;
38
49
65
76
97
核心思想
首先确定一个元素的间隔数gap。 将参加排序的元素按照gap分隔成若干个子序列 ( 即分别把那些位置相隔为gap的元素看作一个子序 列),然后对各个子序列采用 某一种排序方法 进行排 序；此后减小gap值，重复上述过程，直到gap<1。
一种减小gap的方法：
gap1 = n/2 gapi = gapi-1/2
1.时间性能 —— 排序过程中元素之间的比较次数与元素的
移动次数。 本章讨论各种排序方法的时间复杂度 时主要按照最差情况下所需要的比较次数 来进行。
2.空间性能 —— 除了存放参加排序的元素之外，排序过程
中所需要的其他辅助空间。
3.排序稳定性 —— 对于值相同的两个元素，排序前后的先后
次序不变，则称该方法为稳定性排序方法， 否则，称为非稳定性排序方法。
算 法
泡排序法的排序趟数与原始序列中数 据元素的排列有关，因此，排序的趟数为 一个范围，即[1..n-1]。
什么情况下至少排序一趟 什么情况下要排序n-1趟
O(n
2)
结论
泡排序方法比较适合于 参加排序的序列的原始状态 基本有序的情况
泡排序法是 稳定性排序方法。
严蔚敏《数据结构》复习笔记及习题 (内部排序)【圣才出品】
第10章内部排序10.1 复习笔记一、概述1．排序的相关概念（1）排序：重新排列表中元素，使其按照关键字递增或递减排列的过程。
（2）内部排序：待排序记录存放在计算机的随机存储器中进行排序的过程。
（3）外部排序：待排序记录数据量大，内存不能一次性容纳全部记录，排序时需对外存进行访问的过程。
2．排序算法的评价（1）时间复杂度（2）空间复杂度（3）稳定性在设计排序算法时，除了考虑算法的时间和空间复杂度外，还需考虑算法的稳定性，稳定性定义如下：待排序列中两个元素R i，R j对应的关键字K i＝K j，且排序前R i在R j前面，若选择某一种算法对该序列排序后，R i仍在R j前面，则称该排序算法是稳定的，否则是不稳定的。
二、插入排序1．直接插入排序（1）算法分析将待排序记录分为有序子序列和无序子序列两部分，每次将无序序列中的元素插入到有序序列中的正确位置上。
即：先将序列中的第1个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减的有序序列为止，整个排序过程进行n－1趟插入。
其算法实现如下：（2）算法评价①时间复杂度：平均情况下，考虑待排序列是随机的，其时间复杂度为O（n2）。
②空间复杂度：仅使用常数个辅助单元，空间复杂度为O（1）。
③稳定性：每次插入元素都是从后向前先比较再插入，不存在相同元素位置交换，所以算法是稳定的。
2．折半插入排序（1）算法分析当排序表顺序存储时，可以先折半查找出待插位置，再对该位置后的元素统一后移，并完成插入操作。
其算法实现如下：（2）算法评价①时间复杂度：折半插入排序只是减少了元素比较次数，其他的均与直接插入排序相同，因此时间复杂度仍为O（n2）。
②空间复杂度：与直接插入排序相同，为O（1）。
③稳定性：与直接插入排序相同，是稳定的算法。
3．希尔排序（1）算法分析先将整个待排记录序列分割成为若干子序列（形如L[i，i＋d，i＋2d，…，i＋kd]），分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
外部排序:文件中的记录太大，无法全部
将其同时调入内存进行的排序.
排序定义
设有记录序列：{ R1，R2 ， … ，Rn }, 其相应的关键字 序列为：K1, K 2 ,, K n ;
若存在1,2, … ,n的一种排列
1
p1, p2 ,, pn , 使关键字
2 n
非递减（或非递增）： K p K p K;p
插入排序
1.直接插入排序
基本思想：每一次将一个待排序的记录，按其关键字大小插入 到前面已经排好序的有序表中，从而得到一个新的、记录数增 1的有序表。
例: 已知 21、25、22、10、25*、18，用直接插入法将其排序。
0 1 2 3 4 5 6
21
25
22
10
25* 18
直接插入排序过程示例
r 0 1 21 i=2 i=3 i=4 i=5 i=6 22 10 25 18 21 21 21 10 10 10 2 25 25 25 22 15 15 15 3 22 22 22 25 21 21 18 4 10 10 10 10 5 25* 25* 25* 25* 25* 25* 25 6 18 18 18 18 18 18 25*
时间复杂度： T(n)=O(n² )
void binsort(JD r[],int n) { int i,j,x,s,m,k; for(i=2;i<=n;i++) { r[0]=r[i]; x=r[i].key; ‘用择半查找找待插记录的位置 s=1; j=i-1; while(s<=j) { m=(s+j)/2; if(x<r[m].key) j=m-1; else s=m+1; } ‘从i-1 到 s向右移动一个位置 for(k=i-1;k>=s;k--) r[k+1]=r[k]; ‘插入 r[s]=r[0]; } }
3. 2-路插入排序
49 38 65 97 76 13 27 49
当第一个数据在序列 中间位置时，可减少 移动次数，不减少比 较次数。
(49)
(49) (49 65) (49 65 97) (49 65 76 97) (49 65 76 97) (38) (38) (38) (38) (13 38)
i 2
1 n 1
n
记录移动次数：不需移动记录
例如
0
1
2
3
4
5
6
7
13 27 38 49 65 76 97
若待排序记录按关键字从大到小排列(逆序) 关键字比较次数： 记录移动次数：
(n 2)(n 1) i 2 i 2 n (n 4)(n 1) (i 1) 2 i 2
假设待排序的一组记录存放在地址连续的一组存 储单元上。
＃ define MAXSIZE 20 typedef int KeyType； typedef struct { KeyType key; InfoType otherinfo; } RedType; typedef struct { RedType r [MAXSIZE + 1 ] ; // r[0] 空或作哨兵 int length; } SqList;
例
0
i=1
1 2 3 4 5 6 7 (49) 38 65 97 76 13 27
i=2 38 (38 49) 65 97 76 13 27 i=3 65 (38 49 65) 97 76 13 27 i=4 97 (38 49 65 97) 76 13 27
i=5 76 (38 49 65 76 97) 13 27
Maxint 49 38 65 97 76 13 27 49 2 3 1 4 0
Maxint 49 38 65 97 76 13 27 49 2 3 1 5 0 4
Maxint 49 38 65 97 76 13 27 49 6 3 1 5 0 4 2 Maxint 49 38 65 97 76 13 27 49 6 3 1 5 0 4 7 2 Maxint 49 38 65 97 76 13 27 49 6 8 1 5 0 4 7 2 3
待排记录的数据类型
待排序的记录序列有三种存储方式： 1) 存放在地址连续的一组存储单元上； 2) 存放在静态链表中，记录之间的次序关系由指针指示，则 实现排序不需要移动记录，仅需要修改指针即可； 3) 存储在一组地址连续的存储单元内，同时另设一个指示各 个记录存储位置的地址向量，在排序过程中不移动记录本 身，而移动地址向量中这些记录的“地址”，在排序结束 之后再根据地址向量中的值调整记录的存储位置. 本文假设待排序记录存放在地址连续的一组存储单元上
的记录被安置在第n-1个记录位置；
重复上述过程，直到“在一趟排序过程中没有进行过交换 记录的操作”为止.
例
1 2 3 4
49 38 49 38 65 97 76 97 76 13 13 97 27 27 97 30 30 97
2. 折半插入排序
排序过程： 用折半查找方法确定插入位置的排序
例
i=1 i=2 13
i=7 6 i=8 20 i=8 20
…...
(30) 13 70 85 39 42 6 (13 30) 70 85 39 42 6
(6 (6 s (6 s 13 13 30 30 39 39 42 70 42 70 42 70
交换排序
1. 起泡排序(Bubble Sort)
排序过程
将第一、第二个记录的关键字进行比较，若 r[1].key>r[2].key，则交换；然后比较第二与第三个记 录；依次类推，直至第n-1个和第n个记录比较为止——第
一趟冒泡排序，结果关键字最大的记录被安置在最后一个 记录上；
对前n-1个记录进行第二趟冒泡排序，结果使关键字次大
r[0]的作用? 暂存单元 监视哨
25
25 21
问题1：如何构造初始的有序序列
解决方法： 将第1个记录看成是初始有序表，然后从第2个记录起依次插 入到这个有序表中，直到将第n个记录插入。 算法描述： for (i=2; i<=n; i++) { 插入第i个记录，即第i趟直接插入排序； }
问题2：如何查找待插入记录的插入位置?
0
1
2
3
4
5
Байду номын сангаас
6
7
8
Maxint 49 38 65 97 76 13 27 49 1 0
Maxint 49 38 65 97 76 13 27 49
2 0 1
Maxint 49 38 65 97 76 13 27 49
2
3
1
0
Maxint 49 38 65 97 76 13 27 49 2 3 1 4 0
5. 希尔排序(Shell) (缩小增量法)
排序过程： 先取一个正整数d1<n，把所有相隔d1的记录 放一组，组内进行直接插入排序； 然后取d2<d1，重复上述分组和排序操作； 直至di=1，即所有记录放进一个组中排序为止。
例
初始：
49 38 65 97 76 13 27
48 48
55 55
4 4
20 20
85 ) 20 85 ) 20 j 85 ) 20
m 13 30 39 m
13 13 j j 30 39 s mj 30 39
i=8 20 i=8 20
(6 (6
42 70 42 70
85 ) 20 85 ) 20
s
20 30 39 42 70 85 )
i=8 20
(6
13
算法描述
算法评价
复杂性
O(n2)
(49 65 76 97)
(49 49 65 76 97)
Final
(13 27 38)
(13 27 38)
First
4. 表插入排序
假设数据元素已存储在链表中，且0号单
元作为头结点，不移动记录而只是改变链指针 域，将记录按关键码建为一个有序链表。
首先，将表头结点和数组下标为1的结点构成一个循 环链表，即头结点指针域置1，下标为1结点的链域置 0，并在头结点数据域中存放比所有记录关键码都大 的整数。接下来，逐个结点向链表中插入即可。
n
例如 0 1 2 3 4 5 6 7 97 76 65 49 38 27 13
若待排序记录是随机的，取平均值
2 n 关键字比较次数： 4 2 n 记录移动次数： 4
T(n)=O(n² )
插入排序是一种稳定的排序方法。 原理：关键字相同的两个对象，在整个排 序过程中，不会通过比较而相互交换。
第十章
内部排序
1、插入排序 2、交换排序 3、选择排序 4、归并排序 5、基数排序
概
述
排 序 的 分 类
1. 按排序过程中使用的存储器分 a 内排序 b 外排序
2. 按文件的存储结构分 a 连续顺序文件排序 b 链表排序 3. 按排序的稳定性分 a 稳定性排序 b 不稳定性排序
内部排序:全部记录都可以同时调入内存 进行的排序;
r[0]有两个作用： 1. 进入循环之前暂存了r[i] 的值，使得不致于因记录 的后移而丢失r[i]的内容； 2. 在查找插入位置的循环 中充当哨兵。
整个排序过程为进行n-1趟插入，即先将序列中
第1个记录看成是一个有序子序列，然后从第2个记
录开始，逐个进行插入，直至整个序列有序。
算 法 描 述
typedef struct { int key; float info; }JD; ‘直接插入排序 void straisort(JD r[],int n) { int i,j; for(i=2;i<=n;i++) { r[0]=r[i]; ’哨兵 j=i-1;’从第i-1个位置起，和哨兵分别比较 while(r[0].key<r[j].key) { r[j+1]=r[j]; ’向右移动 j--; } r[j+1]=r[0]; } }