归并排序PPT课件
合集下载
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
信息学奥林匹克竞赛(入门)——归并排序算法精讲 课件
四组为“第二层”，如下：
19
排序算法——归并排序
15
37
12
25
归并排序算法精讲
-Example 2
第三步：分解
• 继续分解，此时只剩下19、15这一组可以分解，分解成19、15，
这两组为“第三层”，如下：
19
排序算法——归并排序
15
归并排序算法精讲
-Example 2
第四步：归并
• 由于所有组都已经分解成只有1个元素，开始进行归并，从“高
法，该算法是采用分治法（Divide and Conquer）的一个非常典型
的应用。将已有序的子序列合并，得到完全有序的序列。
• 历史：1945年，冯•诺依曼提出归并排序。
• 算法流程：
• 将数组[1, ]排序问题分解为[1,
2
]和[
• 递归解决子问题得到两个有序的子数组
• 将两个有序子数组合并为一个有序数组
• 后续策略：
• 逐一合并，比较27次
• 两两合并：比较24次
策略名称
4位选手
8位选手
16位选手
逐一合并
27次
105次
405次
两两合并
24次
72次
192次
求解杠铃增重问题的两两合并策略对排序问题有何启发？
排序算法——归并排序
归并排序算法精讲
-归并排序
归并排序
• 定义：归并排序是建立在归并操作上的一种有效，稳定的排序算
Example 1
• 杠铃增重问题
• 每位参赛运动员向组委会提交排好序的三次试举重量
• 杠铃增重顺序：
问题：组委会如何根据试举重量安排杠铃增重顺序？
排序算法——归并排序
19
排序算法——归并排序
15
37
12
25
归并排序算法精讲
-Example 2
第三步：分解
• 继续分解，此时只剩下19、15这一组可以分解，分解成19、15，
这两组为“第三层”，如下：
19
排序算法——归并排序
15
归并排序算法精讲
-Example 2
第四步：归并
• 由于所有组都已经分解成只有1个元素，开始进行归并，从“高
法，该算法是采用分治法（Divide and Conquer）的一个非常典型
的应用。将已有序的子序列合并，得到完全有序的序列。
• 历史：1945年，冯•诺依曼提出归并排序。
• 算法流程：
• 将数组[1, ]排序问题分解为[1,
2
]和[
• 递归解决子问题得到两个有序的子数组
• 将两个有序子数组合并为一个有序数组
• 后续策略：
• 逐一合并，比较27次
• 两两合并：比较24次
策略名称
4位选手
8位选手
16位选手
逐一合并
27次
105次
405次
两两合并
24次
72次
192次
求解杠铃增重问题的两两合并策略对排序问题有何启发？
排序算法——归并排序
归并排序算法精讲
-归并排序
归并排序
• 定义：归并排序是建立在归并操作上的一种有效，稳定的排序算
Example 1
• 杠铃增重问题
• 每位参赛运动员向组委会提交排好序的三次试举重量
• 杠铃增重顺序：
问题：组委会如何根据试举重量安排杠铃增重顺序？
排序算法——归并排序
概述插入排序交换排序选择排序归并排序基数排序外排序课件
• 原理：关键码相同的两个对象，在整 个排序过程中，不会通过比较而相互 交换。
链表插入排序
• 基本思想：用链表来表示已排序的 数据对象，当插入V[i]时，依次在链 表中检查，找到V[i]应插入的位置， 并修改相应的链接指针。如此重复 ，直到V[n]也插入到链表中排好序为 止。
链表插入排序的数据结构
}
链表插入排序的时间复杂度
• 考虑关键码的比较次数和对象移动次 数
1. KCN 最小为n-1，最大为 n (n-1)/2 2. 对象移动次数为0 。
链表插入排序方法是稳定的。
希尔排序
• 1959年由D.L. Shell提出，又称缩小 增量排序(Diminishing-increment sort) 。
希尔排序示例
i (0) (1) (2) (3) (4) (5) gap
21 25 49 25* 16 08
1 21 - - 25*
3
25 - - 16
49 - - 08
21 16 08 25* 25 49
2 21 - 08 - 25
2
16 - 25* - 49
08 16 21 25* 25 49
3 08 16 21 25* 25 49 1
• 内排序与外排序 区分标准：排序过程是
否全部在内存进行。
• 排序的时间开销 它是衡量算法好坏的最
重要的标志。通常用算法执行中的数据比较 次数和数据移动次数来衡量
静态排序中的数据表的类定义 const int DefaultSize = 100; Template <class Type> class datalist; Template<class Type>class Element{ friend calss datalist<Type>; private:
链表插入排序
• 基本思想：用链表来表示已排序的 数据对象，当插入V[i]时，依次在链 表中检查，找到V[i]应插入的位置， 并修改相应的链接指针。如此重复 ，直到V[n]也插入到链表中排好序为 止。
链表插入排序的数据结构
}
链表插入排序的时间复杂度
• 考虑关键码的比较次数和对象移动次 数
1. KCN 最小为n-1，最大为 n (n-1)/2 2. 对象移动次数为0 。
链表插入排序方法是稳定的。
希尔排序
• 1959年由D.L. Shell提出，又称缩小 增量排序(Diminishing-increment sort) 。
希尔排序示例
i (0) (1) (2) (3) (4) (5) gap
21 25 49 25* 16 08
1 21 - - 25*
3
25 - - 16
49 - - 08
21 16 08 25* 25 49
2 21 - 08 - 25
2
16 - 25* - 49
08 16 21 25* 25 49
3 08 16 21 25* 25 49 1
• 内排序与外排序 区分标准：排序过程是
否全部在内存进行。
• 排序的时间开销 它是衡量算法好坏的最
重要的标志。通常用算法执行中的数据比较 次数和数据移动次数来衡量
静态排序中的数据表的类定义 const int DefaultSize = 100; Template <class Type> class datalist; Template<class Type>class Element{ friend calss datalist<Type>; private:
数学排序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 归并排序
归并排序的原理
归并排序是一种分治策略的排序算法，它将待排序序列分成若干个子序 列，然后分别对子序列进行排序，最后将排好序的子序列合并成一个有 序序列。
《数据结构》排序》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]之间进行“ 冒泡”后，待排序序列已排成有序。
算法21--内部排序--归并排序
2019/10/20
实现这种递归调用的关键是为过程建立递归调用工作栈。通 常，在一个过程中调用另一过程时，系统需在运行被调用过 程之前先完成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
代入法解递归方程
方法的关键步骤在于预先对解答作出推测，然后用 数学归纳法证明推测的正确性。
实现这种递归调用的关键是为过程建立递归调用工作栈。通 常，在一个过程中调用另一过程时，系统需在运行被调用过 程之前先完成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
代入法解递归方程
方法的关键步骤在于预先对解答作出推测，然后用 数学归纳法证明推测的正确性。
第13周内排序第5讲-归并排序
归并排序是多次将相邻两个或两个以上的有序表合并成一个新的有序表。
最简单的归并是将相邻两个有序的子表合并成一个有序的表，即二路归并排序。
1、归并的思路一次二路归并：将两个位置相邻的记录有序子序列归并为一个记录的有序序列。
有序序列R [low..high]有序子序列R [low..mid]有序子序列R [mid+1..high]R [low..high]void Merge (RecType R[],int low,int mid,int high){RecType *R1;int i=low,j=mid+1,k=0;//k 是R1的下标,i 、j 分别为第1、2段的下标R1=(RecType *)malloc((high-low+1)*sizeof(RecType));while (i<=mid &&j<=high)if (R[i].key<=R[j].key)//将第1段中的记录放入R1中{R1[k]=R[i];i++;k++;}else //将第2段中的记录放入R1中{R1[k]=R[j];j++;k++;} Merge()：一次二路归并，将两个相邻的有序子序列归并为一个有序序列。
空间复杂度为O(high-low+1)2、二路归并算法while(i<=mid)//将第1段余下部分复制到R1{R1[k]=R[i];i++;k++;}while(j<=high)//将第2段余下部分复制到R1{R1[k]=R[j];j++;k++;}for(k=0,i=low;i<=high;k++,i++)//将R1复制回R中R[i]=R1[k];free(R1);}void MergePass(RecType R[],int length,int n){int i;for(i=0;i+2*length-1<n;i=i+2*length)//归并length长的两相邻子表Merge (R,i,i+length-1,i+2*length-1);if(i+length-1<n)//余下两个子表,后者长度小于length Merge(R,i,i+length-1,n-1);//归并这两个子表}MergePass()：一趟二路归并（段长度为length ）。
归并排序PPT课件
.
12
10.6 基数排序
❖ “花色”优先
先分成4堆； 然后，每堆再按“面值”排； 最后，收成一堆。
扑克牌 “排序” 为例
.
13
10.6 基数排序
❖ “面值”优先
先分成13堆； 每堆再按“花色”排；
扑克牌 “排序” 为例
.
14
10.6 基数排序
❖ 多关键码排序
假设有n个记录……的序列 { R1, R2, …，Rn}
.
24
10.6.2 链式基数排序
分配 算法
.
25
10.6.2 链式基数排序
收集 算法
.
26
10.6.2 链式基数排序
❖ 性能分析
若每个关键码有d 位，需要重复执行d 趟“分配” 与“收集”。而每趟对n 个对象进行“分配”， 对r 个队列进行“收集”。总时间复杂度为O(d (n+r))。
若基数r相同，对于数据个数较多而关键码位数
.
5
初始关键字： [49] [38] [65] [97] [76] [13] [27] 一趟归并后： [38 49] [65 97] [13 76] [27] 二趟归并后： [38 49 65 97] [13 27 76] 三趟归并后： [13 27 38 49 65 76 97]
.
6
10.5 归并排序
每个记录Ri中含有d个关键字(Ki0, Ki1, …,Kid-1)。则 有序是指：对于序列中任意两个记录Ri和Rj(1≤i<j≤n) 都满足下列(词典)有序关系：
(Ki0, Ki1, …,Kid-1)< (Kj0, Kj1, …,Kjd-1) 其中K0被称为“最高”位关键字，Kd-1被称为 “最低” 位关键字。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
❖ 基数排序是典型的LSD排序方法，利用“分配” 和“收集”两种运算对单关键码进行排序。
例如：对下列这组关键字（每个关键字有3位） {209, 386, 768, 185, 247, 606, 230, 834, 539 }
.
17
10.6.2 链式基数排序
❖ 基本思想
从关键字的最“低位”开始，将关键字分配到 r(基数）个堆（桶）中；
8
9
分别按“个位”、“十位”、“百位”进行3趟分配 与收集
.
19
10.6.2 链式基数排序
❖ 实现思想
为了便于分配与收集，采用链表为存储结构 r个桶用r个链式队列表示； 收集的时候直接将队列的头尾指针连接实现；
.
15
10.6 基数排序
❖ 多关键码排序
实现多关键码排序通常有两种方法： 低位码优先LSD 高位码优先MSD
( 3 J 8 9 9 3 1 7 )
先按花色： 8 1 3 7 J 9 3 9 再按面值： 1 8 3 7 9 J 3 9
.
16
10.6.2 链式基数排序
❖ 对于单关键字，可以看成是由多个数位构成的 多关键字；
.
12
10.6 基数排序
❖ “花色”优先
先分成4堆； 然后，每堆再按“面值”排； 最后，收成一堆。
扑克牌 “排序” 为例
.
13
10.6 基数排序
❖ “面值”优先
先分成13堆； 每堆再按“花色”排；
扑克牌 “排序” 为例
.
14
10.6 基数排序
❖ 多关键码排序
假设有n个记录……的序列 { R1, R2, …，Rn}
8
10.5 归并排序
❖ 性能分析
算法在执行时，需要占用与原始记录序列 同样数量的存储空间，因此空间复杂度为O(n)。
.
9
10.5 归并排序
❖ 总结
最好、最坏、平均时间复杂度均为O(nlogn); 空间复杂度高，为O(n); 是高效算法中唯一“稳定”的排序方法； 较少用于内部排序，多用于外部排序。
.
10
10.6 基数排序
❖ 基本思想
基数排序是采用“分配”与“收集”的 办法，用对多关键码进行排序的思想实现对 单关键码进行排序的方法。
.
11Leabharlann 10.6 基数排序❖ 多关键码排序问题
以扑克牌排序为例。每张扑克牌有两个 “关键码”：花色和面值。其有序关系为：
花色： 面值：2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A
.
5
初始关键字： [49] [38] [65] [97] [76] [13] [27] 一趟归并后： [38 49] [65 97] [13 76] [27] 二趟归并后： [38 49 65 97] [13 27 76] 三趟归并后： [13 27 38 49 65 76 97]
.
6
10.5 归并排序
每个记录Ri中含有d个关键字(Ki0, Ki1, …,Kid-1)。则 有序是指：对于序列中任意两个记录Ri和Rj(1≤i<j≤n) 都满足下列(词典)有序关系：
(Ki0, Ki1, …,Kid-1)< (Kj0, Kj1, …,Kjd-1) 其中K0被称为“最高”位关键字，Kd-1被称为 “最低” 位关键字。
（5，24，35，74，222） （19，23，30）
(
)
.
2
两路归并动画演示
iii
( 5 24 35 74 222 )
[s]
[m]
jjjj
( 19 23 30 )
[m+1]
[t]
(
)
kk k k k k
.
3
10.5 归并排序
void Merge (int r[ ], int r1[ ], int s, int m, int t ) { /***将有序列r[s..m]和r[m+1..t]两路归并为r1[ ]***/
SR[m+1..t] Merge (TR2, TR1, s, m, t); //归并
}
}
.
7
10.5 归并排序
❖ 性能分析
一趟归并操作是将r[1]~r[n]中相邻的长 度为h的有序序列进行两两归并，这需要O(n) 时间。整个归并排序需要进行log2n趟，因此， 总的时间代价是O(nlog2n)。
.
.
4
10.5 归并排序
❖ 原理
假设初始序列含有n个记录，则可看成n 个有序的子序列，每个子序列长度为1。然后 两两归并，得到n/2个长度为2或1的有序子 序列；再两两归并，……如此重复，直至得 到一个长度为n的有序序列为止。
初始时： [49] [38] [65] [97] [76] [13] [27]
void Msort ( Elem SR[], Elem TR1[], int s, int t ) { /**** 将SR[s..t]进行归并排序为TR1[s..t]****/ if (s==t) TR1[s] = SR[s];
else { m = (s+t)/2; // 将SR[s..t]分割 Msort (SR, TR1, s, m); // 递归地排序子序列SR[s..m] Msort (SR, TR2, m+1, t); //递归地排序子序列
i=s; j=m+1; k=s; while (i<=m && j<=t) { //两表中元素比较
if (r[i]<=r[j]) r1[k++]=r[i++]; else r1[k++]=r[j++]; } while (i<=m) r1[k++]=r[i++]; //前一个子序列剩下的 while (j<=t) r1[k++]=r[j++]; //后一个子序列剩下的 }
10.5 归并排序
❖ 基本思想
将两个或两个以上的有序子序列“归并”为一个 有序序列。
在内部排序中，通常采用的是2-路归并排序。即： 将两个位置相邻的有序子序列归并为一个有序序 列。
有序 有序
r[i] r[m] r[m+1] r[n]
有序
r[i]
r[n]
.
1
10.5 归并排序
❖ 如何进行两路归并？
将两个有序表的元素进行比较，小者复制到 目标表中。
按桶的编号将关键字收集起来；
然后，以“次低位”将关键字又分配到r个桶 中；再收集，……，重复直到“最高位”为止， 这时，以按关键字有序。
.
18
例如：对下列这组关键字进行基数排序 {209, 386, 768, 185, 247, 606, 230, 834, 539 }
基数 为10
0
1
2
3
4
5
6
7
例如：对下列这组关键字（每个关键字有3位） {209, 386, 768, 185, 247, 606, 230, 834, 539 }
.
17
10.6.2 链式基数排序
❖ 基本思想
从关键字的最“低位”开始，将关键字分配到 r(基数）个堆（桶）中；
8
9
分别按“个位”、“十位”、“百位”进行3趟分配 与收集
.
19
10.6.2 链式基数排序
❖ 实现思想
为了便于分配与收集，采用链表为存储结构 r个桶用r个链式队列表示； 收集的时候直接将队列的头尾指针连接实现；
.
15
10.6 基数排序
❖ 多关键码排序
实现多关键码排序通常有两种方法： 低位码优先LSD 高位码优先MSD
( 3 J 8 9 9 3 1 7 )
先按花色： 8 1 3 7 J 9 3 9 再按面值： 1 8 3 7 9 J 3 9
.
16
10.6.2 链式基数排序
❖ 对于单关键字，可以看成是由多个数位构成的 多关键字；
.
12
10.6 基数排序
❖ “花色”优先
先分成4堆； 然后，每堆再按“面值”排； 最后，收成一堆。
扑克牌 “排序” 为例
.
13
10.6 基数排序
❖ “面值”优先
先分成13堆； 每堆再按“花色”排；
扑克牌 “排序” 为例
.
14
10.6 基数排序
❖ 多关键码排序
假设有n个记录……的序列 { R1, R2, …，Rn}
8
10.5 归并排序
❖ 性能分析
算法在执行时，需要占用与原始记录序列 同样数量的存储空间，因此空间复杂度为O(n)。
.
9
10.5 归并排序
❖ 总结
最好、最坏、平均时间复杂度均为O(nlogn); 空间复杂度高，为O(n); 是高效算法中唯一“稳定”的排序方法； 较少用于内部排序，多用于外部排序。
.
10
10.6 基数排序
❖ 基本思想
基数排序是采用“分配”与“收集”的 办法，用对多关键码进行排序的思想实现对 单关键码进行排序的方法。
.
11Leabharlann 10.6 基数排序❖ 多关键码排序问题
以扑克牌排序为例。每张扑克牌有两个 “关键码”：花色和面值。其有序关系为：
花色： 面值：2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A
.
5
初始关键字： [49] [38] [65] [97] [76] [13] [27] 一趟归并后： [38 49] [65 97] [13 76] [27] 二趟归并后： [38 49 65 97] [13 27 76] 三趟归并后： [13 27 38 49 65 76 97]
.
6
10.5 归并排序
每个记录Ri中含有d个关键字(Ki0, Ki1, …,Kid-1)。则 有序是指：对于序列中任意两个记录Ri和Rj(1≤i<j≤n) 都满足下列(词典)有序关系：
(Ki0, Ki1, …,Kid-1)< (Kj0, Kj1, …,Kjd-1) 其中K0被称为“最高”位关键字，Kd-1被称为 “最低” 位关键字。
（5，24，35，74，222） （19，23，30）
(
)
.
2
两路归并动画演示
iii
( 5 24 35 74 222 )
[s]
[m]
jjjj
( 19 23 30 )
[m+1]
[t]
(
)
kk k k k k
.
3
10.5 归并排序
void Merge (int r[ ], int r1[ ], int s, int m, int t ) { /***将有序列r[s..m]和r[m+1..t]两路归并为r1[ ]***/
SR[m+1..t] Merge (TR2, TR1, s, m, t); //归并
}
}
.
7
10.5 归并排序
❖ 性能分析
一趟归并操作是将r[1]~r[n]中相邻的长 度为h的有序序列进行两两归并，这需要O(n) 时间。整个归并排序需要进行log2n趟，因此， 总的时间代价是O(nlog2n)。
.
.
4
10.5 归并排序
❖ 原理
假设初始序列含有n个记录，则可看成n 个有序的子序列，每个子序列长度为1。然后 两两归并，得到n/2个长度为2或1的有序子 序列；再两两归并，……如此重复，直至得 到一个长度为n的有序序列为止。
初始时： [49] [38] [65] [97] [76] [13] [27]
void Msort ( Elem SR[], Elem TR1[], int s, int t ) { /**** 将SR[s..t]进行归并排序为TR1[s..t]****/ if (s==t) TR1[s] = SR[s];
else { m = (s+t)/2; // 将SR[s..t]分割 Msort (SR, TR1, s, m); // 递归地排序子序列SR[s..m] Msort (SR, TR2, m+1, t); //递归地排序子序列
i=s; j=m+1; k=s; while (i<=m && j<=t) { //两表中元素比较
if (r[i]<=r[j]) r1[k++]=r[i++]; else r1[k++]=r[j++]; } while (i<=m) r1[k++]=r[i++]; //前一个子序列剩下的 while (j<=t) r1[k++]=r[j++]; //后一个子序列剩下的 }
10.5 归并排序
❖ 基本思想
将两个或两个以上的有序子序列“归并”为一个 有序序列。
在内部排序中，通常采用的是2-路归并排序。即： 将两个位置相邻的有序子序列归并为一个有序序 列。
有序 有序
r[i] r[m] r[m+1] r[n]
有序
r[i]
r[n]
.
1
10.5 归并排序
❖ 如何进行两路归并？
将两个有序表的元素进行比较，小者复制到 目标表中。
按桶的编号将关键字收集起来；
然后，以“次低位”将关键字又分配到r个桶 中；再收集，……，重复直到“最高位”为止， 这时，以按关键字有序。
.
18
例如：对下列这组关键字进行基数排序 {209, 386, 768, 185, 247, 606, 230, 834, 539 }
基数 为10
0
1
2
3
4
5
6
7