数据结构-第10章习题(ppt文档)
数据结构-第十章-内部排序
![数据结构-第十章-内部排序](https://img.taocdn.com/s3/m/0ffd09a4f524ccbff12184e2.png)
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
数据结构c(10)-3
![数据结构c(10)-3](https://img.taocdn.com/s3/m/274dee333968011ca300917b.png)
例
注意指针变量的运算
a p p
void main() { int a [ ]={5,8,7,6,2,7,3}; int y, *p=&a[1]; y=(*--p)++; printf(“%d ”,y); printf(“%d”,a[0]); }
5 6 8
0 1 2 3
7 6 2 7
4 5
第10章 指针
分析下面程序是否有错?
main() { int x=10,y=5,*px,*py; px=py; px=&x; py=&y; printf(“*px=%d,*py=%d”,*px,py); }
分析下面程序能否完成数据交换?
change(int *p1, int *p2) { int *p; p=p1; p1=p2; p2=p; } main() { int a,b; int *pointer_1,*pointer_2; scanf("%d,%d",&a,&b); pointer_1=&a; pointer_2=&b; if(a<b) change(pointer_1,pointer_2); printf("%d,%d",*pointer_1,*pointer_2); }
p[9]
注意:
尽管a与p都放的是数组a的首地址,但它们的性质不 同,一个是指针变量,一个是数组名。 如
p++; 合法 a++; 非法, a的值在程序运行期间是固定不变的。
引用一维数组元素的方法
例: 对一维数组的各元素进行赋值和输出。(有5种方法) /* 方法一:下标法*/ main() { int a[10], *p=a, i; printf(“Input 10 numbers: ”); for(i=0; i<10; i++) scanf(“%d”, &a[i]); printf(“a[10]: ”); 在整个程序中a 的值可以变化吗? for(i=0; i<10; i++) printf(“%d ”, a[i]); 注意:程序中a 的值始终不变, printf(“\n”); 也不能变。 } 如果输入: 0 1 2 3 4 5 6 7 8 9←┘ 请写出程序的运行情况 程序运行情况: Input 10 numbers: 0 1 2 3 4 5 6 7 8 9←┘ a[10]: 0 1 2 3 4 5 6 7 8 9
查找 数据结构讲义
![查找 数据结构讲义](https://img.taocdn.com/s3/m/d4e446d733d4b14e85246874.png)
ASL blk
s1 s ASL bn ASL sq log 2 (h 1) 1 log 2 (n / s 1) 2 2
若以顺序查找确定块,则分块查找成功时的平 均查找长度为:
ASL ASL bn ASL sq blk
b 1 s 1 s 2s n 2 2 2s
low=0 high=3 第2次比较: 2 4 7 9 10 14 18
mid=(0+3)/2=1 26 32 40
low=2
第3次比较: 2 4 7
high=3
9 10 14 18 26
mid=(2+3)/2=2
32 40
R[2].key=7 查找成功,返回序号2
其算法如下(在有序表R[0..n-1]中进行二分查找, 成功时返回记录的位置,失败时返回-1):
二分查找过程可用二叉树来描述,我们
把当前查找区间的中间位置上的记录作为根,
左子表和右子表中的记录分别作为根的左子
树和右子树,由此得到的二叉树,称为描述
二分查找的判定树或比较树。
<
5 =
>
< 0 = > 1 < = >
2 =
> 3 < = >
2~3
8 < =
6 < = >
5~6
> 9 < = > 10 < = >
采用二分查找索引表的分块查找算法如下(索引表I的长度 为m):
int IdxSearch(IDX I, int m, SeqList R, int n, KeyType k)
{
int low=0,high=m-1,mid,i;
第十章_排序方法(数据结构ppt-严蔚敏)
![第十章_排序方法(数据结构ppt-严蔚敏)](https://img.taocdn.com/s3/m/2d275b5e804d2b160b4ec014.png)
第二个问题解决方法——筛选
方法:输出堆顶元素之后,以堆中最后一个元素替代之;然 后将根结点值与左、右子树的根结点值进行比较,并与其中 小者进行交换;重复上述操作,直至叶子结点,将得到新的 堆,称这个从堆顶至叶子的调整过程为“筛选”
例 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章
![《数据结构》陈慧南 第10章](https://img.taocdn.com/s3/m/3332bac6bb4cf7ec4afed001.png)
n( n − 1 ) ∑i = 2 i =1
南京邮电大学计算机学院 陈慧南 2006年9月 2006年
9.2.3 冒泡排序
(48,36,68,72,12,48,02) 48,36,68,72,12,48,02) 36,48,68,72,12,48,02) (36,48,68,72,12,48,02) 36,48,68,72,12,48,02) (36,48,68,72,12,48,02) 36,48,68,72,12,48,02) (36,48,68,72,12,48,02) 36,48,68,12,72,48,02) (36,48,68,12,72,48,02) (36,48,68,12,48,72,02) 36,48,68,12,48,72,02) 36,48,68,12,48,02,72) (36,48,68,12,48,02,72)
南京邮电大学计算机学院 陈慧南 2006年9月 2006年
序列中两个元素R 序列中两个元素 i和Rj (i<j),且Ki=Kj,若 , 排序后仍保持p(i)<p(j),即Ri 仍然排在 j之 仍然排在R 排序后仍保持 , 则称所用的排序算法是稳定的。 反之, 前 , 则称所用的排序算法是稳定的 。 反之 , 称该排序算法是不稳定的。 称该排序算法是不稳定的。 如果待排序元素总数相对于内存而言较小, 如果待排序元素总数相对于内存而言较小 , 整个排序过程可以在内存中进行, 整个排序过程可以在内存中进行 , 则称之 为内部排序; 反之, 为内部排序 ; 反之 , 如果待排序元素总数 较多, 不能全部放入内存, 较多 , 不能全部放入内存 , 排序过程中需 访问外存, 则称之为外部排序。 访问外存 , 则称之为外部排序 。 本章讨论 内部排序。 内部排序。
第10章 排序 PPT课件
![第10章 排序 PPT课件](https://img.taocdn.com/s3/m/e50e43db856a561252d36f59.png)
清华大学出版社
概述
数据结构(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. 在查找插入位置的循环 中充当哨兵。
清华大学出版社
插入排序
姓名 王军 李明 汤晓影
数据结构复习题-第10章答案2014-6-16
![数据结构复习题-第10章答案2014-6-16](https://img.taocdn.com/s3/m/f6c0b25ef01dc281e53af02c.png)
第10章内部排序一、选择题(每小题1分,共10分)1.从未排序序列中依次取出一个元素与已排序序列中的元素依次进行比较,然后放在已排序序列的合适位置,该排序方法称为( A )排序法。
A.插入排序B.选择排序C.希尔排序D.二路归并排序2.下列排序算法中( C )排序在一趟结束后不一定能选出一个元素放在其最终位置上。
A.选择B.冒泡C.归并D.堆3.若一组记录的排序码为(46, 79, 56, 38, 40, 84),则利用快速排序的方法,以第一个记录为基准得到的一次划分结果为( C )。
A. 38, 40, 46, 56, 79, 84B. 40, 38, 46, 79, 56, 84C. 40, 38,46, 56, 79, 84D. 40, 38, 46, 84, 56, 794.排序方法中,从未排序序列中依次取出元素与已排序序列(初始时为空)中的元素进行比较,将其放入已排序序列的正确位置上的方法,称为( C )。
A.希尔排序B.冒泡排序C.插入排序D.选择排序5.为实现快速排序算法,待排序序列宜采用的存储方式是( A )。
A. 顺序存储B. 散列存储C. 链式存储D. 索引存储6.若一组记录的排序码为(46, 79, 56, 38, 40, 84),则利用堆排序的方法建立的初始堆为( B )。
A. 79, 46, 56, 38, 40, 84B. 84, 79, 56, 38, 40, 46C. 84, 79, 56, 46, 40, 38D. 84, 56, 79, 40, 46, 387.排序方法中,从未排序序列中依次取出元素与已排序序列中的元素进行比较,将其放入已排序序列的正确位置上的方法,称为( C )。
A.希尔排序B.冒泡排序C.插入排序D.选择排序8.在所有的排序方法中,关键字比较的次数与记录的初始排列次序无关的是( D )。
A.希尔排序B.冒泡排序C.直接插入排序D.直接选择排序9.堆是一种有用的数据结构。
数据结构
![数据结构](https://img.taocdn.com/s3/m/7633b2c089eb172ded63b724.png)
绪 论
CUIT
李
数据对象 (Data Object)
性质相同的数据元素的集合,是数据的子集, 例如整数。
莉
丽
数 据 结 构
数据结构 (Data Structure)
作为一个概念是指:相互之间存在一种或多种 特定关系的数据元素的集合。数据元素之间的相互 关系称为结构。有下列四种基本结构:
之
(1)集合
数 据 结 构
例3:
多叉路口交通灯的管理问题 这类交通、道路的问题数据模型是一种 称为“图”的数据结构。
C
之
绪 论
CUIT
D B
李
A
(a) 五叉路口
E
莉
丽
数 据 结 构
结论:
之
综合上面三个例子,描述这类非数值计算性问 题的数学模型不再是数学方程,而是诸如表、树和 图之类的数据结构。
绪 论
数 据 结 构
这个关系不是线性的,从一个棋盘可以派生出几个格 局,如下图: * * * * *
(a) 棋盘格式示例
之
*
*
*
*
绪 论
CUIT
* * * *
* * * *
* *
(b)井字棋对弈树的局部
李
莉
丽
“树根”是对奕开始之前的棋盘格局,而所有的 “叶子”是可能出现的结局,对奕的过程就是从树 根沿树叉到达某个叶子的过程。 --“树”这种数据 模型也是一种数据结构。
李
莉
丽
数 据 结 构
1. 4
算法:
算法与算法分析
是对特定问题求解步骤的一种描述,是指令的 有限序列,其中每一条指令是一个或多个操作。 一个算法就是一个有穷规则的集合,规则规 定了解决某特定问题的运算序列。
数据结构第10章习题
![数据结构第10章习题](https://img.taocdn.com/s3/m/64a93145a45177232f60a2ab.png)
三、填空题
1. 设用希尔排序对数组{98,36,-9,0,47,23, 1,8,10,7}进行排序,给出的步长(也称增量 序列)依次是4,2,1则排序需__________趟, 写出第一趟结束后,数组中数据的排列次序 __________。 【南京理工大学 1997 三、5 (2分)】 2.若不考虑基数排序,则在排序过程中,主要进行 的两种基本操作是关键字的______和记录的 _____。 【北京邮电大学 2001 二、7 (4分)】 3.分别采用堆排序,快速排序,冒泡排序和归并排 序,对初态为有序的表,则最省时间的是_____ 算法,最费时间的是______算法。【福州大学 1998 二、10 (2分)】
பைடு நூலகம்
12.就排序算法所用的辅助空间而言,堆排序,快 速排序,归并排序的关系是( a ) A.堆排序〈 快速排序〈归并排序 B.堆排序 〈 归并排序〈 快速排序 C.堆排序〉 归并排序 〉快速排序 D.堆排 序 > 快速排序 > 归并排序 E.以上答案都不 对 【西安交通大学 1996 三、1 (3分)】 13.将两个各有N个元素的有序表归并成一个有序表, 其最少的比较次数是( a ) A.N B.2N-1 C.2N D.N-1
2.比较次数与排序的初始状态无关的排序方法是 ( d )。【北方交通大学 2000 二、2(2分)】
A.直接插入排序 D.简单选择排序 B.起泡排序 C.快速排序
3.数据序列(8,9,10,4,5,6,20,1,2)只能是 下列排序算法中的( c )的两趟排序后的结果。 【合肥工业大学 1999 一、3 (2分)】 A.选择排序 B.冒泡排序 C.插入排序 D.堆排序 4.数据序列(2,1,4,9,8,10,6,20)只能是下 列排序算法中的( a )的两趟排序后的结果。 A. 快速排序 B. 冒泡排序 C. 选择排序 D. 插入排序 5.对序列{15,9,7,8,20,-1,4}进行排序,进行 一趟后数据的排列变为{4,9,-1,8,20,7,15}; 则采用的是( c )排序。【南京理工大学 1998 一、8(2分)】 A. 选择 B. 快速 C. 希尔 D. 冒泡
数据结构第10章排序练习及答案
![数据结构第10章排序练习及答案](https://img.taocdn.com/s3/m/efe54123a216147916112809.png)
9.1选择题1.从末排序的序列中依次取出一个元素与已排序序列中的元素依次进行比较,然后将其放在排序序列的合适位置,该排序方法称为()排序法。
A)插入B)选择C)希尔D)二路归并【答案】A2.下面各种排序方法中,最好情况下时间复杂度为O(n)的是()A)快速排序B)直接插入排序C)堆排序D)归并排序【答案】B3.用某种排序方法对线性表(25,84,21,47,15,27,68,35,20)进行排序时,无序序列的变化情况如下:25 84 21 47 15 27 68 35 2020 15 21 25 47 27 68 35 8415 20 21 25 35 27 47 68 8415 20 21 25 27 35 47 68 84则所采用的排序方法是()A)选择排序B)希尔排序C)归并排序D)快速排序【答案】D4.下面给出的四种排序法中,()排序是不稳定排序法。
A)插入B)冒泡C)二路归并D)堆【答案】D5.快速排序方法在()情况下最不利于发挥其长处。
A)要排序的数据量太大B)要排序的数据中含有多个相同值C)要排序的数据已基本有序D)要排序的数据个数为奇数【答案】C6.一组记录的关键码为(46,79,56,38,40,84),则利用快速排序的方法,以第一个记录为基准得到的一次划分结果为()A)38,40,46,56,79,84B)40,38,46,79,56,84C)40,38,46,56,79,84D)40,38,46,84,56,79【答案】C7.对记录的关键码{50,26,38,80,70,90,8,30,40,20}进行排序,各趟排序结束时的结果为:50,26,38,80,70,90 ,8,30,40,2050,8,30,40,20,90,26,38,80,7026,8,30,40,20,80,50,38,90,708,20,26,30,38,40,50,70,80,90其使用的排序方法是()A)快速排序B)基数排序C)希尔排序D)归并排序【答案】C8.以下序列不是堆的是()A)100,85,98,77,80,60,82,40,20,10,66B)100,98,85,82,80,77,66,60,40,20,10C)10,20,40,60,66,77,80,82,85,98,100D)100,85,40,77,80,60,66,98,82,10,20【答案】D【解析】根据堆采用完全二叉树的顺序存储形式及堆的特点,因第一个结点即根结点关键字值最大,则应建立一个大根堆,但依据此数据序列建立起堆后关键字值为40的左右孩子结点分别为60、66,不符合大根堆特点。
数据结构chapter_10
![数据结构chapter_10](https://img.taocdn.com/s3/m/8f8538c52cc58bd63186bde9.png)
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
第10章-数据结构与算法ppt课件(全)
![第10章-数据结构与算法ppt课件(全)](https://img.taocdn.com/s3/m/e1e4409285868762caaedd3383c4bb4cf7ecb7e9.png)
考点3 数据结构的定义
数据对象:是性质相同的数据元素的集合,是数据的一 个子集。
1. 数据的逻辑结构
数据的逻辑结构:是对数据元素之间的逻辑关系的描述, 它可以用一个数据元素的集合和定义在此集合中的若干关系 来表示。
数据的逻辑结构与它们在计算机中的存储位置无关。 数据的逻辑结构有两个要素: 一是数据元素的集合,通常记为D; 二是D上的关系,它反映了数据元素之间的前后件关系, 通常记为R。
进行软件开发的能力。 6. 掌握数据库的基本知识,了解关系数据库的设计。
公共基础知识考试大纲
数据结构与算法考试内容: 1. 算法的基本概念;算法复杂度的概念和意义。 2. 数据结构的定义;数据的逻辑结构与存储结构;
数据结构的图形表示;线性结构与非线性结构的 概念。 3. 线性表的定义;线性表的顺序存储结构及其插入 与删除运算。 4. 栈和队列的定义;栈和队列的个数据结构可以表示成 B=(D,R)
其中 B 表示数据结构。为了反映 D 中各数据元素之间的前后 件关系,一般用二元组来表示。
例 一年四季的数据结构可以表示成 B =(D,R) D = {春,夏,秋,冬} R = {(春,夏),(夏,秋),(秋,冬)}
例 家庭成员数据结构可以表示成 B =(D, R) D = {父亲,儿子,女儿} R = {(父亲,儿子),(父亲,女儿)}
则称为非线性结构。 如 家庭成员之间辈分关系的数据结构是非线性
结构。
考点5 线性表的基本概念
10.3 线性表及其顺序存储结构
线性表(Linear List),由一组数据元素构成, 数据元素的位置只取决于自己的序号,元素之间的 相对位置是线性的。
线性表是由 n(n≥0) 个数据元素组成的一个有限 序列,表中的每一个数据元素,除了第一个外,有 且只有一个前件,除了最后一个外,有且只有一个 后件。
第10章面向对象数据库-PPT精选文档
![第10章面向对象数据库-PPT精选文档](https://img.taocdn.com/s3/m/f2e4cd5a02768e9950e73817.png)
Ô Ï ¶ ó B
ô Ð Ê Ô 1 ¡ ¡ ô Ð Ê Ô r ½ · · ¨1 ¡ ¡ ½ · · ¨s
14
10.1 对象与类
10.1.3 类
类(Class)是对具有共同属性和方法的对象全体的 概括描述,它相当于关系模型中的关系模式。类给出 了属于其全部对象属性与行为的抽象定义,类中对象 仅是类定义中的一个实体,即对象实例。学生是一个 类,一个具体学生,例如John就是学生类中一个对象 实例。与关系模型需要首先描述关系模式类似,对象 模型也首先需要抽象描述具有共同属性的对象的类, 按照类来定义属性和方法,从而避免对每个对象一一 重复定义。查询操作等方法也定义在类上。
6
10.1 对象与类
10.1.1 对象
对象具有封装性、隐蔽性与稳定性等重要特性。 (1)封装性 封装(encapsulation)是使对象的外 部界面与内部实现之间实行清晰隔离的一种技术,是 OO模型的主要特征之一。封装使得用户只能看到对 象外在的界面信息(正如规格说明等),而看不到对 象内部的信息(如方法实现细节),对象内部信息对 于用户是屏蔽的。封装的意义首先在于安全性保证, 其次在于相关模块的可扩展性。
12
10.1 对象与类
10.1.2 消息
例 设一个对象A要求对象B完成其中的某种操作,则 只需向对象B发送一个消息即可。B接收到这个消息后, 根据消息模式找到与之匹配的方法,执行该方法后将 执行的结果又以消息的形式发送给对象A。
13
10.1 对象与类
10.1.2 消息
Ô Ï ¶ ó A
ô Ð Ê Ô 1 ¡ ¡ ô Ð Ê Ô n ½ · · ¨1 ¡ ¡ ½ · · ¨m á ¹ ½ û Ï û Ï ¢ ÷Ó µ Ã Ï û Ï ¢
数据结构第十章 排序
![数据结构第十章 排序](https://img.taocdn.com/s3/m/26817d30a32d7375a41780a2.png)
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)。
while (low<high && L.r[high].key>=pivotkey)
_______(___)_______;
L.r[low]=L.r[high]; //将小于枢轴的记录移到低端
while (low<high && L.r[low].key<=pivotkey)
++low;
L.r[high]= __(___)__; 高端
1 [12] 49 32 86 57* 65 57 28
2 [12 28] 32 86 57* 65 57 49 ......
13:30:50
CH.6
9
习题—分析题
已知关键字序列,画出堆排序第一次的建堆过程
i r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8]
28 49 32 86 12 65 77 51
____。 27、 锦标赛排序的时间复杂度T(n) 为____。 28、 后序遍历二叉树算法在最坏情况下的空
间复杂度S(n)为____(设二叉树的结点数为 n)。
13:30:50
CH.6
7
习题—分析题
已知关键字序列,画出快速排序第一次递归划分后的结 果。
i r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] 57 49 32 86 12 65 57* 28 ^
RcdType temp;
KeyType pivotkey;
temp=L.r[low];
//保存L.r[low]为枢轴记录
pivotkey=L.r[low].key; 的关键字
//取L.r[low].key为枢轴
13:30:50
CH.6
16
习题—编程题
while (_______(___)_______<high) {
20、 堆排序的时间复杂度T(n)为____。 21、 堆排序的空间复杂度S(n) 为____。 22、 二路归并的时间复杂度T(n) 为
____。
13:30:50
CH.6
6
习题—填空题
23、 二路归并的空间复杂度S(n) 为____。 24、 冒泡排序的时间复杂度T(n)为____。 25、 起泡排序的空间复杂度S(n) 为____。 26、 树形选择排序的时间复杂度T(n) 为
//直接插入排序
int i,j;
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]= _______(___)_______;
//==后移
for(j=i-2;LT(L.r[0].key,L.r[j].key);--j)
1
86 51 77 49 12 65 32 28
28
86
49
86
12
32
65
77
51
49
12
77
65
32
51
13:30:50
28
CH.6
10
习题—分析题
已知关键字序列,画出堆排序第二次的建堆过程
i r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] 28 49 32 86 12 65 77 51
34.已知某排序基本操作的头文件,试写出堆排序函数中建堆 函数HeapAdjust(HeapType &H,int s,int m) 实现的算法。
void HeapAdjust(HeapType &H,int s,int m){//对H.r[s..m]建堆
int j;
RcdType rc;
rc=H.r[s];
int pivotloc;
if (low<_______(___)_______){
pivotloc=Partition(L,low,high);
Output_Data_List1(L,pivotloc);//==输出中间结果
QSort(_______(___)_______);
_______(___)_______ (L,pivotloc+1,high);
H.r[s]=H.r[j];
_______(___)_______;
N
13:30:50
CH.6
4
习题—填空题
11、 有n个关键字的序列K1,K2,……Kn 称为小根堆,当且仅当Ki≤K2i 且 ___。
12、 有n个关键字的序列K1,K2,……Kn 称为大根堆,当且仅当Ki≥K2i 且 ___。
13、 顺序查找的平均时间复杂度T(n)为 ____。
14、 二分查找的平均时间复杂度T(n)为 ____。
void HeapSort(HeapType &H) {
//堆排序
int i;
for (i=_______(___)_______;i>0;--i)
HeapAdjust(H,i,H.length);//把H.r[1..H.length]建成大顶堆
for (i=_______(___)_______;i>1;--i) {
void SelectSort(SqList &L) {//简单选择排序
int i,j;
for(i=1; _______(___)_______;i++) { j=SelectMinKey(L,i);//在L.r[i..L.length]中找最小的记录
if (i!= _______(___)_______) { Swap_record(____(___)____); //交换 Output_Data_List1(L,i);//==输出中间结果
int length;
//顺序表长度
}SqList;
//顺序表类型
//== 2.2 采用顺序表存储表示的堆
typedef SqList HeapType;
13:30:50
CH.6
13
习题—编程题
//== 3. 定义基本操作
//== 3.1 插入排序
void InsertSort(SqList &L) {
15、 直接插入排序的空间复杂度S(n)为 ____。
16、 快速排序的时间复杂度T(n)为 ____。
13:30:50
CH.6
5
习题—填空题
17、 快速排序的空间复杂度S(n) 为 ____。。
18、 直接选择排序的时间复杂度T(n)为 ____。
19、 直接选择排序的空间复杂度S(n) 为____。
}
}//QSort
CH.6
15
习题—编程题
31.已知某排序基本操作的头文件,试写出快速排序函 数中的分区函数 Partition(SqList &L,int low,int high) 实现的算法。
int Partition(SqList &L,int low,int high) {//快速排序中的 分区
//将大于枢轴的记录移到
}
L.r[low]=temp;
//定位枢轴记录
return low;
}//Partition
13:30:50
CH.6
17
习题—编程题
32.已知某排序基本操作的头文件如下,试写出简单选择排序 函数 SelectSort(SqList &L)实现的算法,可以调用 SelectMinKey(SqList L,int i)和Swap_record(RcdType &x,RcdType &y)函数。
2、 快速排序属于_____。
[A]: 插入排序 [B]: 交换排序 [C]: 选择排序 [D]: 归并排序
3、 堆排序属于_____。
[A]: 插入排序 [B]: 交换排序 [C]: 选择排序 [D]: 归并排序
CH.6
2
习题—选择题
4、 _____是稳定的。
//保存当前堆顶记录
for (j=2*s; _______(___)_______;j*=2) {
if (j<m && LT(H.r[j].key,H.r[j+1].key))
___(___)___; // j 为两个孩子中key较大者
if (!LT(rc.key,H.r[j].key)) break;
#define MAXSIZE 20 //数据表的最大长度
typedef struct {
KeyType key;
//关键字
InfoType otherinfo;
//其他数据项
}RcdType;
//记录类型
typedef struct {
RcdType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元
}
}
}//SelectSort
13:30:50
CH.6
18
习题—编程题
33.已知某排序基本操作的头文件如下,试写出堆排序函数 HeapSort(HeapType &H)实现的算法,可以调用 HeapAdjust(HeapType &H,int s,int m)和 Swap_record(RcdType &x,RcdType &y)函数。
13:30:50
CH.6
3
习题—判断题
7、排序算法的稳定性是指:是否允许出现关 键字相同的数据元素。