数据结构基数排序ppt
合集下载
排序1(数据结构PPT课件)(ppt文档)
第九章 排序
概述
排序：将一组杂乱无章的数据按一定的规律顺 次排列起来。
文件: 它是待排序数据对象的有限集合。
关键词域(key): 通常数据对象有多个属性 域，即多个数据成员组成，其中有一个属性域 可用来区分对象，作为排序依据。该域即为关 键词域。每个文件用哪个属性域作为关键词， 要视具体的应用需要而定。即使是同一个文件 表，在解决不同问题的场合也可能取不同的域 做关键码。
( i←j–1 ． K←Kj . R←Rj . WHILE K＜Ki DO ( Ri+1←Ri ．i←i–l ) ． Ri+1←R ) ▌
k[0] k[1] k[2] k[3] k[4] k[5]
j －∞ 8
7
2
4
6
2 －∞ [8] 7
246
3 －∞ [7
8] 2 4 64 －来自 [278] 4 6
(n 1)(n 4) 4
(n 1)(n 8) 4
因此，直接插入排序的时间复杂度为 o(n2)。
比较次数
记录移动次数
最好
n–1
2n–2
平均
(n 1)(n 4) 4
排序的时间开销: 排序的时间开销是衡量 算法好坏的最重要的标志。排序的时间开销可 用算法执行中关键词的比较次数与数据的移动 次数来衡量。
各节给出算法运行时间代价的大略估算:一般 都按平均情况进行估算。对于那些受对象关键 词序列初始排列及对象个数影响较大的，需要 按最好情况和最坏情况进行估算。
排序算法的稳定性: 如果在对象序列中有两 个对象r[i]和r[j]，它们的关键码 k[i] = k[j]， 且在排序之前，对象r[i]排在r[j]前面。如果 在排序之后，对象r[i]仍在对象r[j]的前面， 则称这个排序方法是稳定的，否则称这个 排序方法是不稳定的。
概述
排序：将一组杂乱无章的数据按一定的规律顺 次排列起来。
文件: 它是待排序数据对象的有限集合。
关键词域(key): 通常数据对象有多个属性 域，即多个数据成员组成，其中有一个属性域 可用来区分对象，作为排序依据。该域即为关 键词域。每个文件用哪个属性域作为关键词， 要视具体的应用需要而定。即使是同一个文件 表，在解决不同问题的场合也可能取不同的域 做关键码。
( i←j–1 ． K←Kj . R←Rj . WHILE K＜Ki DO ( Ri+1←Ri ．i←i–l ) ． Ri+1←R ) ▌
k[0] k[1] k[2] k[3] k[4] k[5]
j －∞ 8
7
2
4
6
2 －∞ [8] 7
246
3 －∞ [7
8] 2 4 64 －来自 [278] 4 6
(n 1)(n 4) 4
(n 1)(n 8) 4
因此，直接插入排序的时间复杂度为 o(n2)。
比较次数
记录移动次数
最好
n–1
2n–2
平均
(n 1)(n 4) 4
排序的时间开销: 排序的时间开销是衡量 算法好坏的最重要的标志。排序的时间开销可 用算法执行中关键词的比较次数与数据的移动 次数来衡量。
各节给出算法运行时间代价的大略估算:一般 都按平均情况进行估算。对于那些受对象关键 词序列初始排列及对象个数影响较大的，需要 按最好情况和最坏情况进行估算。
排序算法的稳定性: 如果在对象序列中有两 个对象r[i]和r[j]，它们的关键码 k[i] = k[j]， 且在排序之前，对象r[i]排在r[j]前面。如果 在排序之后，对象r[i]仍在对象r[j]的前面， 则称这个排序方法是稳定的，否则称这个 排序方法是不稳定的。
基数排序实用PPT课件PPT课件
11
第11页/共26页
一、时间性能
1. 平均的时间性能
时间复杂度为 O(nlogn)即O(nlog2n)： 快速排序、堆排序和归并排序
时间复杂度为 O(n2)： 直接插入排序、起泡排序和
简单选择排序
时间复杂度为 O(n): 基数排序
12
第12页/共26页
2. 当待排记录序列按关键字顺序有序时 直接插入排序和起泡排序能达到O(n)
最高位优先MSD法：
Most Significant Digit first
最低位优先LSD法：
Least Significant Digit first
4
第4页/共26页
MSD法
先对K0进行排序，并按 K0 的不同值 将记录序列分成若干子序列之后，分 别对 K1 进行排序，...…， 依次类推， 直至最后对最次位关键字排序完成为 止。
对于序列中任意两个记录 Ri 和 Rj (1≤i<j≤n) 都满足下列(词典)有序关系： (Ki0, Ki1, …,Kid-1) < (Kj0, Kj1, …,Kjd-1)
其中: K0 被称为 “最主”位关键字 Kd-1 被称为 “最次”位关键字
3
第3页/共26页
实现多关键字排序 通常有两种作法:
4. 快速排序和堆排序是不稳定的排序方 法。
18
第18页/共26页
四、关于“排序方法的时间复杂度的下限”
本章讨论的各种排序方法，除基数排序外， 其它方法都是基于“比较关键字”进行排序的 排序方法。
可以证明， 这类排序法可能达到的最快的 时间复杂度为O(nlogn)。 (基数排序不是基于 “比较关键字”的排序方法，所以它不受这个 限制)
排序之前 :
第11页/共26页
一、时间性能
1. 平均的时间性能
时间复杂度为 O(nlogn)即O(nlog2n)： 快速排序、堆排序和归并排序
时间复杂度为 O(n2)： 直接插入排序、起泡排序和
简单选择排序
时间复杂度为 O(n): 基数排序
12
第12页/共26页
2. 当待排记录序列按关键字顺序有序时 直接插入排序和起泡排序能达到O(n)
最高位优先MSD法：
Most Significant Digit first
最低位优先LSD法：
Least Significant Digit first
4
第4页/共26页
MSD法
先对K0进行排序，并按 K0 的不同值 将记录序列分成若干子序列之后，分 别对 K1 进行排序，...…， 依次类推， 直至最后对最次位关键字排序完成为 止。
对于序列中任意两个记录 Ri 和 Rj (1≤i<j≤n) 都满足下列(词典)有序关系： (Ki0, Ki1, …,Kid-1) < (Kj0, Kj1, …,Kjd-1)
其中: K0 被称为 “最主”位关键字 Kd-1 被称为 “最次”位关键字
3
第3页/共26页
实现多关键字排序 通常有两种作法:
4. 快速排序和堆排序是不稳定的排序方 法。
18
第18页/共26页
四、关于“排序方法的时间复杂度的下限”
本章讨论的各种排序方法，除基数排序外， 其它方法都是基于“比较关键字”进行排序的 排序方法。
可以证明， 这类排序法可能达到的最快的 时间复杂度为O(nlogn)。 (基数排序不是基于 “比较关键字”的排序方法，所以它不受这个 限制)
排序之前 :
《数据结构排序》课件
根据实际需求选择时间复杂度和空间 复杂度最优的排序算法，例如快速排 序在平均情况下具有较好的性能，但 最坏情况下其时间复杂度为O(n^2)。
排序算法的适用场景问题
适用场景考虑因素
选择排序算法时需要考虑实际应 用场景的特点，如数据量大小、 数据类型、是否需要稳定排序等 因素。
不同场景适用不同
算法
例如，对于小规模数据，插入排 序可能更合适；对于大规模数据 ，快速排序或归并排序可能更优 。
排序的算法复杂度
时间复杂度
衡量排序算法执行时间随数据量增长而增长的速率。时间复杂度越低，算法效 率越高。常见的时间复杂度有O(n^2)、O(nlogn)、O(n)等。
空间复杂度
衡量排序算法所需额外空间的大小。空间复杂度越低，算法所需额外空间越少 。常见的空间复杂度有O(1)、O(logn)、O(n)等。
在数据库查询中，经常需要对结果进行排序，以便用户能够快速找到所需信息。排序算 法的效率直接影响到查询的响应时间。
索引与排序
数据库索引能够提高查询效率，但同时也需要考虑到排序的需求。合理地设计索引结构 ，可以加速排序操作。
搜索引擎中的排序
相关性排序
搜索引擎的核心功能是根据用户输入的 关键词，返回最相关的网页。排序算法 需要综合考虑网页内容、关键词密度、 链接关系等因素。
VS
广告与排序
搜索引擎中的广告通常会根据关键词的竞 价和相关性进行排序，以达到最佳的广告 效果。
程序中的排序应用
数组排序
在程序中处理数组时，经常需要对其进行排 序。不同的排序算法适用于不同类型的数据 和场景，如快速排序、归并排序等。
数据可视化中的排序
在数据可视化中，需要对数据进行排序以生 成图表。例如，柱状图、饼图等都需要对数 据进行排序处理。
《数据结构》排序》PPT课件.ppt
结束
结束
[50 65] 76 [97]
50 [65]
结束
结束
[13 38 38 49 50 65 76 97]
(b) 快速排序的全过程
图9.4 快速排序示例
算法9.4 快速排序算法。
void Quick_Sort(NODE array[],int start,int end)
/* 对从array[start]到array[end]的记录快速排序 */
}
}
9.1.2 希尔排序
希尔排序是一种步长递减的插入排序，又称为
“缩小增量排序”。该排序方法是，将直接插入分成插入 步长由大到小不同的若干趟来进行。初始，步长较大，相 当于把待排记录序列分成若干子序列，各子序列中记录的 间隔为步长距离，由于子序列的长度小，所以子序列的插 入排序的效率较高。以后各趟逐步减小步长，随着步长的 减小，子序列的长度在增加，但子序列中包含了上一趟经 过大的步长插入排序的结点，因此，已有部分结点有序， 这样，在排序中记录移动的次数就少，排序的效率也就高。 最后一趟是步长为1，即：对整个序列直接插入排序，但 这时整个序列已基本有序，只要做少量记录移动，就可将 该序列排成有序。
问题，但它的排序速度要比直接插 入排序快，另外，它是一种不稳定 排序
9.2 交换排序
交换排序基本思想：比较二个待排序记录的关键字， 若为逆序，则交换位置，反之，保持原序。
9.2.1 冒泡(简单交换排序)
冒泡排序的方法是：首先比较array[n-1].key和array[n-2]. key，若为逆序则交换之，然后比较array[n-2].key和array[n3].key，依此类推，直到比较array[1].key和array[0].key，称为 一趟“冒泡”，其结果是将具有最小关键字的记录排到序列 的第1个位置上。然后再array[n-1]到array[1]之间进行一趟“ 冒泡”，将具有次小关键字的记录排到序列的第2个位置上。 依此类推，直到第n-1趟，在array[n-1]和array[n-2]之间进行“ 冒泡”后，待排序序列已排成有序。
第10章排序4-归并与基数排序-PPT资料30页
4
13 49 65 97
j
7 76 80
0
C
k
1
2
3
4
5
6
7
7 13 49 65 76 80
14
0
A
B
0
C
i
1
2
3
4
13 49 65 97
j 7 76 80
至此 B 表的元素 都已移入 C 表， 只需将 A 表的剩 余部分移入 C 表 即可。
k
1
2
3
4
5
6
7
7 13 49 65 76 80
15
0
不稳定
希尔排序 O(n1.5)
O(1)
不稳定
快速排序 堆排序 归并排序 基数排序
O(nlog2n) O(nlog2n) O(nlog2n) O(d(n+r))
O(n2) 同平均 同平均 同平均
同平均 同平均 同平均 同平均
O(log2n) O(1) O(n) O(n+r)
不稳定 不稳定 稳定 稳定
作业
e[0] e[1] e[2] e[3] e[4] e[5] e[6] e[7] e[8] e[9]
109
589
二
趟 008
269
184
分
配 505
930
063 278 083
f[0] f[1] f[2] f[3] f[4] f[5] f[6] f[7] f[8] f[9]
二趟收集： 505 008 109 930 063 269 278 083 184 589
j
7 76 80
0
1
k
2
基数排序课件
首先以静态链表存储n个待排元素，并令表头指针指向第 一个记录，如图（a）
278 109 063 930 589 184 （a） 505 269 008 083
第一趟分配对最低位关键字（个位数）进行，改变记录 的指针值将链表中的记录分配至10个链队列中去，每个 队列中的记录关键字的个位数相等，如图(b)所示，其中 f[i]和e[i]分别为第i个队列的头指针和尾指针；第一趟收 集是改变所有非空队列的队尾记录的指针域，令其指向 下一个非空队列的队头记录，重新将10个队列中的记录 链成一个链表，如图(c)所示；
e[1]
e[2]
e[3]
e[4]
e[5]
e[6]
e[7]
e[8] 589
e[9]
269 930 f[1] f[2] f[3] f[4] f[5] 063 f[6] 278 f[7]
184 083 f[8] f[9]
d
008 109 930 063 269 278 083 184 589
e
2.链式基数排序的实现
g
①数据类型的定义
#define MAX_NUM_OF_KEY 8 //关键字项数的最大值 #define RADIX 10 //关键字基数，此时是十进制整数的基数 #define MAX_SPACE 10000 typedef struct { KeyType keys[MAX_NUM_OF_KEY]; //关键字 InfoType otheritems; //其他数据项 int next; } SLCell; //静态链表的结点类型 typedef struct { SLCell r[MAX_SPACE]; //静态链表的可利用空间，r[0]为头结点 int keynum; //记录的当前关键字个数 int recnum; //静态链表的当前长度 } SLList; //静态链表类型 typedef int ArrType[RADIX]; //指针数组类型
278 109 063 930 589 184 （a） 505 269 008 083
第一趟分配对最低位关键字（个位数）进行，改变记录 的指针值将链表中的记录分配至10个链队列中去，每个 队列中的记录关键字的个位数相等，如图(b)所示，其中 f[i]和e[i]分别为第i个队列的头指针和尾指针；第一趟收 集是改变所有非空队列的队尾记录的指针域，令其指向 下一个非空队列的队头记录，重新将10个队列中的记录 链成一个链表，如图(c)所示；
e[1]
e[2]
e[3]
e[4]
e[5]
e[6]
e[7]
e[8] 589
e[9]
269 930 f[1] f[2] f[3] f[4] f[5] 063 f[6] 278 f[7]
184 083 f[8] f[9]
d
008 109 930 063 269 278 083 184 589
e
2.链式基数排序的实现
g
①数据类型的定义
#define MAX_NUM_OF_KEY 8 //关键字项数的最大值 #define RADIX 10 //关键字基数，此时是十进制整数的基数 #define MAX_SPACE 10000 typedef struct { KeyType keys[MAX_NUM_OF_KEY]; //关键字 InfoType otheritems; //其他数据项 int next; } SLCell; //静态链表的结点类型 typedef struct { SLCell r[MAX_SPACE]; //静态链表的可利用空间，r[0]为头结点 int keynum; //记录的当前关键字个数 int recnum; //静态链表的当前长度 } SLList; //静态链表类型 typedef int ArrType[RADIX]; //指针数组类型
《数据结构排序》PPT课件
• 折半插入排序是一个稳定的排序方法。
精选课件
22
讨论：若记录是链表结构，用直接插入排序行否？折半插入 排序呢？
答：直接插入不仅可行，而且还无需移动元素，时间效率更 高！但链表无法“折半”！
折半插入排序的改进——2-路插入排序见教材P267。 （1）基本思想： P267 （2）举 例：P268 图10.2 （3）算法分析：移动记录的次数约为n2/8
{ L.r[0] = L.r[ i ]； // 将L.r [i] 暂存到L.r[0]
low=1；high=i-1；
while (low<=high) // 比较，折半查找插入位置
{ m=(low+high)/2； // 折半
if (LT(L.r[0].key,L.r[m].key)) high=m-1；//插入点在低半区
//r[0]一般作哨兵或缓冲区
int length ; //顺序表的长度
}SqList ;
精选课件
7
7. 内部排序的算法有哪些？
——按排序的规则不同，可分为5类： • 插入排序 • 交换排序（重点是快速排序） • 选择排序 • 归并排序 • 基数排序
——按排序算法的时间复杂度不同，可分为3类： •简单的排序算法：时间效率低，O(n2) •先进的排序算法: 时间效率高，O( nlog2n ) •基数排序算法：时间效率高，O( d×n)
技巧：子序列的构成不是简单地“逐段分割”，而是将 相隔某个增量dk的记录组成一个子序列,让增量dk逐趟 缩短（例如依次取5,3,1），直到dk＝1为止。
优点：让关键字值小的元素能很快前移，且序列若基本 有序时，再用直接插入排序处理，时间效率会高很多。
精选课件
24
精选课件
22
讨论：若记录是链表结构，用直接插入排序行否？折半插入 排序呢？
答：直接插入不仅可行，而且还无需移动元素，时间效率更 高！但链表无法“折半”！
折半插入排序的改进——2-路插入排序见教材P267。 （1）基本思想： P267 （2）举 例：P268 图10.2 （3）算法分析：移动记录的次数约为n2/8
{ L.r[0] = L.r[ i ]； // 将L.r [i] 暂存到L.r[0]
low=1；high=i-1；
while (low<=high) // 比较，折半查找插入位置
{ m=(low+high)/2； // 折半
if (LT(L.r[0].key,L.r[m].key)) high=m-1；//插入点在低半区
//r[0]一般作哨兵或缓冲区
int length ; //顺序表的长度
}SqList ;
精选课件
7
7. 内部排序的算法有哪些？
——按排序的规则不同，可分为5类： • 插入排序 • 交换排序（重点是快速排序） • 选择排序 • 归并排序 • 基数排序
——按排序算法的时间复杂度不同，可分为3类： •简单的排序算法：时间效率低，O(n2) •先进的排序算法: 时间效率高，O( nlog2n ) •基数排序算法：时间效率高，O( d×n)
技巧：子序列的构成不是简单地“逐段分割”，而是将 相隔某个增量dk的记录组成一个子序列,让增量dk逐趟 缩短（例如依次取5,3,1），直到dk＝1为止。
优点：让关键字值小的元素能很快前移，且序列若基本 有序时，再用直接插入排序处理，时间效率会高很多。
精选课件
24
严蔚敏数据结构(排序)ppt课件
j j j ji ij ij ij i i i 1 2 3 4 5 6 7 8 9 10 二趟排序：13 4 48 38 27 49 55 65 97 76
❖希尔排序特点
子序列的构成不是简单的“逐段分割”， 而是将相隔某个增量的记录组成一个子序 列
希尔排序可提高排序速度，因为
分组后n值减小，n²更小，而T(n)=O(n²), 所以T(n)从总体上看是减小了
i i i iij j j j j 完成一趟排序： ( 27 38 13) 49 (76 97 65 50)
分别进行快速排序： ( 13) 27 (38) 49 (50 65) 76 (97)
快速排序结束： 13 27 38 49 50 65 76 97
x.key=49 例 初始关键字： 2479 38 1635 4997 76 9173 6257 50
i=8 20 (6
i=8 20 (6
13 30 39 42 70 85 ) 20
13 30 39 m
13 302 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 )
kik2i+1
(i=1,2,…...n/2)
例 （96，83，27，38，11，9） 例 （13，38，27，50，76，65，49，97）
96
13
83
27
38
27
38 11 9
50 76 65 49
97
可将堆序列看成完全二叉树，则堆顶 元素（完全二叉树的根）必为序列中 n个元素的最小值或最大值
❖堆排序：将无序序列建成一个堆，得到关键字最小 （或最大）的记录；输出堆顶的最小（大）值后，使 剩余的n-1个元素重又建成一个堆，则可得到n个元素 的次小值；重复执行，得到一个有序序列，这个过程 叫~
《数据结构》排序》课件
遍历数组，两两比较并交换元素位
置，重复执行直到排序完成。
3
时间复杂度分析
最好情况下O(n)，最坏情况和平均
优化方法
4
情况下为O(n^2)。
加入标记位，如果某次遍历中没有 发生交换，则表示已排序完成。
插入排序
基本思想
将数组分为已排序 和未排序两部分， 每次从未排序中取 出一个元素插入到 已排序的合适位置。
感谢阅读。
的元素，放到已排序的末尾。
每次遍历未排序部分，找到最小
（或最大）的元素，放到已排序部
分末尾。
3
堆排序
使用堆数据结构进行排序，每次选
取堆顶元素，调整堆结构，重复执
时间复杂度分析
4
行直到排序完成。
最坏情况下为O(n^2)，平均情况下
为O(n^2)。
5
优化方法
使用堆排序技巧，优化选择的效率。
快速排序
1
实现流程
时间复杂度
不同排序算法的时间复 杂度对比。
空间复杂度
不同排序算法的空间复 杂度对比。
稳定性
不同排序算法在相同元 素排序时的稳定性对比。
结语
通过本课件，您了解了不同排序算法的原理、实现和优化。在实际应用中， 选择合适的排序算法非常重要。希望本课件能为您的学习和实践提供有价值 的指导。
让我们继续深入学习！
直接插入排 序
逐个遍历未排序元 素，依次插入到已 排序序列中正确的 位置。
希尔排序
将数组按一定步长 分组，分组内使用 直接插入排序，不 断缩小步长直到为 1。
时间n^1.3)。
选择排序
1
基本思想
每次从未排序中选择最小（或最大）
直接选择排序
数据结构-排序PPT课件
平均情况时间复杂度
O(nlogn)，归并排序的平均时间复杂度为O(nlogn)。其中，n为待排序序列的长度。
06
基数排序
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
分配和收集
基数排序是一种稳定的排序算法，即相同的元素在排序后仍保持原有的顺序。
文件系统需要对文件和目录进行排序，以便用户可以更方便地浏览和管理文件。
数据挖掘和分析中需要对数据进行排序，以便发现数据中的模式和趋势。
计算机图形学中需要对图形数据进行排序，以便进行高效的渲染和操作。
数据库系统
文件系统
数据挖掘和分析
计算机图形学
02
插入排序
将待排序的元素按其排序码的大小，逐个插入到已经排好序的有序序列中，直到所有元素插入完毕。
简单选择排序
基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。 时间复杂度：堆排序的时间复杂度为O(nlogn)，其中n为待排序元素的个数。 稳定性：堆排序是不稳定的排序算法。 优点：堆排序在最坏的情况下也能保证时间复杂度为O(nlogn)，并且其空间复杂度为O(1)，是一种效率较高的排序算法。
基数排序的实现过程
空间复杂度
基数排序的空间复杂度为O(n+k)，其中n为待排序数组的长度，k为计数数组的长度。
时间复杂度
基数排序的时间复杂度为O(d(n+k))，其中d为最大位数，n为待排序数组的长度，k为计数数组的长度。
适用场景
当待排序数组的元素位数较少且范围较小时，基数排序具有较高的效率。然而，当元素位数较多或范围较大时，基数排序可能不是最优选择。
O(nlogn)，归并排序的平均时间复杂度为O(nlogn)。其中，n为待排序序列的长度。
06
基数排序
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
分配和收集
基数排序是一种稳定的排序算法，即相同的元素在排序后仍保持原有的顺序。
文件系统需要对文件和目录进行排序，以便用户可以更方便地浏览和管理文件。
数据挖掘和分析中需要对数据进行排序，以便发现数据中的模式和趋势。
计算机图形学中需要对图形数据进行排序，以便进行高效的渲染和操作。
数据库系统
文件系统
数据挖掘和分析
计算机图形学
02
插入排序
将待排序的元素按其排序码的大小，逐个插入到已经排好序的有序序列中，直到所有元素插入完毕。
简单选择排序
基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。 时间复杂度：堆排序的时间复杂度为O(nlogn)，其中n为待排序元素的个数。 稳定性：堆排序是不稳定的排序算法。 优点：堆排序在最坏的情况下也能保证时间复杂度为O(nlogn)，并且其空间复杂度为O(1)，是一种效率较高的排序算法。
基数排序的实现过程
空间复杂度
基数排序的空间复杂度为O(n+k)，其中n为待排序数组的长度，k为计数数组的长度。
时间复杂度
基数排序的时间复杂度为O(d(n+k))，其中d为最大位数，n为待排序数组的长度，k为计数数组的长度。
适用场景
当待排序数组的元素位数较少且范围较小时，基数排序具有较高的效率。然而，当元素位数较多或范围较大时，基数排序可能不是最优选择。
基数排序ppt
p=pp=p->next;
//从单链表中获取下一个结点 //从单链表中获取下一个结点
} m=m*10; n=n*10; "收集"操作 收集" "收集"操作实际上就是将非空队列首尾 收集" 相接.具体操作可以这样实现: 相接.具体操作可以这样实现: h=NULL; p=NULL; for(j=0;j<r;j++) if (f[j]) { if (!h) { h=f[j];p =t[j]; } else {p->next=f[j];p=t[j];} {p}
for(j=0;j<r;j++) for(j=0;j<r;j++){f[j]=NULL;t[j]=NULL;} "分配"操作 分配" 分配"过程可以描述为: "分配"过程可以描述为:逐个从单链表中取出待 分配的结点,并分离出关键字的相应位,然后, 分配的结点,并分离出关键字的相应位,然后,按照此位 的数值将其插入到相应的队列中. 的数值将其插入到相应的队列中. 下面我们以3位整型数值为例, 下面我们以3位整型数值为例,说明应该如何分离 出相应的关键字位? 出相应的关键字位? 若将3位整型数值的每一位分离出来, 若将3位整型数值的每一位分离出来,可以这样操 作: 次分离的关键字位(个位): ):k=key%10; 第1次分离的关键字位(个位):k=key%10; 次分离的关键字位(十位): 第2次分离的关键字位(十位): k=key%100/10; 次分离的关键字位(百位): 第3次分离的关键字位(百位): k=key%1000/100; …… 次分离的关键字位: 第i次分离的关键字位:k=key%10i/10i-1
第10章内排序第6讲-基数排序
//对于原链表中每个结点循环
{ k=p->data[i]-'0'; //找第k个链队
if (head[k]==NULL) //进行分配，即采用尾插法建立单链表
{ head[k]=p; tail[k]=p; }
else
{ tail[k]->next=p; tail[k]=p; }
p=p->next;
//取下一个待排序的结点
第1趟排序完毕
4/15
p →230 →367 →167 →237 →138 →369 →239 →139
进行第2次分配：按拾位
f[3] →230 →237 →138 →239 →139 ← r[3]
f[6] →367 →167 →369
← r[638 →239 →139 →367 →167 →369
12/15
13/15
14/15
━━本讲完━━
15/15
//线性表中最多元素个数 //基数的最大取值 //关键字位数的最大取值
//记录的关键字定义的字符串
//单链表中每个结点的类型
p
a1
a2
a3
…
基数排序数据的存储结构
an ∧ 8/15
void RadixSort(RecType1 *&p，int r，int d)
//p为待排序序列链表指针，r为基数，d为关键字位数
}
分配
9/15
p=NULL; for (j=0;j<r;j++) //对于每一个链队循环进行收集
if (head[j]!=NULL) { if (p==NULL)
{ p=head[j]; t=tail[j];
相关主题
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程的内容
第10章 内部排序
10.1 概述 10.2 插入排序 10.3 交换排序 10.4 选择排序 10.5 归并排序 10.6 基数排序
10.1 概述
1. 什么是排序？ 将一组杂乱无章的数据按一定的规律顺次排列起
来。
存放在数据表中
按关键字排序
2. 排序的目的是什么？ ——便于查找！
int length ; //顺序表的长度
}SqList ;
7. 内部排序的算法有哪些？
——按排序的规则不同，可分为5类： • 插入排序 • 交换排序（重点是快速排序） • 选择排序 • 归并排序 • 基数排序
——按排序算法的时间复杂度不同，可分为3类： •简单的排序算法：时间效率低，O(n2) •先进的排序算法: 时间效率高，O( nlog2n ) •基数排序算法：时间效率高，O( d×n)
1) 直接插入排序
最简单的排序法！
新元素插入到哪里？ 在已形成的有序表中线性查找，并在
适当位置插入，把原来位置上的元素向后顺移。
例1：关键字序列T=（13，6，3，31，9，27，5，11），
请写出直接插入排序的中间过程序列。
【13】, 6, 3, 31, 9, 27, 5, 11 【6, 13】, 3, 31, 9, 27, 5, 11 【3, 6, 13】, 31, 9, 27, 5, 11 【3, 6, 13，31】, 9, 27, 5, 11 【3, 6, 9, 13，31】, 27, 5, 11 【3, 6, 9, 13，27, 31】, 5, 11 【3, 5, 6, 9, 13，27, 31】, 11 【3, 5, 6, 9, 11，13，27, 31】
//定义每个记录（数据元素）的结构
KeyType key ;
//关键字
InfoType otherinfo; //其它数据项
}RecordType ;
Typedef struct {
//定义顺序表的结构
RecordType r [ MAXSIZE +1 ]; //存储顺序表的向量
//r[0]一般作哨兵或缓冲区
10.1 概述
3.排序算法的好坏如何衡量？ • 时间效率 —— 排序速度（即排序所花费的全部比较次数） • 空间效率 —— 占内存辅助空间的大小
若排序算法所需的辅助空间不依赖问题的规模n， 即空间复杂度是O(1) ，则称排序方法是就地排序，否 则是非就地排序。
• 稳 定 性 —— 若两个记录A和B的关键字值相等，但排序
不需要增加辅助空间
若设待排序的对象个数为n，则算法需要进行n1次插入。
最好情况下，排序前对象已经按关键码大小从 小到大有序，每趟只需与前面的有序对象序列 的最后一个对象的关键码比较 1 次，对象不需 要移动 。因此，总的关键码比较次数为n-1。
• 最坏情况下，第i趟插入时，第i个对象必须与 前面i-1个对象都做关键码比较，并且每做 1 次比较就要做 1 次数据移动。则总的关键码比 较次数KCN和对象移动次数RMN分别为
214569*
49 08
0 123456
完成!
i=1 i=2 i=3 i=4 i=5 i=6
时间效率： O(n2)——因为在最坏情况下，所有元素的比较
次数总和为（0＋1＋…＋n-1)→O(n2)。其他情况
下还要加上移动元素的次数。
空间效率：O（1）——因为仅占用1个缓冲单元
算法的稳定性：稳定——因为25*排序后仍然在25的后面。
后A、B的先后次序保持不变，则称这种排序算法是稳定的。
4. 什么叫内部排序？什么叫外部排序？ —— 若待排序记录都在内存中，称为内部排序；
内部排序基本操作有两种： ◆ 比较两个关键字的大小；(比不可少的操作) ◆ 存储位置的移动。
—— 若待排序记录一部分在内存，一部分在外存， 则称为外部排序。
注：外部排序时，要将数据分批调入内存来 排序，中间结果还要及时放入外存，显然外 部排序要复杂得多。
5.待排序记录在内存中怎样存储和处理？
处理方式： ① 顺序排序 —— 数据间的逻辑顺序关系通过其物理
存储位置的相邻来体现，排序时直接移动记录； 适合数据较少的情况！
② 链表排序 ——数据间的逻辑顺序关系通过结点中 的指针体现，排序时只修改指针，不移动数据；
③ 地址排序 —— 数据存储在一段连续地址的空间， 构造一个辅助表保持各数据的存放地址（指针），排 序时先修改辅助表中的地址，最后再移动记录。
例2：关键字序列T= （21，25，49，25*，16，08），
请写出直接插入排序的具体实现过程。 *表示后一个25
解：假设该序列已存入一维数组V[7]中，将V[0]作为缓冲或 暂存单元（Temp）。则程序执行过程为：
初态：
22410暂存55698*
021816
21516
2425591*
2459*
d＝关键字的位数(长度)
10.2 插入排序
插入排序的基本思想是：每步将一个待排序的对象， 按其关键码大小，插入到前面已经排好序的一组对象 的适当位置上，直到对象全部插入为止。
简言之，边插入边排序，保证子序列中随时都是排好序的。
插入排序有多种具体实现算法： 1) 直接插入排序 2) 折半插入排序 3) 2路插入排序 4) 希尔排序
// 复制为哨兵
L.r[i] = L.r[i-1]; for( j=i-2; LT(L.r[0].key,L.r[i].key);--j )
L.r[ j+1] = L.r[ j]; // 记录后移 L.r[ j+1] = L.r[0]; // 插入到正确位置
}
} // InsertSort
直接插入排序的算法分析
② ③适合数据较多的情况!
6. 顺序存储（顺序表）的抽象数据类型如何表示？
注：大多数排序算法都是针对顺序表结构的(便于直接移动元素)
# define MAXSIZE 20 //设记录不超过20个 typedef int KeyType ; //设关键字为整型量（int型）
Typedef struct {
对应程序参SqList &L)
{ // 对顺序表L做直接插入排序
for ( i=2; i<=L.length; ++i )
if ( LT(L.r[i].key,L.r[i-1].key) )
// “<“,需将L.r[i]插入有序子表
{ L.r[0] = L.r[i];
第10章 内部排序
10.1 概述 10.2 插入排序 10.3 交换排序 10.4 选择排序 10.5 归并排序 10.6 基数排序
10.1 概述
1. 什么是排序？ 将一组杂乱无章的数据按一定的规律顺次排列起
来。
存放在数据表中
按关键字排序
2. 排序的目的是什么？ ——便于查找！
int length ; //顺序表的长度
}SqList ;
7. 内部排序的算法有哪些？
——按排序的规则不同，可分为5类： • 插入排序 • 交换排序（重点是快速排序） • 选择排序 • 归并排序 • 基数排序
——按排序算法的时间复杂度不同，可分为3类： •简单的排序算法：时间效率低，O(n2) •先进的排序算法: 时间效率高，O( nlog2n ) •基数排序算法：时间效率高，O( d×n)
1) 直接插入排序
最简单的排序法！
新元素插入到哪里？ 在已形成的有序表中线性查找，并在
适当位置插入，把原来位置上的元素向后顺移。
例1：关键字序列T=（13，6，3，31，9，27，5，11），
请写出直接插入排序的中间过程序列。
【13】, 6, 3, 31, 9, 27, 5, 11 【6, 13】, 3, 31, 9, 27, 5, 11 【3, 6, 13】, 31, 9, 27, 5, 11 【3, 6, 13，31】, 9, 27, 5, 11 【3, 6, 9, 13，31】, 27, 5, 11 【3, 6, 9, 13，27, 31】, 5, 11 【3, 5, 6, 9, 13，27, 31】, 11 【3, 5, 6, 9, 11，13，27, 31】
//定义每个记录（数据元素）的结构
KeyType key ;
//关键字
InfoType otherinfo; //其它数据项
}RecordType ;
Typedef struct {
//定义顺序表的结构
RecordType r [ MAXSIZE +1 ]; //存储顺序表的向量
//r[0]一般作哨兵或缓冲区
10.1 概述
3.排序算法的好坏如何衡量？ • 时间效率 —— 排序速度（即排序所花费的全部比较次数） • 空间效率 —— 占内存辅助空间的大小
若排序算法所需的辅助空间不依赖问题的规模n， 即空间复杂度是O(1) ，则称排序方法是就地排序，否 则是非就地排序。
• 稳 定 性 —— 若两个记录A和B的关键字值相等，但排序
不需要增加辅助空间
若设待排序的对象个数为n，则算法需要进行n1次插入。
最好情况下，排序前对象已经按关键码大小从 小到大有序，每趟只需与前面的有序对象序列 的最后一个对象的关键码比较 1 次，对象不需 要移动 。因此，总的关键码比较次数为n-1。
• 最坏情况下，第i趟插入时，第i个对象必须与 前面i-1个对象都做关键码比较，并且每做 1 次比较就要做 1 次数据移动。则总的关键码比 较次数KCN和对象移动次数RMN分别为
214569*
49 08
0 123456
完成!
i=1 i=2 i=3 i=4 i=5 i=6
时间效率： O(n2)——因为在最坏情况下，所有元素的比较
次数总和为（0＋1＋…＋n-1)→O(n2)。其他情况
下还要加上移动元素的次数。
空间效率：O（1）——因为仅占用1个缓冲单元
算法的稳定性：稳定——因为25*排序后仍然在25的后面。
后A、B的先后次序保持不变，则称这种排序算法是稳定的。
4. 什么叫内部排序？什么叫外部排序？ —— 若待排序记录都在内存中，称为内部排序；
内部排序基本操作有两种： ◆ 比较两个关键字的大小；(比不可少的操作) ◆ 存储位置的移动。
—— 若待排序记录一部分在内存，一部分在外存， 则称为外部排序。
注：外部排序时，要将数据分批调入内存来 排序，中间结果还要及时放入外存，显然外 部排序要复杂得多。
5.待排序记录在内存中怎样存储和处理？
处理方式： ① 顺序排序 —— 数据间的逻辑顺序关系通过其物理
存储位置的相邻来体现，排序时直接移动记录； 适合数据较少的情况！
② 链表排序 ——数据间的逻辑顺序关系通过结点中 的指针体现，排序时只修改指针，不移动数据；
③ 地址排序 —— 数据存储在一段连续地址的空间， 构造一个辅助表保持各数据的存放地址（指针），排 序时先修改辅助表中的地址，最后再移动记录。
例2：关键字序列T= （21，25，49，25*，16，08），
请写出直接插入排序的具体实现过程。 *表示后一个25
解：假设该序列已存入一维数组V[7]中，将V[0]作为缓冲或 暂存单元（Temp）。则程序执行过程为：
初态：
22410暂存55698*
021816
21516
2425591*
2459*
d＝关键字的位数(长度)
10.2 插入排序
插入排序的基本思想是：每步将一个待排序的对象， 按其关键码大小，插入到前面已经排好序的一组对象 的适当位置上，直到对象全部插入为止。
简言之，边插入边排序，保证子序列中随时都是排好序的。
插入排序有多种具体实现算法： 1) 直接插入排序 2) 折半插入排序 3) 2路插入排序 4) 希尔排序
// 复制为哨兵
L.r[i] = L.r[i-1]; for( j=i-2; LT(L.r[0].key,L.r[i].key);--j )
L.r[ j+1] = L.r[ j]; // 记录后移 L.r[ j+1] = L.r[0]; // 插入到正确位置
}
} // InsertSort
直接插入排序的算法分析
② ③适合数据较多的情况!
6. 顺序存储（顺序表）的抽象数据类型如何表示？
注：大多数排序算法都是针对顺序表结构的(便于直接移动元素)
# define MAXSIZE 20 //设记录不超过20个 typedef int KeyType ; //设关键字为整型量（int型）
Typedef struct {
对应程序参SqList &L)
{ // 对顺序表L做直接插入排序
for ( i=2; i<=L.length; ++i )
if ( LT(L.r[i].key,L.r[i-1].key) )
// “<“,需将L.r[i]插入有序子表
{ L.r[0] = L.r[i];