数据结构课件-排序.
合集下载
严蔚敏数据结构(排序)ppt课件
❖基本思想：通过一趟排序，将待排 序记录分割成独立的两部分，其中 一部分记录的关键字均比另一部分 记录的关键字小，则可分别对这两 部分记录进行排序，以达到整个序 列有序
❖排序过程：对r[s……t]中记录进行一趟
快速排序，附设两个指针i和j，设枢轴记录 rp=r[s]，x=rp.key
初始时令i=s,j=t
一趟排序：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 49 55 65 97 76 取d3=1 三趟分组：13 4 48 38 27 49 55 65 97 76
三趟排序：4 13 27 38 48 49 55 65 76 97
i=8 20 (6
i=8 20 (6
13 30 39 42 70 85 ) 20
13 30 39 m
13 30 39 mj 13 30 39
s mj
42 70 42 70 42 70
85 ) 20 j 85 ) 20
85 ) 20
13 30 39 42 70 85 ) 20 js
13 20 30 39 42 70 85 )
第九章 内部排序
• 分类：
•内部排序：全部记录都可以同时调入内存进行的排序。
•外部排序：文件中的记录太大，无法全部将其同时调入内存进行的排 序。
• 定义：设有记录序列：{ R1、R2 ……….. Rn } 其相应的关键字 序列为： { K1、K2 ……….. Kn }; 若存在一种确定的关系： Kx <= Ky <= … <= Kz则将记录序列 { R1、R2 ……….. Rn } 排成按 该关键字有序的序列： { Rx、Ry ……….. Rz } 的操作，称之为 排序。
❖排序过程：对r[s……t]中记录进行一趟
快速排序，附设两个指针i和j，设枢轴记录 rp=r[s]，x=rp.key
初始时令i=s,j=t
一趟排序：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 49 55 65 97 76 取d3=1 三趟分组：13 4 48 38 27 49 55 65 97 76
三趟排序：4 13 27 38 48 49 55 65 76 97
i=8 20 (6
i=8 20 (6
13 30 39 42 70 85 ) 20
13 30 39 m
13 30 39 mj 13 30 39
s mj
42 70 42 70 42 70
85 ) 20 j 85 ) 20
85 ) 20
13 30 39 42 70 85 ) 20 js
13 20 30 39 42 70 85 )
第九章 内部排序
• 分类：
•内部排序：全部记录都可以同时调入内存进行的排序。
•外部排序：文件中的记录太大，无法全部将其同时调入内存进行的排 序。
• 定义：设有记录序列：{ R1、R2 ……….. Rn } 其相应的关键字 序列为： { K1、K2 ……….. Kn }; 若存在一种确定的关系： Kx <= Ky <= … <= Kz则将记录序列 { R1、R2 ……….. Rn } 排成按 该关键字有序的序列： { Rx、Ry ……….. Rz } 的操作，称之为 排序。
查找排序PPT课件
low=1; high=n;
while(low<=high)
{ mid=(low+high)/2;
if(ST[mid].key= = key) return (mid); /*查找成功*/
else if( key< ST[mid].key) high=mid-1; /*在前半区间继续查找*/
若k==r[mid].key，查找成功 若k<r[mid].key，则high=mid-1 若k>r[mid].key，则low=mid+1
❖重复上述操作，直至low>high时，查找失败 特点：比顺序查找方法效率高。最坏的情况下，需要比较 log2n次。
8
折半查找举例： 已知如下11个元素的有序表：
low
mid
( 08, 14, 23, 37, 46, 55, 68, 79,
low mid
high=mid-1
( 08, 14, 23, 37, 46, 55, 68, 79,
low=mid+1
high
mid
( 08, 14, 23, 37, 46, 55, 68, 79,
low
mid
( 08, 14, 23, 37, 46, 55, 68, 79,
5
讨论：怎样衡量查找效率？
——用平均查找长度（ASL）衡量。
如何计算ASL？
分析： 查找第1个元素所需的比较次数为1； 查找第2个元素所需的比较次数为2； …… 查找第n个元素所需的比较次数为n；
总计全部比较次数为：1＋2＋…＋n = (1+n)n/2 因为是计算某一个元素的平均查找次数，还应当除以n， （假设查找任一元素的概率相同） 即： ASL＝（1＋n）/2 ，时间效率为 O(n)
数据结构教程 第九章 排序
2 插入排序
9.2.3 希尔排序
3.算法
void ShellSort() { gap=n/2;//初次增量取序列元素个数n的一半为步长 while(gap>0) { for(i=gap+1;i<=n;i++) { j=i-gap; while(j>0) { if(r[j]>r[j+gap]) { x=r[j];r[j]=r[j+gap];r[j+gap]=x; j=j-gap; }//对子序列作直接插入排序 else j=0; } } gap=gap/2;}//每次减半，直至步长为1 上一页 }
上一页
下一页
9.3 快速排序法
9.3.2 快速排序
3【例9-5】对数据序列:70, 75, 69, 32, 88, 18, 16, 58进行快速排序如图9-3所示。 4.算法
void QuickSort(int low, int high)//递归形式的快速排序 { int pivotpos; if(low<high) { pivotpos=Partition(low,high); QuickSort(low,pivotpos-1);//对低子表递归排序 QucikSort(pivotpos+1,high);//对高子表递归排序 } }
9.2 插入排序
9.2.2 二分插入排序
3.算法
void BinsSort() { for(i=2;i<=n;i++) { r[0]=r[i];low=1;high=i-1;//将r[i]暂存到r[0] while(low<=high) //在r[low..high]中折半查找有序插入的位置 { m=(low+high)/2;//折半 if(r[0].key<r[m].key) high=m-1;//插入点在低半区 else low=m+1;//插入点在高半区 } for(j=i-1;j>high+1;--j) r[j+1]=r[j];//记录后移 r[high+1]r[0];//插入 } 上一页 下一页
9.2.3 希尔排序
3.算法
void ShellSort() { gap=n/2;//初次增量取序列元素个数n的一半为步长 while(gap>0) { for(i=gap+1;i<=n;i++) { j=i-gap; while(j>0) { if(r[j]>r[j+gap]) { x=r[j];r[j]=r[j+gap];r[j+gap]=x; j=j-gap; }//对子序列作直接插入排序 else j=0; } } gap=gap/2;}//每次减半，直至步长为1 上一页 }
上一页
下一页
9.3 快速排序法
9.3.2 快速排序
3【例9-5】对数据序列:70, 75, 69, 32, 88, 18, 16, 58进行快速排序如图9-3所示。 4.算法
void QuickSort(int low, int high)//递归形式的快速排序 { int pivotpos; if(low<high) { pivotpos=Partition(low,high); QuickSort(low,pivotpos-1);//对低子表递归排序 QucikSort(pivotpos+1,high);//对高子表递归排序 } }
9.2 插入排序
9.2.2 二分插入排序
3.算法
void BinsSort() { for(i=2;i<=n;i++) { r[0]=r[i];low=1;high=i-1;//将r[i]暂存到r[0] while(low<=high) //在r[low..high]中折半查找有序插入的位置 { m=(low+high)/2;//折半 if(r[0].key<r[m].key) high=m-1;//插入点在低半区 else low=m+1;//插入点在高半区 } for(j=i-1;j>high+1;--j) r[j+1]=r[j];//记录后移 r[high+1]r[0];//插入 } 上一页 下一页
(2024年)《数据结构》全套课件
30
树形数据结构的查找算法
二叉排序树的查找
从根节点开始，若查找值小于当前节点 值，则在左子树中查找；若大于当前节 点值，则在右子树中查找。
VS
平衡二叉树的查找
在保持二叉排序树特性的基础上，通过旋 转操作使树保持平衡，提高查找效率。
2024/3/26
31
散列表的查找算法
散列函数的设计
将关键字映射为散列表中位置的函数。
过指针来表示。
链式存储的特点
逻辑上相邻的元素在物理位置上 不一定相邻；每个元素都包含数
据域和指针域。
链式存储的优缺点
优点是插入和删除操作不需要移 动元素，只需修改指针；缺点是
存储密度小、空间利用率低。
2024/3/26
11
线性表的基本操作与实现
插入元素
在线性表的指定位 置插入一个元素。
查找元素
在线性表中查找指 定元素并返回其位 置。
自然语言处理的应用
在自然语言处理中，需要处理大量的文本数据，数据结构中的字符 串、链表、树等可以很好地支持文本的处理和分析。
41
数据结构在计算机网络中的应用
2024/3/26
路由算法的实现
计算机网络中的路由算法需要大量的数据结构支持，如最短路径 树、距离向量等。
网络流量的控制
在计算机网络中，需要对网络流量进行控制和管理，数据结构中的 队列、缓冲区等可以很好地支持流量的控制。
37
06
数据结构的应用与拓展
2024/3/26
38
数据结构在算法设计中的应用
01
作为算法设计的基 础
数据结构为算法提供了基本操作 和存储方式，是算法实现的重要 基础。
02
提高算法效率
第10章 排序 PPT课件
清华大学出版社
概述
数据结构（C++版）
排序算法的存储结构
从操作角度看，排序是线性结构的一种操作，待排序 记录可以用顺序存储结构或链接存储结构存储。
假定1：采用顺序存储结构，关键码为整型，且记录 只有关键码一个数据项。
int r[n+1]; //待排序记录存储在r[1]~r[n]，r[0]留做他用
假定2：将待排序的记录序列排序为升序序列。
i = 6 18 10 15 21 25 25* 18
10 15 18 21 25 25*
r[0]的作用? 暂存单元 43;+版）
关键问题(1)如何构造初始的有序序列？
解决方法：
将第1个记录看成是初始有序表，然后从第2个记录起 依次插入到这个有序表中，直到将第n个记录插入。 算法描述：
学号 0001 0002 0003 …
姓名 王军 李明 汤晓影
…
高数 85 64 85 …
英语 68 72 78 …
思想品德 88 92 86 …
清华大学出版社
概述
数据结构（C++版）
排序的基本概念
单键排序：根据一个关键码进行的排序； 多键排序：根据多个关键码进行的排序。
学号 0001 0002 0003 …
算法描述：
r[0]=r[i]; j=i-1; while (r[0]<r[j]) {
r[j+1]=r[j]; j--; }
r[0]有两个作用：
1. 进入循环之前暂存了r[i] 的值，使得不致于因记录 的后移而丢失r[i]的内容；
2. 在查找插入位置的循环 中充当哨兵。
清华大学出版社
插入排序
姓名 王军 李明 汤晓影
数学排序ppt课件
归并排序的基本思想是将两个或两个以上的有序表合并成一个新的有序 表。
归并排序的关键在于将待排序序列不断分解成若干个子序列，直到子序 列的长度为1或0，然后将这些子序列合并成一个有序序列。
归并排序的步骤
分解
将待排序序列不断分解 成若干个子序列，直到 每个子序列的长度为1
或0。
解决
对每个子序列进行排序 ，可以使用插入排序、
插入排序在每一步都保证将一个未排序的元素插入到已排序部分的合适位置，从 而保证已排序部分始终保持有序。
插入排序的步骤
01 02 03
初始化已排序部分为第一个元素， 未排序部分为其他元素。
从未排序部分取出第一个元素。
在已排序部分找到该元素的合适位 置并插入。
插入排序的时间复杂度
最好情况
当输入数组已经有序时， 插入排序的时间复杂度为 O(n)。
数学排序ppt课件
$number {01}
目录
• 引言 • 冒泡排序 • 选择排序 • 插入排序 • 快速排序 • 归并排序
01 引言
排序的定义
1 2
3
排序
将一组数据按照一定的顺序排列，以便进行查找、插入、删 除等操作。
排序的依据
可以是数值大小、字母顺序、时间先后等。
排序的稳定性
如果两个元素相等，排序后它们的位置不应改变。
02
快速排序在平均情况下的时间复杂度为 O(nlogn)，其中n为数组的长度。
03
快速排序在最好情况下的时间复杂度为 O(nlogn)，其中n为数组的长度。
06 归并排序
归并排序的原理
归并排序是一种分治策略的排序算法，它将待排序序列分成若干个子序 列，然后分别对子序列进行排序，最后将排好序的子序列合并成一个有 序序列。
归并排序的关键在于将待排序序列不断分解成若干个子序列，直到子序 列的长度为1或0，然后将这些子序列合并成一个有序序列。
归并排序的步骤
分解
将待排序序列不断分解 成若干个子序列，直到 每个子序列的长度为1
或0。
解决
对每个子序列进行排序 ，可以使用插入排序、
插入排序在每一步都保证将一个未排序的元素插入到已排序部分的合适位置，从 而保证已排序部分始终保持有序。
插入排序的步骤
01 02 03
初始化已排序部分为第一个元素， 未排序部分为其他元素。
从未排序部分取出第一个元素。
在已排序部分找到该元素的合适位 置并插入。
插入排序的时间复杂度
最好情况
当输入数组已经有序时， 插入排序的时间复杂度为 O(n)。
数学排序ppt课件
$number {01}
目录
• 引言 • 冒泡排序 • 选择排序 • 插入排序 • 快速排序 • 归并排序
01 引言
排序的定义
1 2
3
排序
将一组数据按照一定的顺序排列，以便进行查找、插入、删 除等操作。
排序的依据
可以是数值大小、字母顺序、时间先后等。
排序的稳定性
如果两个元素相等，排序后它们的位置不应改变。
02
快速排序在平均情况下的时间复杂度为 O(nlogn)，其中n为数组的长度。
03
快速排序在最好情况下的时间复杂度为 O(nlogn)，其中n为数组的长度。
06 归并排序
归并排序的原理
归并排序是一种分治策略的排序算法，它将待排序序列分成若干个子序 列，然后分别对子序列进行排序，最后将排好序的子序列合并成一个有 序序列。
《数据结构排序》课件
根据实际需求选择时间复杂度和空间 复杂度最优的排序算法，例如快速排 序在平均情况下具有较好的性能，但 最坏情况下其时间复杂度为O(n^2)。
排序算法的适用场景问题
适用场景考虑因素
选择排序算法时需要考虑实际应 用场景的特点，如数据量大小、 数据类型、是否需要稳定排序等 因素。
不同场景适用不同
算法
例如，对于小规模数据，插入排 序可能更合适；对于大规模数据 ，快速排序或归并排序可能更优 。
排序的算法复杂度
时间复杂度
衡量排序算法执行时间随数据量增长而增长的速率。时间复杂度越低，算法效 率越高。常见的时间复杂度有O(n^2)、O(nlogn)、O(n)等。
空间复杂度
衡量排序算法所需额外空间的大小。空间复杂度越低，算法所需额外空间越少 。常见的空间复杂度有O(1)、O(logn)、O(n)等。
在数据库查询中，经常需要对结果进行排序，以便用户能够快速找到所需信息。排序算 法的效率直接影响到查询的响应时间。
索引与排序
数据库索引能够提高查询效率，但同时也需要考虑到排序的需求。合理地设计索引结构 ，可以加速排序操作。
搜索引擎中的排序
相关性排序
搜索引擎的核心功能是根据用户输入的 关键词，返回最相关的网页。排序算法 需要综合考虑网页内容、关键词密度、 链接关系等因素。
VS
广告与排序
搜索引擎中的广告通常会根据关键词的竞 价和相关性进行排序，以达到最佳的广告 效果。
程序中的排序应用
数组排序
在程序中处理数组时，经常需要对其进行排 序。不同的排序算法适用于不同类型的数据 和场景，如快速排序、归并排序等。
数据可视化中的排序
在数据可视化中，需要对数据进行排序以生 成图表。例如，柱状图、饼图等都需要对数 据进行排序处理。
数据结构 排序
选择排序种类： 简单选择排序 树形选择排序 堆排序
2019/9/7
30
10.4.1 简单选择排序
待排记录序列的状态为：
有序序列R[1..i-1] 无序序列 R[i..n]
有序序列中所有记录的关键字均小于无序序列中记 录的关键字，第i趟简单选择排序是从无序序列 R[i..n]的n-i+1记录中选出关键字最小的记录加入 有序序列
2019/9/7
5
排序的类型定义
#define MAXSIZE 20 // 待排序记录的个数
typedef int KeyType;
typedef struct
{ KeyType key;
InfoType otherinfo; ∥记录其它数据域
} RecType;
typedef struct {
RecType r[MAXSIZE+1];
分别进行快速排序：[17] 28 [33] 结束 结束
[51 62] 87 [96] 51 [62] 结束
结束
快速排序后的序列： 17 28 33 51 51 62 87 96
2019/9/7
26
自测题 4 快速排序示例
对下列一组关键字 （46,58,15,45,90,18,10,62） 试写出快速排序的每一趟的排序结果
final↑ ↑first
i=8
[51 51 62 87 96 17 28 33]
final↑ ↑first
2019/9/7
14
希尔(shell )排序
基本思想：从“减小n”和“基本有序”两 方面改进。
将待排序的记录划分成几组，从而减少参 与直接插入排序的数据量，当经过几次分 组排序后，记录的排列已经基本有序，这 个时候再对所有的记录实施直接插入排序。
2019/9/7
30
10.4.1 简单选择排序
待排记录序列的状态为：
有序序列R[1..i-1] 无序序列 R[i..n]
有序序列中所有记录的关键字均小于无序序列中记 录的关键字，第i趟简单选择排序是从无序序列 R[i..n]的n-i+1记录中选出关键字最小的记录加入 有序序列
2019/9/7
5
排序的类型定义
#define MAXSIZE 20 // 待排序记录的个数
typedef int KeyType;
typedef struct
{ KeyType key;
InfoType otherinfo; ∥记录其它数据域
} RecType;
typedef struct {
RecType r[MAXSIZE+1];
分别进行快速排序：[17] 28 [33] 结束 结束
[51 62] 87 [96] 51 [62] 结束
结束
快速排序后的序列： 17 28 33 51 51 62 87 96
2019/9/7
26
自测题 4 快速排序示例
对下列一组关键字 （46,58,15,45,90,18,10,62） 试写出快速排序的每一趟的排序结果
final↑ ↑first
i=8
[51 51 62 87 96 17 28 33]
final↑ ↑first
2019/9/7
14
希尔(shell )排序
基本思想：从“减小n”和“基本有序”两 方面改进。
将待排序的记录划分成几组，从而减少参 与直接插入排序的数据量，当经过几次分 组排序后，记录的排列已经基本有序，这 个时候再对所有的记录实施直接插入排序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(1)趟数为n-1;
22
(2)直到在某趟排序过程中没有进行过交换记录的操作为止。
例:有一组待排序的记录的关键字初始排列如下: (49,38,65,97,76,13,27,49`)
第一趟: 49 38 65 97 76 13 27 49` 38 49 65 97 76 13 27 49` 38 49 65 97 76 13 27 49` 38 49 65 97 76 13 27 49` 38 49 65 76 97 13 27 49` 38 49 65 76 13 97 27 49` 38 49 65 76 13 27 97 49` 38 49 65 76 13 27 49` 97
Void insertsort(sqlist &L) {
for (i=2;i<=L.length; ++i) if (LT(L.r[i].key,L.r[i-1].key)) { L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0]; } }
38
38 38
↑final ↑first
13
27
16
2-路插入排序的性能分析: (1)空间: (2)时间: 基本运算:比较和移动记录; 2-路插入排序算法的时间复杂度为O(n×n)
17
10.2.3希尔排序
从直接插入排序 希尔排序的基本思想:
待排序序列基本有序可提高效率
待排序序列的记录数n很小时可提高效率
L.r[1].key..L.r[8].key 是 7 递增有序的
直接插入排序的过程:
r[0] r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] [初始关键字] 49 38 65 97 76 13 27 49`
第一趟插入 i=2 第二趟插入 i=3 第三趟插入 i=4 第四趟插入 i=5 第五趟插入 i=6 第六趟插入 i=7
Void Binsertsort(sqlist &L) { for (i=2;i<=L.length; ++i) if (LT(L.r[i].key,L.r[i-1].key)) { L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0]; } }
76
97
直接插入排序算法分析:
有n个记录待排序,需进行2..n共n-1趟插入;
第i趟插入完成的功能:在含有i-1个记录的有序序列r[1..i-1] 中插入一个记录r[i],插入后变成含
有i个记录的有序序列r[1..i]。
一级算法： Void insertsort(sqlist &L) {
for (i=2;i<=L.length; ++i)
38 38 38 38
49 49 49 49
65 65 65 65
97
76
13 13 13
27 27 27 27
49` 49` 49` 49`
97 76 97 76 76
97 13
13
13
38
27
49
38
65
49
76 97
65 76
27
97
49`
49`
8
第七趟插入 i=8
13
27
38
49 49` 65
姓名
4张强 3七明 5陈华 2王天 1李由
年龄 24 24 24
体重 72 75 53
54 57
76 62
内部排序—— 待排序记录存放在计算机随机存储器中进 行的排序过程； 外部排序—— 待排序记录的数量很大，以致内存一次不 能容纳全部记录，在排序过程中尚需对外 存进行访问的排序过程；
4
按排序过程中依据的不同原则对内排方法分类：
21
10.3快速排序
起泡排序的基本思想: 首先将第一个记录的关键字和第二个记录的关键字进 行比较，若为逆序，则将两个记录交换之，然后比较第二 个记录和第三个记录的关键字。直至第n-1个记录和第n个 记录的关键字进行过比较为止。 ……
然后进行第二趟起泡排序，对前n-1个记录进行同样操作。 结束的条件:
5
待排序的记录序列可有三种存储方式： （1）待排序的记录存放在地址连续的一组存储单元上。 （2）待排序的记录存放在静态链表中。
（3）待排序的记录本身存储在一组地址连续的存储单元 待排序记录的数据类型设为：
内,同时另设一个指示各个记录存储位置的地址向量。
P264
6
10.2插入排序 插入排序
直接插入排序 折半插入排序 2-路插入排序 表插入排序 希尔排序
例:有一组待排序的记录的关键字初始排列如下: (49,38,65,97,76,13,27,49`)
15
[初始关键字] 49
i=1:
first↑ ↑final
38 65 97 76 13 d[1] d[2] d[3] d[4] d[5] d[6] 49
27 d[7]
49` d[8]
i=2:
i=3:
49
体重 62 76 75 72 53
姓名 按某种稳定 3七明 方法对年龄 4张强 关键字进行 5陈华 排序 2王天 1李由
年龄 24
体重 75
24
24 54 57
72
53 76 62
3
姓名 1李由 2王天 3七明 4张强 5陈华
年龄 57 54 24 24 24
体重 62 76 75 72 53
按某种不稳 定方法对年 龄关键字进 行排序
10
三级算法：
Void insertsort(sqlist &L) {
for (i=2;i<=L.length; ++i) if (LT(L.r[i].key,L.r[i-1].key)) { L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0]; }
第10章 内部排序
10.1 概述 10.2 插入排序 10.3 快速排序 10.4 选择排序 10.5 归并排序 10.6 基数排序 10.7 各种内部排序方法的比较讨论
1
10.1概述
排序—— 是将数据元素的一个任意序列，重新排列成一 个按关键字有序的序列。 排序的一个确切定义：
假设含n个记录的序列为 {R1,R2,R3,…,Rn} 其相应的关键字序列为{K1,K2,…,Kn}
23
第一趟进行7次比较
整 个 排 序 过 程
49 38 65 97 76 13 27 49`
（1）插入排序 （2）交换排序 （3）选择排序 按内排过程中所需的工作量分类： （4）归并排序 （5）基数排序
（1）简单的排序方法，其时间复杂度为O(n×n)
（2）先进的排序方法，其时间复杂度为O(nlogn); （3）基数排序，其时间复杂度为O(d×n) 排序算法的两种基本操作： （1）比较两个关键字的大小； （2）将记录从一个位置移至另一个位置；
先将整个待排记录序列分割成为若干子序列分别进行
直接插入排序,待整个序列中的记录“基本有序”时,再对 全 体记录进行一次直接插入排序. 例:有一组待排序的记录的关键字初始排列如下: (49,38,65,97,76,13,27,49`)
18
r[0] r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] [初始关键字] 49 38 65 97 76 13 27 49`
第一趟排序后: (d1=3)
27
38
13
49
49`
65
97
76
第二趟排序后: (d2=2)
第三趟排序后: (d3=1)
13
ห้องสมุดไป่ตู้
38
27
49
49` 65
97
76
13
27
38
49
49`
65
76
19
97
希尔排序算法的实现:
Void shellsort(sqlist &L,int dlta[ ],int t){ for (i=0;i<t; ++i) 以dlta[i]为增量的一趟排序； } Shellinsert（sqlist &L,dlta[i]);
列中Ri领先于Rj，若在排序后的序列中Ri仍 领先Rj，则称所用的排序方法是稳定的。
不稳定排序方法—— 假设Ki=Kj(1<=i,j<=n,i<>j),且在排序前的序列
中Ri领先于Rj，若在排序后的序列中Rj领先 Ri，则称所用的排序方法是不稳定的。
例：
姓名
1李由 2王天 3七明 4张强 5陈华
年龄 57 54 24 24 24
第i趟插入；
}
9
二级算法：第i趟插入的算法 例：第i=7趟插入： 1 2 3 4 5 13 38 49 65 76
6 97
7 27
8 49`
if (LT(L.r[i].key,L.r[i-1].key)) { L.r[i]插入到 L.r[1].. L.r[i-1]中 } L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0];
22
(2)直到在某趟排序过程中没有进行过交换记录的操作为止。
例:有一组待排序的记录的关键字初始排列如下: (49,38,65,97,76,13,27,49`)
第一趟: 49 38 65 97 76 13 27 49` 38 49 65 97 76 13 27 49` 38 49 65 97 76 13 27 49` 38 49 65 97 76 13 27 49` 38 49 65 76 97 13 27 49` 38 49 65 76 13 97 27 49` 38 49 65 76 13 27 97 49` 38 49 65 76 13 27 49` 97
Void insertsort(sqlist &L) {
for (i=2;i<=L.length; ++i) if (LT(L.r[i].key,L.r[i-1].key)) { L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0]; } }
38
38 38
↑final ↑first
13
27
16
2-路插入排序的性能分析: (1)空间: (2)时间: 基本运算:比较和移动记录; 2-路插入排序算法的时间复杂度为O(n×n)
17
10.2.3希尔排序
从直接插入排序 希尔排序的基本思想:
待排序序列基本有序可提高效率
待排序序列的记录数n很小时可提高效率
L.r[1].key..L.r[8].key 是 7 递增有序的
直接插入排序的过程:
r[0] r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] [初始关键字] 49 38 65 97 76 13 27 49`
第一趟插入 i=2 第二趟插入 i=3 第三趟插入 i=4 第四趟插入 i=5 第五趟插入 i=6 第六趟插入 i=7
Void Binsertsort(sqlist &L) { for (i=2;i<=L.length; ++i) if (LT(L.r[i].key,L.r[i-1].key)) { L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0]; } }
76
97
直接插入排序算法分析:
有n个记录待排序,需进行2..n共n-1趟插入;
第i趟插入完成的功能:在含有i-1个记录的有序序列r[1..i-1] 中插入一个记录r[i],插入后变成含
有i个记录的有序序列r[1..i]。
一级算法： Void insertsort(sqlist &L) {
for (i=2;i<=L.length; ++i)
38 38 38 38
49 49 49 49
65 65 65 65
97
76
13 13 13
27 27 27 27
49` 49` 49` 49`
97 76 97 76 76
97 13
13
13
38
27
49
38
65
49
76 97
65 76
27
97
49`
49`
8
第七趟插入 i=8
13
27
38
49 49` 65
姓名
4张强 3七明 5陈华 2王天 1李由
年龄 24 24 24
体重 72 75 53
54 57
76 62
内部排序—— 待排序记录存放在计算机随机存储器中进 行的排序过程； 外部排序—— 待排序记录的数量很大，以致内存一次不 能容纳全部记录，在排序过程中尚需对外 存进行访问的排序过程；
4
按排序过程中依据的不同原则对内排方法分类：
21
10.3快速排序
起泡排序的基本思想: 首先将第一个记录的关键字和第二个记录的关键字进 行比较，若为逆序，则将两个记录交换之，然后比较第二 个记录和第三个记录的关键字。直至第n-1个记录和第n个 记录的关键字进行过比较为止。 ……
然后进行第二趟起泡排序，对前n-1个记录进行同样操作。 结束的条件:
5
待排序的记录序列可有三种存储方式： （1）待排序的记录存放在地址连续的一组存储单元上。 （2）待排序的记录存放在静态链表中。
（3）待排序的记录本身存储在一组地址连续的存储单元 待排序记录的数据类型设为：
内,同时另设一个指示各个记录存储位置的地址向量。
P264
6
10.2插入排序 插入排序
直接插入排序 折半插入排序 2-路插入排序 表插入排序 希尔排序
例:有一组待排序的记录的关键字初始排列如下: (49,38,65,97,76,13,27,49`)
15
[初始关键字] 49
i=1:
first↑ ↑final
38 65 97 76 13 d[1] d[2] d[3] d[4] d[5] d[6] 49
27 d[7]
49` d[8]
i=2:
i=3:
49
体重 62 76 75 72 53
姓名 按某种稳定 3七明 方法对年龄 4张强 关键字进行 5陈华 排序 2王天 1李由
年龄 24
体重 75
24
24 54 57
72
53 76 62
3
姓名 1李由 2王天 3七明 4张强 5陈华
年龄 57 54 24 24 24
体重 62 76 75 72 53
按某种不稳 定方法对年 龄关键字进 行排序
10
三级算法：
Void insertsort(sqlist &L) {
for (i=2;i<=L.length; ++i) if (LT(L.r[i].key,L.r[i-1].key)) { L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0]; }
第10章 内部排序
10.1 概述 10.2 插入排序 10.3 快速排序 10.4 选择排序 10.5 归并排序 10.6 基数排序 10.7 各种内部排序方法的比较讨论
1
10.1概述
排序—— 是将数据元素的一个任意序列，重新排列成一 个按关键字有序的序列。 排序的一个确切定义：
假设含n个记录的序列为 {R1,R2,R3,…,Rn} 其相应的关键字序列为{K1,K2,…,Kn}
23
第一趟进行7次比较
整 个 排 序 过 程
49 38 65 97 76 13 27 49`
（1）插入排序 （2）交换排序 （3）选择排序 按内排过程中所需的工作量分类： （4）归并排序 （5）基数排序
（1）简单的排序方法，其时间复杂度为O(n×n)
（2）先进的排序方法，其时间复杂度为O(nlogn); （3）基数排序，其时间复杂度为O(d×n) 排序算法的两种基本操作： （1）比较两个关键字的大小； （2）将记录从一个位置移至另一个位置；
先将整个待排记录序列分割成为若干子序列分别进行
直接插入排序,待整个序列中的记录“基本有序”时,再对 全 体记录进行一次直接插入排序. 例:有一组待排序的记录的关键字初始排列如下: (49,38,65,97,76,13,27,49`)
18
r[0] r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] [初始关键字] 49 38 65 97 76 13 27 49`
第一趟排序后: (d1=3)
27
38
13
49
49`
65
97
76
第二趟排序后: (d2=2)
第三趟排序后: (d3=1)
13
ห้องสมุดไป่ตู้
38
27
49
49` 65
97
76
13
27
38
49
49`
65
76
19
97
希尔排序算法的实现:
Void shellsort(sqlist &L,int dlta[ ],int t){ for (i=0;i<t; ++i) 以dlta[i]为增量的一趟排序； } Shellinsert（sqlist &L,dlta[i]);
列中Ri领先于Rj，若在排序后的序列中Ri仍 领先Rj，则称所用的排序方法是稳定的。
不稳定排序方法—— 假设Ki=Kj(1<=i,j<=n,i<>j),且在排序前的序列
中Ri领先于Rj，若在排序后的序列中Rj领先 Ri，则称所用的排序方法是不稳定的。
例：
姓名
1李由 2王天 3七明 4张强 5陈华
年龄 57 54 24 24 24
第i趟插入；
}
9
二级算法：第i趟插入的算法 例：第i=7趟插入： 1 2 3 4 5 13 38 49 65 76
6 97
7 27
8 49`
if (LT(L.r[i].key,L.r[i-1].key)) { L.r[i]插入到 L.r[1].. L.r[i-1]中 } L.r[0]=L.r[i]; L.r[i]= L.r[i-1]; For (j=i-2;LT(L.r[0].key, L.r[j].key);--j) L.r[j+1]= L.r[j]; L.r[j+1]= L.r[0];