第十章排序
合集下载
数据结构讲义第10章排序ppt课件
R[j]＝temp;
flag＝1;
}
}
2021精选ppt
25
10.3 交换排序
10.3.1冒泡排序(Bubble Sort)
4、算法分析： 起泡排序的最坏时间复杂度为O(n2)，平均时间复杂度为 O(n2)。 起泡排序算法中增加一个辅助空间temp，辅助空间为 S(n)=O(1)。 起泡排序是稳定的。
整个排序进行n-1趟插入。
2021精选ppt
10
10.2 插入排序
10.2.1直接插入排序
2、示例： 初始： [49] 38 65 97 76 13 27 49 i=1: [38 49] 65 97 76 13 27 49 i=2: [38 49 65] 97 76 13 27 49 i=3: [38 49 65 97] 76 13 27 49 i=4: [38 49 65 76 97] 13 27 49 i=5: [13 38 49 65 76 97] 27 49 i=6: [13 27 38 49 65 76 97] 49
此后，再对存放在R1,R2,R3,…,Rn-1中n-1个记录作同样处理,结果，最 大者在Rn-1中。
…。
n-1次起泡能完成排序。设置标志noswap表示本次起泡是否有交换， 若无交换，表示排序完成。
2021精选ppt
23
10.3 交换排序
10.3.1冒泡排序(Bubble Sort)
2、示例：
初始 1 2 3 4 5 6
r[lppt
16
10.2 插入排序
10.2.2折半插入排序
4、算法分析： 算法分析：
空间效率：同直接插入排序 时间效率：比较次数确定：
n log2i nlog2n i=1 移动记录次数：平均移动次数为O(n2) 时间复杂度为O(n2)
第十章内部排序
10.2 插入排序
1、直接插入排序:续 •实现算法
Status InsertSort ( SqList &L ) { for ( i = 2; i <= L.length ; ++i ) if ( LT( L.r[i].key, L.r[i-1].key ) ) { L.r[0].key = L.r[i].key; //复制为哨兵 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]; } } //InsertSort
1 物料管理
第十章 内部排序
学习内容
10.1 概述 10.2 插入排序 10.3 快速排序 10.4 选择排序 10.5 归并排序
SORT
2 物料管理
第十章 内部排序
10.1 概述
•定义
设有记录序列：{ R1、R2 ……….. Rn } 其相应的关键字序列为： { K1、K2 ……….. Kn }; 若存在一种确定的关系： Kx <= Ky <= … <= Kz，则将记录序列 { R1、R2 ……….. Rn } 排成按 该关键字有序的序列：{ Rx、Ry ……….. Rz } 的操作，称之为排序。
•性能分析 减少了查找比较次数，但并未降低时间复杂度，仍为O(n2)。 7
SORT
8 物料管理
第十章 内部排序
10.2 插入排序
3、 希尔(shell) 排序 •基本思想 先将整个待排记录序列分割成为若干个子序列分别进行直接插入排序，待整个序列 中的记录基本有序时，再对全体记录进行一次直接插入排序。
第十章_排序方法(数据结构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章-内部排序PPT课件
L.r[j+1]=L.r[j]; //将j……i-1的记录后移一格 L.r[j+1]=L.r[0]; } //将Ri插入到位置j+1 }
-
算法效率
时间复杂度
待排序记录按关键字从小到大排列(正序)
n
比较次数: 1 n 1 i2
移动次数: 0
待排序记录按关键字从大到小排列(逆序)
比较次数:
n i (n2)(n1)
i2
2
移动次数:
n
(n4)(n1)
(i1)
i2
2
待排序记录随机，取平均值
比较次数: n 2
4
移动次数: n 2
4
总的时间复杂度:T(n)=O(n2)
空间复杂度：S(n)=O(1)
-
3. 折半插入排序
排序过程：用折半查找方法确定插入位置。 举例：
i=1: (38) (49) 38 65 97 76 13 27 49
5 R’={5}
R={10,2}
2 R’={2,5}
R={2}
10 R’={2,5,10}
R={ }
2 R’={2,2,5,10}
-
2. 直接插入排序
排序过程：整个排序过程为n-1趟插入
将序列中第1个记录看成是一个有序子序列 从第2个记录开始，逐个进行插入，直至整个序列有序
R1 R2 …… Rn
内部排序适用于记录个数不很多的小文件； 外部排序则适用于记录个数太多，不能一次 将其全部放入内存的大文件
排序依据策略
插入排序：直接插入排序, 折半插入排序, 希尔排序 交换排序：冒泡排序, 快速排序 选择排序：简单选择排序, 堆排序 归并排序：2-路归并排序 基数排序
-
算法效率
时间复杂度
待排序记录按关键字从小到大排列(正序)
n
比较次数: 1 n 1 i2
移动次数: 0
待排序记录按关键字从大到小排列(逆序)
比较次数:
n i (n2)(n1)
i2
2
移动次数:
n
(n4)(n1)
(i1)
i2
2
待排序记录随机，取平均值
比较次数: n 2
4
移动次数: n 2
4
总的时间复杂度:T(n)=O(n2)
空间复杂度：S(n)=O(1)
-
3. 折半插入排序
排序过程：用折半查找方法确定插入位置。 举例：
i=1: (38) (49) 38 65 97 76 13 27 49
5 R’={5}
R={10,2}
2 R’={2,5}
R={2}
10 R’={2,5,10}
R={ }
2 R’={2,2,5,10}
-
2. 直接插入排序
排序过程：整个排序过程为n-1趟插入
将序列中第1个记录看成是一个有序子序列 从第2个记录开始，逐个进行插入，直至整个序列有序
R1 R2 …… Rn
内部排序适用于记录个数不很多的小文件； 外部排序则适用于记录个数太多，不能一次 将其全部放入内存的大文件
排序依据策略
插入排序：直接插入排序, 折半插入排序, 希尔排序 交换排序：冒泡排序, 快速排序 选择排序：简单选择排序, 堆排序 归并排序：2-路归并排序 基数排序
第十章排序
关键字比较次数：
n
1
n
1
i2
记录移动次数：
n
2
2(n
1)
i2
» 若待排序记录按关键字从大到小排列(逆序)
n
关键字)
i2
2
n
记录移动次数：
(i 1) (n 4)(n 1)
i2
2
» 若待排序记录是随机的，取平均值
while (i<j&&r[j]>=x) j--; t=r[i]; r[i]=r[j]; r[j]=t; while (i<j&&r[i]<=x) i++; t=r[i]; r[i]=r[j]; r[j]=t; } r[i]=x; QkSort(r,low,i-1); QkSort(r,i+1,hig); }
对前n-1个记录进行第二趟冒泡排序，结果使关键字次大的记 录被安置在第n-1个记录位置 重复上述过程，直到“在一趟排序过程中没有进行过交换记 录的操作”为止
...
例，序列 49 38 76 13 27
4398
38
1338
13
3489 初
1439
321873
27
始
7163
421973
3287
第 四
思想:
先将待排序记录序列分割成为若干子序列分别进行直接插入排序；
待整个序列中的记录基本有序后，再全体进行一次直接插入排序。
例，序列 49 38 65 97 76 13 27 48 55 4 19
第一趟排序 49
13
19
取d1=5
38
第十章 排序
i=2: (38) (38 49) 65 97 76 13 27 49 i=3: (65) (38 49 65) 97 76 13 27 49 i=4: (97) (38 49 65 97) 76 13 27 49 i=5: (76) (38 49 65 76 97) 13 27 49 i=6: (13) (13 38 49 65 76 97) 27 49 i=7: (27) (13 27 38 49 65 76 97) 49
2）再取 d2 < d1，把所有相隔 d2 的记录放一组，对每一组内的记录进 行直接插入排序。
3）最后取 di＝1，即把所有记录放 在一组进行直接插入排序排序。 15
例1.3
对下列关键字进行希尔排序： 49 38 65 97 76 13 27 48 55 4 取 d1＝5，d2＝3，d3＝1。
16
lmh 13 30 39 42 70 85 ) 20
hl 13 20 30 39 42 70 85 )
13
折半插入算法的分析
• 时间复杂度为O(n2)。 • 空间复杂度为S(n)=O(1)，即使用
一个辅助单元（第0个单元）。
14
1.3 希尔排序
基本思想：
1）先取一个正整数d1（d1＜记录数 n），把所有相隔d1的记录放一组， 这样就把整个待排记录序列分割成若 干个子序列，对每个子序列进行直接 插入排序。
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
18
希尔排序的特点
• 子序列的构成不是简单的“逐段分 割”，而是将相隔某个增量的记录组 成一个子序列
2）再取 d2 < d1，把所有相隔 d2 的记录放一组，对每一组内的记录进 行直接插入排序。
3）最后取 di＝1，即把所有记录放 在一组进行直接插入排序排序。 15
例1.3
对下列关键字进行希尔排序： 49 38 65 97 76 13 27 48 55 4 取 d1＝5，d2＝3，d3＝1。
16
lmh 13 30 39 42 70 85 ) 20
hl 13 20 30 39 42 70 85 )
13
折半插入算法的分析
• 时间复杂度为O(n2)。 • 空间复杂度为S(n)=O(1)，即使用
一个辅助单元（第0个单元）。
14
1.3 希尔排序
基本思想：
1）先取一个正整数d1（d1＜记录数 n），把所有相隔d1的记录放一组， 这样就把整个待排记录序列分割成若 干个子序列，对每个子序列进行直接 插入排序。
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
18
希尔排序的特点
• 子序列的构成不是简单的“逐段分 割”，而是将相隔某个增量的记录组 成一个子序列
数据结构chapter_10
typedef struct { //定义每个记录 数据元素) 定义每个记录( //定义每个记录(数据元素)的结构 KeyType key ; //关键字 //关键字 InfoType otherinfo; //其它数据项 //其它数据项 }RedType; //记录类型 //记录类型 typedef struct { //定义顺序表 定义顺序表L //定义顺序表L的结构 RecordType r [ MAXSIZE +1 ]; //存储顺序表的向量 //存储顺序表的向量 //r[0] r[0]一般作哨兵或缓冲区 //r[0]一般作哨兵或缓冲区 int length ; //顺序表的长度 //顺序表的长度 }SqList; //顺序表类型 //顺序表类型
void BInsertSort (SqList &L) {
// 对顺序表 作折半插入排序 对顺序表L作折半插入排序 for ( i=2; i<=L.length; ++i ) { L.r[0] = L.r[i]; // 将L.r[i]暂存到 暂存到L.r[0] 暂存到 low = 1; high = i-1; while (low<=high) { // 在r[low..high]中折半查找有序插入的位置 中折半查找有序插入的位置 m = (low+high)/2; // 折半 if (L.r[0].key < L.r[m].key) high = m-1; // 插入点在低半区 else low = m+1; // 插入点在高半区 } // while for ( j=i-1; j>=low; --j ) L.r[j+1] = L.r[j]; // 记录后移 // 插入 L.r[high+1] = L.r[0]; } } // BInsertSort
数据结构第十章排序严蔚敏.ppt
对于有相同关键字记录的情况，冒泡排 序是稳定的。
第十章 排序
10.2.3 直接插入排序
直接插入排序的基本思想是：从数组的 第二个单元开始，依次从原始数据中取 出数据，并将其插入到数组中该单元之 前的已排好序的序列中合适的位置处。
直接插入算法需要经过（n-1）趟插入过 程。如果数据恰好应插入到序列的最后 端，则不需移动数据，可节省时间，所 以若原始数据大体有序，此算法可以有 较快的运算速度。
排 28
14
14 28
17 15
20 17
42 20
︹ 42
23 ︹
23 28
序 23 15 28 23 23 23 42 ︹
过 15 23 23 28 28 28 28 42
程︺ ︺ ︺ ︺ ︺ ︺ ︺ ︺
第十章 排序
需扫描的趟数视原始数据最初的排列次 序的不同而不同，最坏的情况要进行 （n-1）趟扫描，一般常常少于(n-1)趟即 可完成。
第十章 排序
简单插入排序算法
void insertsort (sqlist r, int n) {
int i,j; for( i=2; i<=n; i++) {
r[0]=r[i]; /* r[0]用于暂时存放待插入的元素*/ j= i-1; /* j为待比较元素下标，初始时指 向待插入元素前一个单元*/
第十章 排序
10.3.2 构建堆
一般构建堆是采用一种称为筛选（sift）的算 法。这种方法是将一个无序数据序列的构建 堆的过程看作一个反复“筛选”的过程。
设原始数据为10，10，13，15，4，20，19， 8（数据个数n=8）。
首先把这些数据按任意次序置入完全二叉树 的各结点中，由于原始数据的次序是任意的， 此树一般不符合堆的条件，需要用筛选运算 进行调整。
第十章 排序
10.2.3 直接插入排序
直接插入排序的基本思想是：从数组的 第二个单元开始，依次从原始数据中取 出数据，并将其插入到数组中该单元之 前的已排好序的序列中合适的位置处。
直接插入算法需要经过（n-1）趟插入过 程。如果数据恰好应插入到序列的最后 端，则不需移动数据，可节省时间，所 以若原始数据大体有序，此算法可以有 较快的运算速度。
排 28
14
14 28
17 15
20 17
42 20
︹ 42
23 ︹
23 28
序 23 15 28 23 23 23 42 ︹
过 15 23 23 28 28 28 28 42
程︺ ︺ ︺ ︺ ︺ ︺ ︺ ︺
第十章 排序
需扫描的趟数视原始数据最初的排列次 序的不同而不同，最坏的情况要进行 （n-1）趟扫描，一般常常少于(n-1)趟即 可完成。
第十章 排序
简单插入排序算法
void insertsort (sqlist r, int n) {
int i,j; for( i=2; i<=n; i++) {
r[0]=r[i]; /* r[0]用于暂时存放待插入的元素*/ j= i-1; /* j为待比较元素下标，初始时指 向待插入元素前一个单元*/
第十章 排序
10.3.2 构建堆
一般构建堆是采用一种称为筛选（sift）的算 法。这种方法是将一个无序数据序列的构建 堆的过程看作一个反复“筛选”的过程。
设原始数据为10，10，13，15，4，20，19， 8（数据个数n=8）。
首先把这些数据按任意次序置入完全二叉树 的各结点中，由于原始数据的次序是任意的， 此树一般不符合堆的条件，需要用筛选运算 进行调整。
第十章 内部排序1
0 1 2 3 4 5 6 i=1 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 i=6 13 (13 38 49 65 76 97) 27
k’1≤k’2≤···≤k’n 或 k’1≥k’2≥···≥k’n
• 稳定与不稳定：若记录序列中的任意两个记录 Rx , Ry 的排序码 Kx= Ky ；如果在排序之前和排 序之后，它们的相对位置保持不变，则这种排序 方法是稳定的，否则是不稳定的 • 排序中的两种基本操作：
– 两个排序码的比较（通常是必须的）
n
0
1 2 3 4 97 76 65 49
5 6 7 38 27 13
若待排序记录是随机的，取平均值
排序码比较次数：
n2 4
n2 记录移动次数： 4
时间复杂度：T(n)=O(n² ) 空间复杂度：S(n)=O(1)
10.1.2 折半插入排序
• 对直接插入排序，在插入记录Ri时，改用折半查找 方法确定插入的位置 • 算法思想：在插入Ri时，前面的记录R1, R2 ,·· Ri -1 ·, 已经排好序，因此可用折半查找找到Ri的插入位置
算法描述 #define M 100 //最大记录个数 typedef struct { int key; //排序码域 ···· //其他域 · ·; }RcdType; //记录类型 typedef RcdType Rcdlist[M+1];
//用顺序表存放，记录0下标不用 假设Rcdlist R；排序前待排序的记录已顺序存放在 R中，记录个数为n i：排序趟数，j：移动次数，直接插入排序算法如下：
第10章排序.ppt
(2)空间效率：仅占用1个附加内存单元——O(1) (3)算法的稳定性：稳定
精选精选文档
6
初始关键字序列:
{64}
5
7
89
第一次排序:
{5
64}
7
89
第二次排序:
{5
7
64}
89
第三次排序:
{5
7
64
89}
第四次排序:
{5
6
7
64
第五次排序:
{5
6
7
24
直接插入排序过程
精选精选文档
6
24
6
24
6
24
//设第i个数据元素关键字最小
for(j = i+1; j < n; j++)
//寻找关键字最小的数据元素
if(a[j].key < a[small].key) small=j;
//记住最小元素的下标
if(small != i)
//当最小元素的下标不为i时交换位置
{
temp = a[i];
a[i] = a[small];
for(m = 0; m < numOfD; m++)
//共numOfD次循环
{ span = d[m];
//取本次的增量值
for(k = 0; k < span; k++)
//共span个小组
{
//组内是直接插入排序，区别是每次不是增1而是增span
for(i = k; i < n-span; i = i+span)
CreatHeap(a, i, 0);
//调整根结点满足最大堆
精选精选文档
6
初始关键字序列:
{64}
5
7
89
第一次排序:
{5
64}
7
89
第二次排序:
{5
7
64}
89
第三次排序:
{5
7
64
89}
第四次排序:
{5
6
7
64
第五次排序:
{5
6
7
24
直接插入排序过程
精选精选文档
6
24
6
24
6
24
//设第i个数据元素关键字最小
for(j = i+1; j < n; j++)
//寻找关键字最小的数据元素
if(a[j].key < a[small].key) small=j;
//记住最小元素的下标
if(small != i)
//当最小元素的下标不为i时交换位置
{
temp = a[i];
a[i] = a[small];
for(m = 0; m < numOfD; m++)
//共numOfD次循环
{ span = d[m];
//取本次的增量值
for(k = 0; k < span; k++)
//共span个小组
{
//组内是直接插入排序，区别是每次不是增1而是增span
for(i = k; i < n-span; i = i+span)
CreatHeap(a, i, 0);
//调整根结点满足最大堆
第10章排序答案
第10章排序习题答案一、填空题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. 在堆排序、快速排序和归并排序中，若只从存储空间考虑，则应首先选取堆排序方法，其次选取快速排序方法，最后选取归并排序方法；若只从排序结果的稳定性考虑，则应选取归并排序方法；若只从平均情况下最快考虑，则应选取快速排序方法；若只从最坏情况下最快并且要节省内存考虑，则应选取堆排序方法。
数据结构第十章 排序
7
10.2 插入排序 插入排序
直接插入排序 折半插入排序 2-路插入排序 表插入排序 希尔排序
10.2.1 直接插入排序
基本操作：将一个记录插入到已排好序的有序表中， 从而得到一个新的、记录数增1的有序表。
例:有一组待排序的记录的关键字初始序列如下:
(49,38,65,97,76,13,27,49`)
（4）归并排序 （5）基数排序
按内排过程中所需的工作量分类：
（1）简单的排序方法，其时间复杂度为O(n×n)
（2）先进的排序方法，其时间复杂度为O(nlogn);
（3）基数排序，其时间复杂度为O(d(n+rd))
排序算法的两种基本操作：
（1）比较两个关键字的大小； （2）将记录从一个位置移至另一个位置；
算法实现的关键设计:
将d看成是一个循环数组,并设两个指针first和final分别指示排序过 程中得到的有序序列中的第一个记录和最后一个记录在d中的位置.
例:有一组待排序的记录的关键字初始排列如下:
(49,38,65,97,76,13,27,49`) 16
[初始关键字] 49 38 65 97 76 13 27 49`
18
10.2.3 希尔排序 从直接插入排序
待排序序列基本有序可提高效率 回顾 待排序序列的记录数n很小时可提高效率
希尔排序的基本思想:
先将整个待排记录序列分割成为若干子序列分别进行
直接插入排序,待整个序列中的记录“基本有序”时,再对 全
体记例录:有进一行组一待次排直序接的插记入录排的序关. 键字初始排列如下: (49,38,65,97,76,13,27,49`)
} 12
直接插入排序的性能分析: 10. 3
(1)空间:只需一个记录的辅助空间r[0].
10.2 插入排序 插入排序
直接插入排序 折半插入排序 2-路插入排序 表插入排序 希尔排序
10.2.1 直接插入排序
基本操作：将一个记录插入到已排好序的有序表中， 从而得到一个新的、记录数增1的有序表。
例:有一组待排序的记录的关键字初始序列如下:
(49,38,65,97,76,13,27,49`)
（4）归并排序 （5）基数排序
按内排过程中所需的工作量分类：
（1）简单的排序方法，其时间复杂度为O(n×n)
（2）先进的排序方法，其时间复杂度为O(nlogn);
（3）基数排序，其时间复杂度为O(d(n+rd))
排序算法的两种基本操作：
（1）比较两个关键字的大小； （2）将记录从一个位置移至另一个位置；
算法实现的关键设计:
将d看成是一个循环数组,并设两个指针first和final分别指示排序过 程中得到的有序序列中的第一个记录和最后一个记录在d中的位置.
例:有一组待排序的记录的关键字初始排列如下:
(49,38,65,97,76,13,27,49`) 16
[初始关键字] 49 38 65 97 76 13 27 49`
18
10.2.3 希尔排序 从直接插入排序
待排序序列基本有序可提高效率 回顾 待排序序列的记录数n很小时可提高效率
希尔排序的基本思想:
先将整个待排记录序列分割成为若干子序列分别进行
直接插入排序,待整个序列中的记录“基本有序”时,再对 全
体记例录:有进一行组一待次排直序接的插记入录排的序关. 键字初始排列如下: (49,38,65,97,76,13,27,49`)
} 12
直接插入排序的性能分析: 10. 3
(1)空间:只需一个记录的辅助空间r[0].
相关主题
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第一趟：第1个与第2个比较，大则交换；第2个与第3个比较， 大则交换，……关键字最大的记录交换到最后一个位置上； 第二趟：对前n-1个记录进行同样的操作，关键字次大的记录交换 到第n-1个位置上；
依次类推，则完成排序。
正序：时间复杂度为O(n) 逆序：时间复杂度为O(n2)
适合于数据较少的情况。
2013-5-13 排序n个记录的文件最多需要n-1趟冒泡排序。 举例：图8-2-5
25
思想：小的 浮起，大的 沉底。
25 56 49 78 11 65 41 36
初 始 关 键 字
25 49 56 11 65 41 36 78
第 一 趟 排 序 后
25 49 11 56 41 36 65
25 11 49 41 36 56
11 25 41 36 49
11 25 36 41
11 25 36
简单选择排序、堆排序。
1、简单选择排序
思想：首先从1~n个元素中选 出关键字最小的记录交换到第 一个位置上。然后再从第2 个 到第n个元素中选出次小的记 录交换到第二个位置上，依次 类推。
时间复杂度为O(n2)， 适用于待排序元素较少的情况。
3 j 3 k 3 k 3
互换
9 9 j 9 9
1 1 1 j 1 k 8
插入算法如下：
9
方法:Ki与Ki-1,K i-2,…K1依次比较,直到找到应插入的位置。 void insertSort(RedType L[ ],int n)
{ int i ,j; for(i=2; i<=n; i++) if(L[i].key<L[i-1].key)
{
L[0]=L[i];
L[j+1]=L[j]; L[j+1]=L[0];
[ 15
27
36
53
69 ]
42
[ 15
27
36
low high mid ( 42<53 ) 53 69 ] 42 (high<low ，查找结束，插入位置为low 或high+1 )
high low
[ 15
27
36
42
53
69 ]
2013-5-13
void BinsertSort(RedType L[ ],int n)
19
E、筛选算法（调整建堆）
typedef Sqlist HeapType; //堆采用顺序表存储表示 void HeapAdjust( HeapType &H, int s, int m){ // 已知H.r[s..m]中记录的关键字除H.r[s] .key外均满足堆定义， //本函数调整H.r[s] .key，使H.r[s..m]成为一个堆，其中堆顶元素为最大值 rc=H.r[s]; for(j=2*s; j<=m; j*=2) { //沿关键字值较大的孩子结点向下筛选 if( j<m && H.r[j].key <H.r[j+1].key) + +j;// j 为 key较大的记录下标 if( rc.key >= H.r[j].key) break; H.r[s]=H.r[j]; s=j; // }// for s H.r[s]=rc; 10 10 76 24 33 15 } 1 2 3 4 5 j 76 24 rc.key = 10
2013-5-13
22
A:
56
25
49
F、堆排序算法
56
25 49 i=3
i=4
78
11
65
(1)
41
78
11
65
(2)
41
36 i=1 78 56
36 25
25 65 78 56
25 65 78 56 65
i=2
11
49 (5)
41
11
49 (4)
41
11
49 (3)
41
36
36
2013-5-13
6 6 6 6 j 6 第 二 趟 第 一 趟
14
3 i k
9 j 9
1 i k 1 i k 1
3
8 j 8 j
6
3
9
6
3
2013-5-13
9 i k
8 j
6
第 三 趟
简单选择排序的算法如下：
15
void SelectSort( RedType L[ ],int n)
{ int i,j,k,t; for (i=1,i<=n;++i） { k=i； for(j=i+1;j<=n;++j)
举例，图8-2-2
2013-5-13
2、折半插入排序
11
折半插入排序在寻找插入位置时，不是逐个比较而是利用折半 查找的原理寻找插入位置。待排序元素越多，改进效果越明显。
例：有6个记录，前5 个已排序的基础上，对第6个记录排序。 [ 15 27 36 53 69 ] 42
low mid ( 42>36 ) high
6
插入排序
直接插入排序 折半插入排序
简单选择排序 堆排序 起泡排序
选择排序
排序方法
交换排序 归并排序
2013-5-13
快速排序
7
10.2 插入排序
直接插入、折半插入
1、直接插入排序: 基本思想：从数组的第2号元素开始，顺 序从数组中取出元素，并将该元素插入 到其左端已排好序的数组的适当位置上。
举例：图8-2-1
2013-5-13
假设待排序的记录存放在地址连续的 一组存储单元中，那么这种存储方式 下的数据类型可描述为：
5
#define MAX 20 typedef struct { int key; float otherinfo;
0 1 2 3 4
key info
MAX
}RedType;
… … …
2013-5-13
12
{ int i,low,high,mid;
for(i=2; i<=n; ++i){ L[0]=L[i]; /* r[0]作为监视哨*/
low=1; high=i-1;
While(low<=high) {mid=(low+high)/2; else low=mid+1; } for( j=i-1; j>=high+1; j ) L[j+1]=L[j]; L[high+1]=L[0]; } /* for*/ }/*折半插入排序*/
36
n=8, int(n/2)=4开始 25 41 11 65 49 36 11 56
25 41 65
78 (b): 78被筛选后的状态 11 25 36 78 56 65 41 49
56 36
49
78
78
2013-5-13 (d): 56被筛选后的状态
(c): 49被筛选后的状态
(e): 被筛选之后建成堆
76 33 24
s
10
24
s 15 76
j 76
33
15
10
33 24
15
10 15
10 10 24 33 j=2*j=4
j=2*j=8>m
第二次
2013-5-13
第一次
21
F、堆排序算法
void HeapSort( HeapType &H) { //堆顺序表H进行堆排序 for( i=H.length/2; i>0; i) HeapAdjust(H, i, H.length); // 把H.r[1..H.length]成为一个堆， For(i=H.length; i>1; i){ 把堆顶元素与最后一个记录相交换 // rc=H.r[1]; H.r[1]=H.r[i]; H.r[i]=rc; HeapAdjust(H, 1, i-1); //把H.r[1..i-1]重新调整为一个堆 } }
16
33
15
10
56
49
78
(a):堆顶元素取最大值 (2) 实现堆排序需解决两个问题：
(b):堆顶元素取最小值
（1） 如何由一个无序序列建成一个堆？
（2） 输出堆顶元素后，如何将剩余元素调整成一个新的堆？
举例：图8-2-4
2013-5-13
(3) 输出堆顶元素并调整建新堆的过程(筛选) 把自堆顶至叶子的调整过程称为“筛选‘。从一个无序序 65 11 (a) (b) 列建堆的过程就是一个反复”筛选“的过程。
2013-5-13
8
10.2 插入排序
直接插入、折半插入
1、直接插入排序: 基本思想：从数组的第2号元素开始，顺序从数组中取出元素， 并将该元素插入到其左端已排好序的数组的适当位置上 待排元素序列：[53] 27 36 15 69 42 第一次排序： 第二次排序： [27 53] 36 15 69 42 [27 36 53] 15 69 42
第 二 趟 排 序 后
2013-5-13
第 三 趟 排 序 后
第 四 趟 排 序 后
第 五 趟 排 序 后
第 六 趟 排 序 后
26
冒泡排序的C程序段：
Void bubsort(RedType L[ ],int n) { int i,x,j=1,k=1;
while (j<n)&&(k>0);
{ k=0; for (i=1;i<=n-j; i++) if (L[i+1].key<L[i].key) {k++;x=L[i];L[i]=L[i+1];L[i+1]=x;} j++; } /*while*/
依次类推，则完成排序。
正序：时间复杂度为O(n) 逆序：时间复杂度为O(n2)
适合于数据较少的情况。
2013-5-13 排序n个记录的文件最多需要n-1趟冒泡排序。 举例：图8-2-5
25
思想：小的 浮起，大的 沉底。
25 56 49 78 11 65 41 36
初 始 关 键 字
25 49 56 11 65 41 36 78
第 一 趟 排 序 后
25 49 11 56 41 36 65
25 11 49 41 36 56
11 25 41 36 49
11 25 36 41
11 25 36
简单选择排序、堆排序。
1、简单选择排序
思想：首先从1~n个元素中选 出关键字最小的记录交换到第 一个位置上。然后再从第2 个 到第n个元素中选出次小的记 录交换到第二个位置上，依次 类推。
时间复杂度为O(n2)， 适用于待排序元素较少的情况。
3 j 3 k 3 k 3
互换
9 9 j 9 9
1 1 1 j 1 k 8
插入算法如下：
9
方法:Ki与Ki-1,K i-2,…K1依次比较,直到找到应插入的位置。 void insertSort(RedType L[ ],int n)
{ int i ,j; for(i=2; i<=n; i++) if(L[i].key<L[i-1].key)
{
L[0]=L[i];
L[j+1]=L[j]; L[j+1]=L[0];
[ 15
27
36
53
69 ]
42
[ 15
27
36
low high mid ( 42<53 ) 53 69 ] 42 (high<low ，查找结束，插入位置为low 或high+1 )
high low
[ 15
27
36
42
53
69 ]
2013-5-13
void BinsertSort(RedType L[ ],int n)
19
E、筛选算法（调整建堆）
typedef Sqlist HeapType; //堆采用顺序表存储表示 void HeapAdjust( HeapType &H, int s, int m){ // 已知H.r[s..m]中记录的关键字除H.r[s] .key外均满足堆定义， //本函数调整H.r[s] .key，使H.r[s..m]成为一个堆，其中堆顶元素为最大值 rc=H.r[s]; for(j=2*s; j<=m; j*=2) { //沿关键字值较大的孩子结点向下筛选 if( j<m && H.r[j].key <H.r[j+1].key) + +j;// j 为 key较大的记录下标 if( rc.key >= H.r[j].key) break; H.r[s]=H.r[j]; s=j; // }// for s H.r[s]=rc; 10 10 76 24 33 15 } 1 2 3 4 5 j 76 24 rc.key = 10
2013-5-13
22
A:
56
25
49
F、堆排序算法
56
25 49 i=3
i=4
78
11
65
(1)
41
78
11
65
(2)
41
36 i=1 78 56
36 25
25 65 78 56
25 65 78 56 65
i=2
11
49 (5)
41
11
49 (4)
41
11
49 (3)
41
36
36
2013-5-13
6 6 6 6 j 6 第 二 趟 第 一 趟
14
3 i k
9 j 9
1 i k 1 i k 1
3
8 j 8 j
6
3
9
6
3
2013-5-13
9 i k
8 j
6
第 三 趟
简单选择排序的算法如下：
15
void SelectSort( RedType L[ ],int n)
{ int i,j,k,t; for (i=1,i<=n;++i） { k=i； for(j=i+1;j<=n;++j)
举例，图8-2-2
2013-5-13
2、折半插入排序
11
折半插入排序在寻找插入位置时，不是逐个比较而是利用折半 查找的原理寻找插入位置。待排序元素越多，改进效果越明显。
例：有6个记录，前5 个已排序的基础上，对第6个记录排序。 [ 15 27 36 53 69 ] 42
low mid ( 42>36 ) high
6
插入排序
直接插入排序 折半插入排序
简单选择排序 堆排序 起泡排序
选择排序
排序方法
交换排序 归并排序
2013-5-13
快速排序
7
10.2 插入排序
直接插入、折半插入
1、直接插入排序: 基本思想：从数组的第2号元素开始，顺 序从数组中取出元素，并将该元素插入 到其左端已排好序的数组的适当位置上。
举例：图8-2-1
2013-5-13
假设待排序的记录存放在地址连续的 一组存储单元中，那么这种存储方式 下的数据类型可描述为：
5
#define MAX 20 typedef struct { int key; float otherinfo;
0 1 2 3 4
key info
MAX
}RedType;
… … …
2013-5-13
12
{ int i,low,high,mid;
for(i=2; i<=n; ++i){ L[0]=L[i]; /* r[0]作为监视哨*/
low=1; high=i-1;
While(low<=high) {mid=(low+high)/2; else low=mid+1; } for( j=i-1; j>=high+1; j ) L[j+1]=L[j]; L[high+1]=L[0]; } /* for*/ }/*折半插入排序*/
36
n=8, int(n/2)=4开始 25 41 11 65 49 36 11 56
25 41 65
78 (b): 78被筛选后的状态 11 25 36 78 56 65 41 49
56 36
49
78
78
2013-5-13 (d): 56被筛选后的状态
(c): 49被筛选后的状态
(e): 被筛选之后建成堆
76 33 24
s
10
24
s 15 76
j 76
33
15
10
33 24
15
10 15
10 10 24 33 j=2*j=4
j=2*j=8>m
第二次
2013-5-13
第一次
21
F、堆排序算法
void HeapSort( HeapType &H) { //堆顺序表H进行堆排序 for( i=H.length/2; i>0; i) HeapAdjust(H, i, H.length); // 把H.r[1..H.length]成为一个堆， For(i=H.length; i>1; i){ 把堆顶元素与最后一个记录相交换 // rc=H.r[1]; H.r[1]=H.r[i]; H.r[i]=rc; HeapAdjust(H, 1, i-1); //把H.r[1..i-1]重新调整为一个堆 } }
16
33
15
10
56
49
78
(a):堆顶元素取最大值 (2) 实现堆排序需解决两个问题：
(b):堆顶元素取最小值
（1） 如何由一个无序序列建成一个堆？
（2） 输出堆顶元素后，如何将剩余元素调整成一个新的堆？
举例：图8-2-4
2013-5-13
(3) 输出堆顶元素并调整建新堆的过程(筛选) 把自堆顶至叶子的调整过程称为“筛选‘。从一个无序序 65 11 (a) (b) 列建堆的过程就是一个反复”筛选“的过程。
2013-5-13
8
10.2 插入排序
直接插入、折半插入
1、直接插入排序: 基本思想：从数组的第2号元素开始，顺序从数组中取出元素， 并将该元素插入到其左端已排好序的数组的适当位置上 待排元素序列：[53] 27 36 15 69 42 第一次排序： 第二次排序： [27 53] 36 15 69 42 [27 36 53] 15 69 42
第 二 趟 排 序 后
2013-5-13
第 三 趟 排 序 后
第 四 趟 排 序 后
第 五 趟 排 序 后
第 六 趟 排 序 后
26
冒泡排序的C程序段：
Void bubsort(RedType L[ ],int n) { int i,x,j=1,k=1;
while (j<n)&&(k>0);
{ k=0; for (i=1;i<=n-j; i++) if (L[i+1].key<L[i].key) {k++;x=L[i];L[i]=L[i+1];L[i+1]=x;} j++; } /*while*/