数据结构与算法 Data Structures and Algorithm

数据结构与算法Data Structures and Algorithm

数据结构 – Data Structures

西安电子科技大学 , Xidian University, China 2

课程目录第 1 章概论第 2 章线性表第 3 章栈和队列第 4 章串和数组第 5 章递归和广义表第 6 章树和二叉树第 7 章图第 8 章查找第 9 章内排序第 10章文件第 11章算法设计技术



第一章概论本章内容：

1.1 什么是数据结构1.2 算法和算法分析

本章学习要点：1. 熟悉各名词、术语的含义，掌握基本概念。2. 理解算法五个要素的确切含义。3. 掌握计算语句频度和估算算法时间复杂度的基本方法。



数据结构是一门讨论“描述现实世界实体的数学模型 ( 非数值计算 ) 及其上的操作在计算机中如何表示和实现”的学科。

数据结构的定义

数据结构：是指数据以及数据元素相互之间的联系 , 可以看作是相互之间存在着某种特定关系的数据元素的集合。



数据结构的内容对数据结构的内容包括以下几个方面：①数据的逻辑结构，指数据元素之间的逻辑关系。②数据的存储结构，指数据元素及其关系在计算机

存储器中的存储方式，也称为数据的物理结构。③数据运算，指施加在数据上的操作。



算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中，每一条指令表示一个或多个操作。粗略地说，算法是为了求解问题而给出的一个指令序列，程序是算法的一种具体实现。

一个算法必须满足以下五个重要特性：

什么是算法

1. 有穷性 2. 确定性 3. 可行性4. 有输入 5. 有输出



(1) 有穷性 : 算法在有穷步之后结束，每一步在有穷时间内完成。

(2) 确定性 : 算法中的每一条指令有明确的含义，无二义性。

(3) 可行性 : 可通过已经实现的基本运算执行有限次来实现算法中的所有操作。

算法的重要特征



算法分析算法分析的两个主要方面是分析算法的时间复杂度和空间复杂度。算法的执行时间主要与问题的规模有关。问题规模是一个与输入有关的量。　　语句频度是指算法中该语句被重复执行的次数。算法中所有语句的频度之和记作Ｔ (n) ，是该算法所求解问题规模的函数。当问题规模趋向无穷大时，Ｔ (n) 的数量级称为渐进时间复杂度，简称时间复杂度，记作Ｔ (n)=O(f(n)) 。通常采用算法中表示基本运算的语句的频度来分析算法的时间复杂度。



练习题举例1. 数据结构中的逻辑结构是指 ( 　 ) ，物理结构是指（　）。2. 算法的基本特征包括有穷性、 (　　)、 (　　) 、有输入和输出。3. 算法的有穷性是指（　）。4. 算法的确定性是指（　）。5. 算法的可行性是指（　）。6. 算法分析的两个主要方面是分析算法的（　）和空间复杂度。



练习题举例1. 语句频度是指（　）。

2. 设 n 为正整数，对下面的程序段，写出语句①、②、③的频度及该程序段的时间复杂度。

for (i=1; i <=n; i++)

{

s=0; ①　n

for (j=1; j <=n; j++)

s=s+i×j; n② 2

if (s%2) n③

print(s);

}



第二章线性表本章内容：

2.1 线性表的基本概念 2.2 线性表的顺序存储结构 2.3 线性表的链式存储结构 2.4 双向链表 2.5 链表的应用

本章学习要点：1. 掌握线性关系的定义。2. 熟练掌握线性表的顺序存储结构（顺序表）和链表存储结构

（链表），及线性表的各种基本操作的实现。3. 从时间和空间复杂度的角度综合比较线性表两种存储结构的

不同特点及其适用情况。




2.1 线性表的基本概念 2.2 线性表的顺序存储结构 2.3 线性表的链式存储结构 2.4 双向链表 2.5 链表的应用

一个线性表是有 n 个数据元素的有限序列： (a1， a2 …，， ai …，， an)

线性表的顺序存储指用一组地址连续的存储单元依次存储线性表的数据元素。这称为顺序表。

特点：存储单元地址连续（需要一段连续空间）逻辑上相邻的数据元素其物理位置也相邻存储密度大（ 100%）随机存取，元素的存储位置存在如下关系： Loc(ai) = Loc(a1) + (i - 1) * d (1≤i≤n)

a1

a2...

ai

an

...

d




2.1 线性表的基本概念 2.2 线性表的顺序存储结构 2.3 线性表的链式存储结构 2.4 双向链表 2.5 链表的应用线性表的链式存储指用任意的存储单元存放线性表中的元

素，每个元素与其直接前驱和（或）直接后继之间的关系用指针来表示。这称为链表。

单链表示意图

a1 a2 ai-1 … ai

ai+1 an ^…

head

头指针头结点首元结点



第二章线性表

单链表示意图

a1 a2 ai-1 … ai

ai+1 an ^…

head


头指针是指向链表第一个结点的指针。头结点是链表中的第一个结点但是头结点中不存放

数据元素。



单链表、循环链表和双向链表

（ a ）单链表示意图

a1 a2 ai-1 … ai

ai+1 an ^…

head


tail

a2a1 anan-1…

(b) 循环单链表

head

a1

∧a2 an-1 anai

…∧

（ c ）双向链表示意图

…



单链表、循环链表的类型定义

（ a ）单链表示意图

a1 a2 ai-1 … ai

ai+1 an ^…

head


tail

a2a1 anan-1…（ b ）循环单链表

typedef struct LNode { ElemType data; /* 存储数据元素 */ struct LNode *next; /* 指向后继结点 */}SLink,*LinkList;

LinkList head,tail;



练习题举例1. 顺序表中，逻辑上相邻的数据元素在物理位置上 ( 也相邻 ) 。

线性表 L=(a1,a2,...,an) 采用顺序存储，假定在不同的 n+1 个位置上的插入概率相同，则插入一个新元素平均需要移动的元素个数是 (　n/2　) 。

2. 在一个长度为 n 的顺序表中 , 在第 i 个元素 (1 i n) 之前插入一个新元素时 , 需向后移动 (　　n-i+1　) 个元素。

3. 在表长为 n 的单链表中 , 取得第 i (1 i n) 个数据元素必须从 (　头指针 ) 出发开始寻找。

4. 在一个具有 n 个结点的有序单链表中，插入一个新结点并保持链表有序的算法时间复杂度为 ( O(n) ) 。

5. 若线性表中最常用的操作是删除第一个结点或在最后一个结点后插入一个结点，则 ( C ) 存储方式最节省运行时间及空间。

A. 单向链表 B. 仅含头指针的单向循环链表 C. 仅含尾指针的单向循环链表 D. 双向链表



练习题举例6. 请对线性表进行顺序存储和链式存储的特点作比较。

基于空间的考虑：顺序表的存储空间是静态分配的，而链表的存储空间是动态分配的。因此，当线性表的长度变化较大，难以估计其存储空间规模时，宜采用动态链表作为存储结构。反之，则采用顺序表作为存储结构。另外，存储密度越大，则存储空间的利用率越高。显然，顺序表的存储密度为 1 ，而链表的存储密度小于 1 。因此，当线性表的长度变化不大，易于事先确定其大小时，为了节省空间，采用顺序表为宜。

基于时间的考虑：顺序表是由向量实现的，它是一种随机存取结构，而链表是一种顺序存储结构。因此，若线性表的操作主要是进行查找，很少进行插入和删除操作时，采用顺序表作存储结构为宜。反之，则采用链表作为存储结构。



练习题举例7. 编写算法，将一个带头结点的单链表就地逆置。（请先说明算

法思路，再用类高级语言编写算法。）8. 在单链表的删除结点算法中，如果已知 p 指针指向的被删结点

存在直接后继，则我们可以通过把 p 的直接后继值送到 p 中再删去 p 的后继来完成，这样只需要 O(1) 时间。试编写实现这一思想的算法。

9. 设有一个循环链表，其结点值均为正整数。试写出一个算法，反复找出链表中结点值最小的结点，并输出该值；然后将该结点从链表中删除，直到链表空为止，最后再删除表头结点。（简要说明算法思想）



练习题举例7. 编写算法，将一个带头结点的单链表就地逆置。（请先说明算

法思路，再用类高级语言编写算法。）

单链表逆置

…a2a1 an

∧an-1

…aiai-1 ai+1

head

…a2a1

∧anan-1

…aiai-1 ai+1

head



单链表就地逆置算法思路将原链表看成由两部分组成：已经完成逆置的部分和未完成逆置的部分。

设置两个指针 p和 s， p 指向已完成逆置部分链表的第一个结点， s 指向未逆置部分的第一个结点。

…a2a1

∧an

∧an-1

…aiai-1 ai+1

head

p s




设置两个指针 p和 s， p 指向已完成逆置部分链表的第一个结点（表头结点）， s 指向未逆置部分的第一个结点。

初始时令指针 p 指向第一个元素结点， s 指向 p所指结点的后继。将第一个元素结点的指针域置为空。

149∧

40∧

2715head

p s p = head->next;if (p) s = p->next;p->next = NULL;




设置两个指针 p和 s， p 指向已完成逆置部分链表的第一个结点（表头结点）， s 指向未逆置部分的第一个结点。


对于 s所指结点，令 t 指向其后继结点，然后将其指针域改为指向 p所指结点，并用 s更新 p， t更新 s 。重复该过程，直到未逆置部分的结点全部处理完。

149∧

40∧

2715head

p s t = s ->next;s->next = p; // ①

p = s; // ②s = t; // ③

t

①

② ③

①






对于 s所指结点，令 t 指向其后继结点，然后将其指针域改为指向 p所指结点，并用 s更新 p， t更新 s 。重复该过程，直到未逆置部分的结点全部处理完。

149∧

40∧

2715head

p s t = s ->next;s->next = p; // ①

p = s; // ②s = t; // ③

t

①

② ③

①

算法：void　reverse(LinkList　head)　{　　// 带头结点的单链表就地逆置　　　　p　=　head->next;　　　　if　　(!p)　return;　　　　　　// 空链表　　　　s　=　p->next;　　p　->　next　=　NULL; while　(s)　{　　　　　　　　　　t　=　s　->　next;　　　　　s　->　next　=　p;　　　　p　=　s;　　　　　　　s　=　t;　　　　}　　　　　head　->　next　=　p;}　　　　　　　　　　



单链表就地逆置算法思路 ( 二 )

将原链表看成由两部分组成：已经完成逆置的部分和未完成逆置的部分。



将未逆置部分的结点逐个插入到头结点之后。




149∧

40∧

2715head

pp = head->next;if (p) s = p->next;p->next = NULL;

149∧

40∧

2715head

p s

s

p = s;s = s ->next;p->next = head -> next;head -> next = p;




149∧

40∧

2715head

p s

p = s;s = s ->next;p->next = head -> next;head -> next = p;

149∧

40∧

2715head

p s



单链表就地逆置算法思路 ( 二 ) 将原链表看成由两部分组成：已经完成逆置的部分和未完成逆置的部分。



将未逆置部分的结点逐个插入到头结点之后。算法：void　reverse(LinkList　head)　{　　// 带头结点的单链表逆置　　　　p　=　head->next;　　if　(!p)　return;　　　　s　=　p->next;　　p->next　=　NULL;　　　　while　(s)　{　　　　　　　p　=　s;　　s　=　s　->　next;　　　　p　->　next　=　head　->　next;　　　head->next　=　p;　　　　}　}　　　　　　　　　　



第三章栈和队列本章内容：

3.1 栈 3.2 队列

本章学习要点：1. 掌握栈和队列的运算特点，并能在相应的应用问题中正

确选用。2. 熟练掌握栈类型的两种实现方法，特别应注意栈满和栈

空的条件以及其描述方法。3. 熟练掌握循环队列和链队列的基本操作实现算法，特别注意队满和队空的描述方法。



第三章栈和队列本章内容：

3.1 栈 3.2 队列

栈是后进先出的线性表，队列是先进先出的线性表；在应用中，栈和队列都是容器，因此需要判断是否“栈空”或“队空”；

采用顺序存储结构时，栈和队列都可能存在“溢出”问题，分别称为“栈满”、“队满”；

采用顺序结构的队列常见形式是循环队列。



栈的运算演示(1)A、 B、 C、 D 四个元素依次进入一个栈，再依次出栈，

得到一个输出序列 DCBA 。

D

C

B

A

BCD

A

栈的基本运算

D

C

B

A

CD

B

A

D

C

B

A

D

C

B

A

D

C

B

A

D

C

B

A

D

C

B

A

ABCD




得到一个输出序列 DCBA。

D

C

B

A

D

C

B

A

栈的基本运算

D

C

B

A

D

C

B

A

D

C

B

A

DC

B

A

D

C

B

A

DCB

A

D

C

B

A

DCBA




得到一个输出序列 BCDA 。

D

C

B

A

BCD

A

栈的基本运算

D

C

B

A

CD

B

A

D

C

B

A

B

A

D

C

B

A

C

A

D

C

B

A

ABCD





栈的基本运算

CD

D

C

B

A A

D

C

B

A

C

A

BC

D

C

B

A A

D

C

B

A

D

A

D

D

C

B

A A

BCD





栈的基本运算

D

C

B

A

D

A

D

C

B

A A

BCD

D

C

B

A A

BCDA

D

C

B

A



练习题举例1. 用 S 、 X 分别表示入栈、出栈操作，若元素入栈顺序为 1 、 2 、3 、 4 ，为得到出栈序列 1 、 3 、 4 、 2 ，则相应的 S 和 X操作串是（ SXSSXSXX ）。

2. 若 push、 pop 分别表示入栈、出栈操作，初始栈为空且元素 a 、 b 、 c 依次进栈，则经过操作序列push、 push、 pop、 pop、 push、 pop 之后，得到的出栈序列为 (　b　a　c　　) 。

3. 如果进栈的序列为 1 、 2 、 3,　则不能得到的出栈序列为（ 3　1　　2 ）。



循环队列

Q.front

Q.rear

12

7 0

35

4

6

e4e5

e6

e7

e8 e9

e10

令队列空间中的一个单元闲置，使得在任何时刻，保持 Q.rear和 Q.front 之间至少间隔一个空闲单元

队列满 (full) ： (Q.rear+1)%MAXSIZE == Q.front 队列空： Q.rear==Q.front 队列长度： (Q.rear - Q.front+ MAXSIZE)%

MAXSIZE

MAXSIZE=8



练习题举例1. 在循环队列结构中（队列空间容量为M ），Ｑ .rear 指向队尾

元素所在位置，Ｑ .front 指向队头元素所在位置，则队列的长度为 (　(Q.rear　-　Q.front　+　1　+　M)　%　M　) 。

2. 用循环链表表示的队列长度为 n ，若只设头指针，则出队和入队的时间复杂度分别是（ O(1)　　）和（ O(n) ）；若只设尾指针，则出队和入队的时间复杂度分别是（ O(1) ）和（ O(1) ）。

循环链队列

front a2a1 anan-1…

taila2a1 anan-1…



练习题举例 1. 若以域变量 rear和 length 分别指示循环队列中队尾元素的

位置和队列中元素的个数。请完善下面的入队列和出队列的算法。

#define MAXQSIZE 100 // 最大队列长度 typedef struct { Qelemtype *base; //base 为队列所在存储区域的首地址 int length; //队列长度 int rear; //队尾元素位置 }SqQueue；

Q.rear

12

7 0

35

4

6

e4e5

e6

e7

e8 e9

e10

MAXSIZE=8



练习题举例1. 若以域变量 rear和 length 分别指示循环队列中队尾元素的位

置和队列中元素的个数。请完善下面的入队列和出队列的算法。 #define MAXQSIZE 100 // 最大队列长度 typedef struct { Qelemtype *base; //base 为队列所在存储区域的首地址 int length,rear; //队列长度和队尾元素位置 }SqQueue； Status EnQueue（ SqQueue &Q, Qelemtype e ）｛ // 将元素 e 插入队列 Q if （（ 1 ）） return ERROR； //队列满，无法插

入 Q.rear ＝（ 2 ） ; // 计算元素 e 的插入位置（ 3 ）＝ e; // 在队尾加入新的元素 Q.length++； //队列长度加 1 Return OK; ｝// (1) Q.length > ＝ MAXSIZE (2) （ Q .rear + 1 ）％　MAXSIZE (3)

Q.base[Q .rear]



练习题举例1. 若以域变量 rear和 length 分别指示循环队列中队尾元素的位

置和队列中元素的个数。请完善下面的入队列和出队列的算法。 #define MAXQSIZE 100 // 最大队列长度 typedef struct { Qelemtype *base; //base 为队列所在存储区域的首地址 int length,rear; //队列长度、队尾元素位置 }SqQueue；

Status DeQueue（ SqQueue &Q, Qelemtype &e ）　　　　　｛　　　 // 删除队头元素，并用 e 带回其值 if （（ 4 ）） return ERROR； //队列空 e ＝ Q.base[ （ 5 ） ]; // 取队头元素 Q.length--； //队列长度减 1 return OK; ｝// (4) Q.length <=0　　　　　　 (5) （ Q .rear – Q.length + 1+ MAXSIZE ）％ MAXSIZE



练习题1. 写出用单链表表示栈的入栈算法和出栈算法。2. 写出用循环单链表表示队列的判断队空、入队列和出队列算法。



第四章串和数组本章内容：

4.1 串 4.2 数组 4.3 稀疏矩阵

本章学习要点：1. 掌握串的定义、基本运算及模式匹配过程。2. 掌握数组的定义及存储，掌握对特殊矩阵进行压缩存储

时的下标变换公式。3. 了解稀疏矩阵的压缩存储方法的特点。



串和数组1. 串的基本运算串赋值、串复制、求串长、判断串相等、串连接、求子串等2. 模式匹配 BF 算法（基本的模式匹配算法，布鲁特 -福斯算法） KMP 算法（改进的模式匹配算法）3. 数组元素的顺序存储（按行存储、按列存储）4. 特殊矩阵的压缩存储（对称矩阵、三角矩阵、对角矩阵）5. 稀疏矩阵的压缩存储（三元组线性表）



KMP 模式匹配算法中求模式串的 next函数值

next[j] =

Max{k|0<k<j 且‘ t0...tk-1’==‘tj-k...tj-1’}

-1 当 j==0, 表示与模式串第一个字符比较就失败，应使主串 i 指向下一字符再与模式串的第一字符比较 (i++;j++) 。

0　　　其他情况 (j==1或之前没有匹配部分 )

next[j]

a b c a c

j 0 1 2 3 4

模式串

-1 0 0 0 1



行优先顺序或以行为主序存储方式：将数组元素按行排列，第 i+1行的元素紧接在第 i 行元素之后。以二维数组为例，按行优先顺序存储的线性序列为：

a11,a12,…,a1n,a21,a22,…a2n,……,am1,am2,…,amn

LOC(aij) = LOC(a11)+[(i-1)*n+j-1]*d

数组的表示

Am×n=

a11 a12 … a1n

a21 a22 … a2n

… … aij …

am1 am2 … amn



列优先顺序或以列为主序存储方式：将数组元素按列向量排列，第 j+1个列向量紧接在第 j 个列向量之后， A 的m*n个元素按列优先顺序存储的线性序列为：

a11,a21,…,am1,a12,a22,…am2,……,an1,an2,…,anm

LOC(aij)=LOC(a11)+[(j-1)*m+i-1]*d

Am×n=

a11 a12 … a1n

a21 a22 … a2n

… … aij …

am1 am2 … amn

数组的顺序表示



特殊矩阵是指非零元素或零元素的分布有一定规律的矩阵 , 为了节省存储空间 , 特别是在高阶矩阵的情况下 , 可以利用特殊矩阵的规律 , 对它们进行压缩存储 , 也就是说 , 使多个相同的非零元素共享同一个存储单元 , 对零元素不分配存储空间。

特殊矩阵的压缩存储

常见的特殊矩阵有对称矩阵、三角矩阵、对角矩阵等。



对称矩阵的压缩存储

对称矩阵

数组 B ai,j an,na1,1 a2,1 a2,2 a3,1

1 2 3 4 k m下标

a1,1 a1,2 … a1,n

a2,1 a2,2 … a2,n

… … ai,j …

an,1 an,2 … an,n

a1,1

a2,1 a2,2

… ai,j …

an,1 an,2 … an,n

…

n*n的对称矩阵 A 元素压缩存储到一维数组 B

k = i(i-1)/2 + j – 1 + 1 = i(i-1)/2+j

…



对角矩阵的压缩存储

a0,0 a0,1

a1,0 a1,1 a1,2

a2,1 a2,2 a2,3

…. ai,j …. an-2,n-3 an-2,n-2 an-2,n-1

an-1,n-2 an-1, n-

1

a0,0 a0,1 a1,0 ai,j数组 B

1 2 k k+1 m下标 0

... ...

对角矩阵是指所有的非零元素都集中在以主对角线为中心的带状区域中。下图为三对角矩阵示意图。

k = 3i - 1+ j – i +1

= 2i + j



稀疏矩阵的压缩存储稀疏矩阵中的非零元素的分布一般是没有规律的，因此在压缩存储稀疏矩阵时，不仅存储非零元素，同时，还必须记下它所在的行位置和列位置（ i,j)。反之，一个三元组 (i,j,aij) 惟一确定了矩阵 A 的一个非零元。因此，稀疏矩阵可由表示非零元的三元组及其行列数唯一确定。

M=

0　　　12　　　　9　　　　0　　　　0　　　　0　　　　0　　0　　　　0　　　　0　　　　0　　　　0　　　　0　　　　0-3　　　　0　　　　0　　　　0　　　　0　　　14　　　　0　0　　　　0　　　24　　　　0　　　　0　　　　0　　　　0　0　　　18　　　　0　　　　0　　　　0　　　　0　　　　015　　　　0　　　　0　　　–7　　　0　　　　0　　　　0



( (1,2,12), (1,3,9), (3,1,-3), (3,6,14), (4,3,24), (5,2,18), (6,1,15), (6,4,-7) )

M=

0　　　12　　　　9　　　　0　　　　0　　　　0　　　　0　　0　　　　0　　　　0　　　　0　　　　0　　　　0　　　　0-3　　　　0　　　　0　　　　0　　　　0　　　14　　　　0　0　　　　0　　　24　　　　0　　　　0　　　　0　　　　0　0　　　18　　　　0　　　　0　　　　0　　　　0　　　　015　　　　0　　　　0　　　–7　　　0　　　　0　　　　0

例如，一个 6*7的稀疏矩阵

用三元组表表示稀疏矩阵中的非零元素

稀疏矩阵的压缩存储



练习题举例1. 模式串“ abcde” 的子串数目为 (　1+2+3+4+5+1　) 。 2. 已知 S　=　“abcaba”,　则其 next函数值为（ -1　0　0　0　1　2

）。3. 将一个三对角矩阵 A[1..100,1..100] 中的元素按行存储在一维数组 B[1..298] 中，元素 A[66,65] 在数组B 中的下标为（ A　　）。 //2i+j-2

A.　195　　　　　　　B.　196　　　　　　　　C.　197 　　　　D.　198



练习题举例4. 设有下三角矩阵 A[0..8,0..8] 如下所示，将该三角矩阵的非零元素按行优先压缩存储在数组 B[1..m] 中，如果每个元素占两个存储单元，问： 1)　m 的值至少为多少？ A[3,1] 的值存储在数组B 的哪个元素中？ 2)若 A[0,0] （即 B[1] ）的起始地址为 100 ，则元素 A[i,j](0≤i≤8,0≤j≤i) 的地址计算公式是什么？

A7,0

...

A0,0

A7,2

A8,3

...

A1,1

A8,8

A7,7

0...

..

A1,0

A8,0

A7,1

A8,2A8,1

.

1) 45 B[8]

2) 100+(i(i+1)/2+j)*2



第五章递归和广义表本章内容：

5.1 递归 5.2 广义表的定义、存储及基本运算 5.3 广义表的递归算法

本章学习要点：1. 掌握递归算法的分析。2. 掌握广义表的定义及基本运算。



练习题举例1. 设广义表 L= （（（ a,　b ）），（ c ， d ）， e ），则 L的

表头 ( （（ a,　b ））　　 ) ，表尾是 ( （（ c ， d ）， e ）　 ) 。2. 已知广义表 L　=（ ((f)),(b),c,(a),(((d,e)))） ,则该广义表

的长度和深度分别为（ 5　　）、（ 4　　），用求表头和求表尾的方式求出原子 a 的式子为(　head(head(tail(tail（ tail(L)))))　) 。



第六章树和二叉树本章内容：

6.1 树 6.2 二叉树 6.3 二叉树的基本运算 6.4 二叉树的遍历 6.5 二叉树与树之间的转换 6.6 线索二叉树 6.7 哈夫曼树本章学习要点：

1. 掌握树和二叉树的定义。2. 掌握二叉树的遍历运算及其他运算方法。3. 掌握线索二叉树的基本运算。4. 掌握哈夫曼树的构造方法。5. 掌握二叉树与树之间的相互转换方法。



第六章树和二叉树二叉树或者是一棵空树；或者由一个根结点和两棵互不相交的称为左子树和右子树的二叉树组成。

(a) (b)

(c) (d) (e)



满二叉树满二叉树中所有分支结点都有左孩子和右孩子，叶结点都集中在二叉树的最后一层。

A

B C

D E

H I J K

F G

L M N O

1

2 3

4 5 6 7

8 9 10 15 11 12 13 14

满二叉树

满二叉树结点的编号：从树根为 1 开始 , 按照层数从小到大、同一层从左到右的次序进行。



完全二叉树完全二叉树中，最多只有最下面两层的结点的度数可以小于 2 ，最下面一层的叶结点都排列在该层最左边的位置上。

完全二叉树结点的编号：从树根为 1 开始 , 按照层数从小到大、同一层从左到右的次序进行。

A

B C

D E

H I J K

F G

1

2 3

4 5 6 7

8 9 10 11

完全二叉树



练习题举例

A

B C

D E

H I J K

F G

L M N O

1

2 3

4 5 6 7

8 9 10 15 11 12 13 14

满二叉树

1. 一棵满二叉树中共有 n 个结点，其中有m 个叶子结点，则 n和m 的关系为（ n=2m-1 ）。

2. 在完全二叉树中，若一个结点没有左孩子子结点，则它一定没有 (　B　　) 。

A ．父结点 B ．右孩子结点　　　　　C ．左兄弟结点 D ．右兄弟结点

A

B C

D E

H I J K

F G

1

2 3

4 5 6 7

8 9 10 11

完全二叉树



二叉树的性质性质 1 非空二叉树上第 i层上至多有 2i-1 个结点 i≥1 。性质 2 高度为 h 的二叉树至多有 2h-1 个结点 (h≥1) 。性质 3 非空二叉树上叶结点数 ( 度为 0)等于双分支结点数 ( 度为 2) 加 1 。性质 4 对完全二叉树中编号为 i 的结点 (1≤i≤n ， n≥1 ，n 为结点数 ) ，可以算出其左孩子结点、右孩子结点和父结点的编号（若这些结点存在）。性质 5 具有 n 个 (n ＞ 0) 结点的完全二叉树的高度为 log2 (n+1) 或 log2n+1 。

A

B C

D E

H I J K

F G

1

2 3

4 5 6 7

8 9 10 11

完全二叉树



二叉树的顺序存储二叉树的顺序存储指的是用元素在数组中的下标表示一个

结点与其孩子和父结点的关系 .完全二叉树的顺序存储

EED

C

F

A

BA B C D E F1 2 3 4 5 6 7 8 9 10 11 12

非完全二叉树的顺序存储

EE

GF

C

D

A

B

A B C D E F G1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

非完全二叉树不适合进行顺序存储



二叉树的链式存储一般用二叉链表存储二叉树 ( 每个结点有两个指针域 )

EE

GF

C

D

A

B

A

∧ B ∧ C

E∧ D ∧

∧ F ∧ ∧ G ∧

root

Lchild data Rchild



二叉树的遍历运算树的遍历是访问树中每个结点仅一次的过程。可以认为遍

历是把所有的结点放在一条线上，或者将一棵树进行线性化的处理。

D

L R

根结点

根的左子树

根的右子树

先序遍历 DLR 、中序遍历 LDR 、后序遍历 LRD 层序遍历



二叉树的遍历运算先序遍历 DLR ：访问根结点、先序遍历左子树、先序遍历右子树

中序遍历 LDR ：中序遍历左子树、访问根结点、中序遍历右子树

后序遍历 LRD ：后序遍历左子树、后序遍历右子树、访问根结点

D

L R

1

2 3



二叉树的遍历运算先序遍历：访问根结点、先序遍历左子树、先序遍历右子树。下图的

先序遍历序列为 A B D E G C F 。中序遍历：中序遍历左子树、访问根结点、中序遍历右子树。下图的

中序遍历序列为 D B G E A C F 。后序遍历：后序遍历左子树、后序遍历右子树、访问根结点。下图的

后序遍历序列为 D G E B F C A 。层序遍历：先根后子树、先左子树后右子树。下图的层序遍历序列为

A B C D E F G 。

B

A

C

ED

G

F

root



练习题举例1. 在有 n 个结点的二叉树的二叉链表中必定存在（ n+1 ）个空

链域。2. 前序遍历序列与中序遍历序列相同的二叉树为（ D　）。　　　A.　根结点无左子树的二叉树　　　B.　根结点无右子树的二叉树　　　C.　只有根结点的二叉树或非叶子结点只有左子树的二叉树　　　D.　只有根结点的二叉树或非叶子结点只有右子树的二叉树 3. 已知一棵二叉树的先序遍历序列为 ABDGCEF ，中序遍历序列为 DGBAECF ，画出此二叉树。



3. 已知先序序列为 ABDGCEF ，中序序列为 DGBAECF ，构造二叉树。

根结点： A左先序 :BDG 左中序 :DGB右先序 :CEF 右中序 :ECF

根结点： B左先序 :DG 左中序 :DG右先序 : 空右中序 : 空

根结点： D左先序 : 空左中序 : 空右先序 :G 右中序 :G

根结点： G左先序 : 空左中序 : 空右先序 : 空右中序 : 空

根结点： C左先序 :E 左中序 :E右先序 :F 右中序 :F

根结点： E左先序 : 空左中序 : 空右先序 : 空右中序 : 空

根结点： F左先序 : 空左中序 : 空右先序 : 空右中序 : 空



树（森林）采用孩子兄弟链存储结构。可以将一棵树或一个森林转换为一棵二叉树，反之亦然。

二叉树与树、森林之间的转换

树的孩子兄弟链存储结构是指在一个结点中既指出当前结点的第一个孩子，也指示出当前结点的兄弟。下图 (a) 的树对应的孩子兄弟链存储结构如图 (b) 所示。

A

B C

F D E

(a)

G

A ∧

B

∧ D

∧ C ∧

E

∧ G ∧

∧ F ∧

(b)



A

B C D

E

F

G

H I

A

B E

F G C

D H

I

(a) (c)

A

B C D

E

F

G

H I

(b)

左指针：父子关系

右指针：兄弟关系

森林转换为二叉树的过程



A

D H B

F C G

E

A

B

D C

F E H G

(a) (c)

A

B

D C

F E H G

(b)

将一棵二叉树还原为树

二叉树还原为森林、树



线索二叉树对于具有 n 个结点的二叉树，采用二叉链存储结构时，每个

结点有两个指针域，总共有 2n 个指针域，又由于只有 n-1

个结点被有效指针所指向（ n 个结点中只有树根结点没有被有效指针域所指向），则共有 2n-(n-1)=n+1 个空链域。

遍历二叉树的结果是一个结点的线性序列。可以利用这些空链域存放指向结点的前驱和后继结点的指针。这些指向结点在某种遍历序列中的“前驱”和“后继”的指针，称作线索。

EE

C

D

A

B

A

∧ B ∧ C

∧ E ∧∧ D ∧

root



线索二叉树的存储类型定义

Ltag=

Lchild data Rchild

Lchild data Rchild RtagLtag

0 Lchild 指向左子树根结点

1 Lchild 指向前驱结点

Rtag=

0 Rchild 指向右子树根结点

1 Rchild 指向后继结点

typedef enum PointerTag {Link=0,Thread=1};

typedef struct BiThrNode{

ElemType data;

struct BiThrNode *Lchild,*Rchild;

PointerTag Ltag, Rtag;

}*BiThrTree;



B

A

C

ED

G

F

root

中序线索二叉树

NULL

中序序列：DBGEACF

NULL

在中序线索化二叉树上查找给定结点的前驱和后继结点

0 0

0 0 1 0

1 11 1 0 1

1 1



中序线索二叉树在中序线索二叉树上，查找 p所指结点的后继

分为两种情况：

(2) 若 p->Rtag=0 ，则 p 所指结点的中序后继必为其右子树中序遍历得到的第一个结点，即从 p 所指结点的右子树根出发，沿左指针链向下找，直到找到一个没有左孩子的结点为止，这个结点称为 p 的右子树中“最左下”的结点。

(1) 若 p->Rtag=1 ，则 p->Rchild 指向其后继结点；

B

A

C

ED

G

F

root

NULLNULL

0 0

0 0 1 0

1 11 1 0 1

1 1



哈夫曼树哈夫曼树（或最优二叉树）是一类带权路径长度最短的树，

这种树的叶子结点带有权值。路径和路径长度

从树中的一个结点到另一个结点之间的分支构成这两个结点之间的路径，路径上的分支数目称作路径长度。

结点的带权路径长度从根到该结点的路径长度与该结点权的乘积称为结点的

带权路径长度树的带权路径长度

树中所有叶子的带权路径长度之和称为树的带权路径长度，记作

n

1kkklwWPL



树的带权路径长度

a b c d7 5 2 4

7 5

d

c

a b4

2

WPL= 4*2 + 7*3 +5*3 + 2*1 = 46

WPL = 7*2+5*2+2*2+4*2 = 36



构造哈夫曼树设有四个叶子 a 、 b 、 c 和 d 的二叉树中，对应的权值

分别为 7 、 5 、 2 和 4 ，构造哈夫曼树。

a b c d7 5 2 4

a b c d7 5 2 4

6

a b c d7 5 2 4

6

a b c d7 5 2 4

6



练习题1. 设 n 为某棵哈夫曼树的叶子结点数目，则该哈夫曼树共有

（ 2n-1　）个结点。2. 已知组成电文的字符集 D 及其概率分布W 为： D=｛ a,b,c,d,e｝ W=｛ 0.25, 0.30, 0.12, 0.25， 0.08｝用哈夫曼算法为该字符集中的字符编码，画出哈夫曼树。

0.45

0.20

0.12 0.08

0.55

0.25 0.300.25

1.000 1

0 1

0 1

0 1

c e

ad b

a: 01

b:11

c: 000

d: 10

e: 001



练习题1. 二叉树第 i层上的结点数目最多为（ 2i-1 ）。2. 在 n 个结点的线索二叉树中，线索的数目是（ n+1 ）。3. 假设二叉树中所有非叶子结点都有左、右子树，则对有 m 个叶子结点的此类二叉树，结点总数为（　2m-1 ）。

4. 树 T 的度为 4 ，其中度为 1、 2、 3、 4 的结点个数分别为 4、2、 1、 1 ，则 T 中的叶子结点个数为（　8

）。 //n0=n2+2n3+3n4+1

5. 高度为ｈ的满 k叉树，第 i层（ i＜ｈ）的结点数目为（　ki-1

）。



练习题7. 将一棵有 50 个结点的完全二叉树从树根结点开始，由根向下，

每一层从左到右，顺序地存储在一维数组 bt[1..50] 中，这棵二叉树最下面一层（最高层）最左边的结点存储在数组元素（ bt[32] ）中。

8. 已知二叉树 T 的后序遍历序列和中序遍历序列分别为 H C D F I

G B A E和 D H C E F B G I A 。（ 1 ）试画出二叉树 T；（ 2 ）画出与二叉树 T 对应的中序线索二叉树；（ 3 ）画出与该二叉树对应的树（森林）。



第七章图本章内容：

7.1 图的基本概念 7.2 图的存储结构 7.3 图的遍历 7.4 最小生成树 7.5 最短路径 7.6 拓扑排序 7.7 AOE网与关键路径本章学习要点：

1. 掌握图的基本概念及存储结构。2. 掌握图的遍历运算方法。3. 掌握求最小生成树的普里姆算法和克鲁斯卡尔算法。4. 理解求最短路径的迪杰斯特拉算法和弗洛伊德算法思想。5. 掌握拓扑排序过程，了解 AOE网及关键路径概念。



图的存储结构1. 邻接矩阵顶点之间相邻关系用矩阵表示。

A[i][j]=1　　顶点 vi与 vj 间有边( 弧 )

0　　顶点 vi与 vj 间无边( 弧 )0　　1　　0　　1　　01 0　　1　　0　　10　　1　　0　　1　　11 0　　1　　0　　00　　1　　1　　0　　0

V0

V4 V3

V1

V2 0　　1　　1　　00　　0　　0　　00　　0　　0　　11 0　　0　　0

V0 V1

V2 V3



图的存储结构1. 邻接矩阵顶点之间相邻关系用矩阵表示。

A[i][j]=wij　　顶点 vi与 vj 间有边 (弧 )

∞　　顶点 vi与 vj 间无边( 弧 )

8 2

7 3

496

2

2

1

V3

2

V2

V4V1

V6

V5

∞ 8 ∞ 7 4 9 8 ∞ 2 1 ∞ ∞∞ 2 ∞ 3 ∞ 2 7 1 3 ∞ ∞ 2 4 ∞ 2 ∞ ∞ 6

9 ∞ 2 2 6 ∞

123456

1 2 3 4 5 6



图的存储结构

例 V0

V4 V3

V1

V2

下标

v0 1

v1

v2

v3

v4

3 ∧

0 2 4 ∧

1 3 4 ∧

0 2 ∧

1 2 ∧

0

1

2

34

顶点：通常按编号顺序将顶点数据存储在一维数组中关联同一顶点的边：用线性链表存储

该结点表示边（ V0,V1） , 其中的 1是 V1的序号，即一维数组中的下标。

2. 邻接链表



图的存储结构

表头顶点的邻接顶点编号

和边相关的信息

指向下一个邻接顶点的指针

(a) 表结点结构

(b) 邻接链表

123456

2 8 5 4 6 9 4 7 ∧

1 8 3 2 4 1 ∧

2 2 5 2 6 2 4 3 ∧1 7 2 1 3 3 6 2 ∧

1 4 6 6 3 2 ∧

1 9 4 2 5 6 3 2 ∧

V1

V2

V3

V4

V5

V6

8 2

7 3

496

2

2

1

V3

2

V2

V4V1

V6

V5

2. 邻接链表



图的遍历从图的某个顶点出发，访问图中的所有顶点，且使每个顶

点仅被访问一次。这一过程叫做图的遍历。

遍历方法 : 深度优先遍历和广度优先遍历



图的遍历从顶点 v1 出发进行深度优先遍历（ DFS ） DFS遍历序列： v1 v2 v4 v8 v5 v3 v6 v7

V3V2

V4

V1

V6V5

V8

V7

V1

V2

V4

V5

V8

V3

V6

V7

V1

V2

V4

V8

V5

V3

V6 V7

从顶点 v1 出发进行广度优先遍历（ BFS ） BFS遍历序列： v1 v2 v3 v4 v5 v6 v7 v8



生成树

V3

V2

V4V1

V6

V5

V3

V2

V4V1

V6

V5

V3

V2

V4V1

V6

V5

无向图 G

生成树一个连通图的生成树是一个极小连通子图，它含有图中全部顶点，

但只有足以构成一棵树的 n-1条边。

图 G 的生成树



生成树的代价等于其边上的权值之和。

生成树的代价

V4

V1

V3

V2

V6V5

6

51

2

6

6

5

5

3 4

V4

V1

V3

V2

V6V5

6

16 5

4

V4

V1

V3

V2

V6V5

1

2

5

3 4

生成树最小生成树



最小生成树我们把具有权值最小的生成树称为最小生成树。普里姆算法和克鲁斯卡尔算法是两种常用的构造最小生成树的方法。

V4

V1

V3

V2

V6V5

6

51

2

6

6

5

5

3 4

V4

V1

V3

V2

V6V5

6

16 5

4

V4

V1

V3

V2

V6V5

1

2

5

3 4

生成树最小生成树



普里姆算法求最小生成树V1

V3

1V4

V1

V3

V2

V6V5

6

5

1

2

6

6

5

5

3 4

V1

V3

1

V6

V4

V1

V3

1

V6

4

4 2

V4

V1

V3

1V2

V6

4 22

5 V4

V1

V3

1V2

V6V5

4 22

5

3

V1



V4

V1

V3

V2

V6V5

6

51

2

6

6

5

5

3 4

V4

V1

V3

V2

V6V5

1

克鲁斯卡尔算法求最小生成树

V4

V1

V3

V2

V6V5

1

2

V4

V1

V3

V2

V6V5

1

23

V4

V1

V3

V2

V6V5

1

23 4



V4

V1

V3

V2

V6V5

6

51

2

6

6

5

5

3 4

V4

V1

V3

V2

V6V5

1

23 4

克鲁斯卡尔算法求最小生成树

V4

V1

V3

V2

V6V5

1

2

5

4

V1 、 V4 依附在同一个连通分量

3

V4

V1

V3

V2

V6V5

1

2

5

4

V3 、 V4 依附在同一个连通分量

3

V4

V1

V3

V2

V6V5

1

2

5

43



拓扑排序方法：1) 在有向图中选一个无前趋的顶点 v ，输出之；2) 从有向图中删除 v 及以 v 为尾的弧；3) 重复 1)、 2) ，直接全部输出全部顶点或有向图中不存在无前趋的结点时为止。

V5 V3

V2

V0

V1 V4 V6

拓扑排序

V0 V1 V2 V3 V4 V5 V6

V0 V2 V1 V3 V4 V5 V6

……

V1 V0 V4 V3 V2 V6 V5



V5V3

V2

V0

V1 V4 V6

拓扑排序

V5V3

V2

V1 V4 V6

V5V3

V2

V4 V6

V0 V0 V1

V5

V2

V4 V6

V0 V1 V3

V5

V2

V6

V0 V1 V3 V4

V5

V6

V0 V1 V3 V4 V2

拓扑序列之一： V0 V1 V3 V4 V2 V5 V6



最短路径问题1.　　单源点最短路径问题：从一个顶点到其余各顶点

的最短路径 ( 迪杰斯特拉算法 )

2.　　每一对顶点间的最短路径问题 ( 弗洛伊德算法 )



单源点最短路径

20

V4

V5

V0

V2

V3

V1

100

105

60

10

50

30

始点终点最短路径路径长度

v0　　　　v1　　　　　　　　无

v2　　　　　　　　(v0,v2)　　　　　　　10

v3　　　　　(v0,v4,v3)　　　　　50

v4　　　　　(v0,v4)　　　　　　　　30

v5　　　(v0,v4,v3,v5)　　　　　60

问题：给定一个带权有向图G 与源点 v ，求从 v 到G 中其他顶点的最短路径，并限定各边上的权值大于或等于 0 。迪杰斯特拉算法以路径长度递增的方式解单源点最短路径问题。



最短路径的求解过程

i=1

∞

10(v0,v2)

∞

30(v0,v4)

100(v0,v5)

i=2

∞

60(v0, v2,v3)

30(v0,v4)

100(v0,v5)

i=3

∞

50(v0, v4,v3)

90(v0, v4,v5)

i=4

∞

60(v0, v4,v3,v5)

i=5

∞

v2 v4 v3 v5

终点

v1

v2

v3

v4

v5

vj

S {v0,v2} {v0, v2,v4}{v0, v2,v4,

v3}

{v0, v2,v4,

v3,v5}

20

V4

V5

V0

V2

V3

V1

100

105

60

10

50

30

以 V0 为源点

迪杰斯特拉算法（ Dijkstra ）



练习题举例1. 对于有 n 个顶点的完全无向图，其边数 e 等于（ n(n-1)/2

）。2. 一个连通图的生成树是一个（极小）连通子图， n 个顶点的生成树有（　n-1 ）条边。

3. 有 5 个顶点的无向图，至少需要（ 7 ）条边才能保证是连通的。

4. 可以用（深度优先遍历）和（拓扑排序）方法判断有向图中是否存在环。



练习题举例1. 假设含 n 个结点的无向图形成一个环，则它的生成树为（ n ）

个。2.G 是一个有 28条边的非连通无向图，则该图至少有（ 9 ）个顶点。

3. 单源最短路径的 Dijkstra 算法是按路径长度（路经长度递增的次序）依次求解的。

4. 在一个无向图的邻接表中，若表结点的个数是m ，则图中边的条数是（ m/2　　）条。



练习题已知一赋权有向图如下： 1. 写出该图的邻接矩阵表示并据此给出从顶点 1 出发的深度优

先遍历序列； 2. 求该有向图的强连通分量数目； 3. 给出该图的两个拓扑序列； 4. 若将该图视为无向图，用克鲁斯卡尔算法求最小生成树。

33

6

4

5 4 35

3 7

1

432

5 6

7



第八章查找本章内容：

8.1 顺序查找 8.2 二分查找 8.3 分块查找 8.4 二叉排序树 8.5 平衡二叉树 8.6 哈希表查找

本章学习要点：1. 掌握顺序查找、二分查找方法，了解分块查找。2. 掌握二叉排序树的定义及查找、插入和删除运算方法。3. 了解平衡二叉树的定义及其构造、查找方法。4. 掌握哈希表的构造及查找方法。5. 掌握各种查找方法下平均查找长度的计算。



二分查找二分查找判定树是描述二分查找过程的二叉树

a4

a2 a6

a1 a3 a5 a7

a8

若有序顺序表为： a1<a2<a3<a4<a5<a6<a7<a8　　　　则其判定树（ (low+high)/2 ）如下：

ASL 成功 = (1+2+2+3+3+3+3+4)/8

= 21/8 ------- 等概率查找



二分查找二分查找判定树 : 描述二分查找过程的二叉树

若有序顺序表为： a1<a2<a3<a4<a5<a6<a7<a8　　　　则其判定树（ (low+high)/2 ）如下：

a4

a2 a6

a1 a3 a5 a7

a8

比 a1 小的所有元

素比 a8 大的所有元

素

大于 a2而小于a3 的所有元素

大于 a5而小于a6 的所有元素

ASL 失败 =

(3*7+4*2)/9 =

29/9



二分查找算法

int B_search(int A[], int n, int e) {

// 在有序表中查找元素 e ，若查找成功，则返回元素在表中的位置

// 否则返回 0

low=1; high=n;

while ( low<=high ) {

mid=[(low+high)/2];

if (A[mid]==e) return mid; // 查找成功 else if (e<A[mid]) high=mid-1;// 下一次到前半区查找 else low=mid+1; // 下一次到后半区查找 } //end of while

return 0; // 查找失败} //end of B_search

ASL 成功 ≈ log2n

ASL 失败 ≈ log2n

a4

a2 a6

a1 a3 a5 a7

a8



二叉排序树二叉排序树 (二叉检索树、二叉查找树 ) 定义

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

1) 若其左子树不空，则左子树上所有结点的值均小于它的根结点的值；

2) 若其右子树不空，则右子树上所有结点的值均大于它的根结点的值

3) 其左、右子树也分别为二叉排序树



查找：查找键值等于 key 的记录若二叉排序树为空树，则查找失败，返回；若根结点的键值等于 key ，则查找成功，返回；若根结点的键值大于 key ，则到根的左子树上继续查找；否则，到根的右子树上继续查找；

二叉排序树的查找运算

BSTNode *BSTSearch (BSTNode *bt, KeyType key) {//在 T 指向根的二叉排序树中递归地查找关键字等于 key 的数据元素// 若找到，返回指向该结点的指针，否则返回 NULL

if (bt==NULL) return NULL;

else if (bt->key==key) return bt;

else if (key < bt->key)

return BSTSearch (bt->lchild, key);

else

return BSTSearch (bt->rchild, key);}//BSTSearch

45

12 53

3 37 100

90

24 61

78

bt



查找：查找键值等于 key 的记录若二叉排序树为空树，则查找失败，返回；若根结点的键值等于 key ，则查找成功；若 key 小于根结点的键值，则到根的左子树上继续查找；否则，到根的右子树上继续查找；

二叉排序树的查找运算

BSTNode *BSTSearch (BSTNode *bt, KeyType key) {//在 T 指向根的二叉排序树中非递归地查找关键字等于 key 的数据元素// 若找到，返回指向该结点的指针，否则返回 NULL

p = bt;

while (p!=NULL && p->key!=key) {

if (key < p->key) p = p->lchild;

else p = p->rchild;

}

return p;}//BSTSearch

45

12 53

3 37 100

90

24 61

78

bt



若查找成功，则走了一条从根结点到某结点的路径，若查找失败，则走到一棵空的子树时为止。因此，最坏情况下，其平均查找长度不会超过树的高度。

n

iic

1ipASL

ASL 成功

=(1+2*2+3*3+4*2+5*2+6*1)/11

=38/11

二叉排序树的查找性能分析

ASL 失败 = (2+3*4+4*2+5*3+6*2) /12

= 49/12

45

12 53

3 37 100

90

24 61

78

55

大于 90 且小于 100 的

数

大于 100 的数

大于 12 且小于 24 的

数



二叉排序树的构造根据关键字序列 (45,24,53,12,37,93)所构造的二叉排序树

如下所示

45 45

24

45

24 53

12 37

45

24 53

45

24 53

12

45

24 53

12 37 93

Ø



二叉排序树的构造关键字序列为 (12,24,37,45,53,93)所构造的二叉排序树如

下所示

12 12

24

37

45

12

24

37

12

24

53

45

37

12

24

12

24

37

45

53

93

Ø



二叉排序树的形态具有 n 个结点的二叉树的高度取决于其形态，二叉排序树

的形态取决于关键字序列的初始排序

45

24 53

12 37 93

(a)

12

24

37

45

53

93

(b)

12

93

24

53

37

45(c)



45

12 53

3 37 100

90

24 61

78

二叉排序树的删除运算在二叉排序树中删除键值等于 key 的结点时，需要考虑

以下情况 : 待删除的结点是叶子结点；待删除的结点是仅有左子树或右子树的结点；待删除的结点既有左子树又有右子树；



平衡二叉树平衡二叉树或者是一棵空树，或者是具有下列性质的二叉树：

它的左子树和右子树都是平衡二叉树，且左、右子树的深度之差的绝对值不超过 1 。

平衡因子定义二叉树中结点的平衡因子 bf等于结点左子树的高度减去右子树的高度

平衡二叉树中结点的平衡因子为 0 、 1 或 -1。

12

10 24

8 20 37

平衡二叉树



四种平衡处理在平衡二叉排序树上插入结点时，其祖先结点的平衡

因子可能发生变化，离插入结点最近且平衡因子变为 2或 -2 的祖先结点作为根的子树称为最小不平衡子树。

一般情况下，假设由于在二叉排序树上插入结点而失去平衡的最小子树根结点的指针为 a ，则失去平衡后进行调整的规律可归纳为以下四种情况： RR型左旋平衡处理 LL型右旋平衡处理 LR型先左后右旋转平衡处理 RL型先右后左旋转平衡处理



哈希表查找一个散列结构是一块地址连续的存储空间，它与一个称为

散列（哈希）函数的函数相关联，该函数是数据记录的关键字到地址空间的映射。

这种存储空间的使用方式，使得

(1) 存储记录时，通过散列函数计算出记录的存储位置并按此存储位置存储记录

记录位置＝ Hash(记录的关键字 )

Hash ：关键字→ 哈希地址

(2) 访问记录时，同样利用散列函数计算存储位置，然后根据所计算出的存储位置访问记录



8.6.1 哈希表查找的基本概念散列技术中的主要问题

表面上看，设置了散列函数后，只需作简单的函数计算就可以实现元素的定位及查找操作，但事实上没有这么简单，概括起来，主要有以下两个问题：

(1)冲突及解决

一般情况下，设计出的散列函数很难是单射的，即不同的关键字会对应到同一个存储位置，这样就造成了冲突 ( 碰撞 ) 。此时，发生冲突的关键字互为同义词。

(2)散列函数的设计

设计一个简单、均匀、存储空间利用率高、冲突少的散列函数是关键。



构造哈希函数的常用方法 1．直接定址法

2．数字分析法

3．平方取中法

4．折叠法

5．除留余数法

该方法的散列函数形式为： Hash(key) = key % p

其中， p 为不大于散列表表长 m 的整数

6. 随机法



常用的冲突解决方法 1．开放地址法

2．链地址法



冲突解决方法1．开放地址法

开放定址法利用下列公式求“下一个”空地址

Hi = (H(key)+di) MOD m i=1,2,…K(K<=m-1)

其中 H(key) 为散列函数， m 为散列表长度， di 为增量序列

根据 di 的取法，解决冲突时常使用下面一些方法：

(1)线性探测再散列

(2)二次探测再散列

(3)伪随机探测再散列



假设哈希表的地址为 0~m-1 ，则哈希表的长度为 m 。若一个关键字在地址 d 处发生冲突，则依次探查 d+1 ， d+2 ，…，当达到表尾 m-1 时，又从 0 ， 1 ， 2 ，… . 开始探查，直到找到一个空闲位置来存储冲突的关键字，将这一种方法称为线性探测再散列。

Hi = (H(key)+di) MOD m i = 1,2,…,k (k≤m-1)

其中， H(key) 为关键字 key 的哈希函数值， di=1,2,3,

…,m-1

冲突解决方法 - 线性探查再散列



冲突解决方法 - 线性探查再散列例如 :　给定关键字序列如下，散列函数为 H(k)=k%13 19， 14， 23， 1 ， 68， 20， 84， 27， 55， 11， 10， 79试用线性探测再散列法建立散列表。1 2 3 4 5 6 7 8 9 10 11 120

19

19 % 13 = 6

14 % 13 = 1

14

23 % 13 = 10

23

1 % 13 = 1

1



冲突解决方法 - 线性探查再散列例如 :　给定关键字序列如下，散列函数为 H(k)=k%13 19， 14， 23， 1 ， 68， 20， 84， 27， 55， 11， 10， 79试用线性探测再散列法建立散列表。1 2 3 4 5 6 7 8 9 10 11 120

1914 231

68 % 13 = 3

68

20 % 13 = 7

20

84 % 13 = 6

84



冲突解决方法 - 线性探查再散列例如 :　给定关键字序列如下，散列函数为 H(k)=k%13 19， 14， 23， 1 ， 68， 20， 84， 27， 55， 11， 10， 79试用线性探测再散列法建立散列表。

1 2 3 4 5 6 7 8 9 10 11 120

1914 231 68 20 84

27 % 13 = 1

27

55 % 13 = 3

55

11 % 13 = 11

11



冲突解决方法 - 线性探查再散列例如 :　给定关键字序列如下，散列函数为 H(k)=k%13 19， 14， 23， 1 ， 68， 20， 84， 27， 55， 11， 10， 79试用线性探测再散列法建立散列表。

1 2 3 4 5 6 7 8 9 10 11 120

1914 231 68 20 8427 55 11

10 % 13 = 10

79 % 13 = 1

1079

ASL 成功 = (1+1+1+2+1+1+3+4+3+1+3+9)/12 = 30/12ASL 失败 = (1+13+12+11+10+9+8+7+6+5+4+3+2)/13

= 91/13



把相互发生冲突的同义词用一个单链表链接起来。

2. 链地址法

12

11

10

9

8

7

6

5

4

3

2

1

0

14 1 27 79 ^

19 84 ^

23 10 ^

68 55 ^

20 ^

11 ^

ASL 成功 =(1*6+2*4+3+4)/12

　　　　　　　　　　　　=21/12

ASL 失败 =(4+2*3+1+1)/13

　　　　　　　　　　　　=12/13

冲突解决方法 - 链地址法



哈希查找的性能分析哈希表的平均查找长度是装填因子（散列表中存入的元

素个数 n 与哈希表的大小 m 的比值）的函数：　= n/m

采用哈希法构造查找表时，可以选择一个适当的装填因子，使得平均查找长度限定在某个范围内。

线性探测再散列成功查找的平均查找长度：

链地址法成功查找的平均查找长度：

)1

11(

2

1

nlS

21

ncS



练习题举例1. 对于查找算法来说 , 通常以（平均查找长度）作为衡量查找

算法好坏的依据 .

2. 在关键字序列为（ 5 , 10, 19 , 21 , 28 , 34 , 41， 53 , 58 ,65 ）的顺序表中，用折半法查找关键字为 5 的记录（ mid＝（ low＋high） DIV 2 ），需要经过（ 3 ）次比较。

3. 对二叉排序树进行（中序）遍历，可将树中结点按关键字值进行升序排列。

4. 在平衡二叉树中，任意结点的左、右子树的高度之差为（ -

1、 0、 1 ）。



练习题举例1. 在有 15 个元素构成的有序表 A[1..15] 中进行折半查找（向上取

整），则找到的元素为 A[3] 时，被比较的元素的下标依次为（ 8， 4， 2， 3 ），等概率查找的情况下，查找成功的平均查找长度是（ 49/15 ）。a8

a4 a12

a2 a6a10

a14

a1 a3 a5a7 a9

a11 a13a15

ASL 成功 = (1+2*2+4*3+8*4)/15 = 49/15



练习题举例1. 依次输入表

(30， 15， 28， 20， 24， 10， 12， 68， 35， 50， 46，55) 中的元素，生成一棵二叉树排序树。

（ 1 ）试画出生成之后的二叉排序树；（ 2 ）在等概率下，计算对该二叉排序树成功的平均查找长度。

30

15

28

20

24

10

12

68

35

50

46 55

ASL 成功 =(1+2*2+3*3+4*3+5*3)/12

=41/12



练习题举例2. 设哈希函数 H(key)＝ key mod 9 ，哈希地址空间为 0 ~11 ，对

关键字序列（ 31， 12， 48， 54， 21， 33， 22， 67 ）。（ 1 ）用线性探查法解决冲突构造哈希表，并计算在等概率情况

下查找成功和不成功的平均查找长度；（ 2 ）用拉链法解决冲突构造哈希表，并计算在等概率情况下查

找成功的平均查找长度。

12 31 48 21 33 22

1 2 3 4 5 6 7 8

67

9 10 11

54

0（ 1 ）解：

ASL 成功 = (1+1+3+1+4+2+5+6) / 8= 23/8



练习题举例1. 编写二分查找的递归算法。2. 设计一个算法判断给定的二叉树是否为二叉排序树。



练习题举例1. 编写二分查找的递归算法。

int Bsearch(Elemtype a[],int low,int high, ElemType e) { if (low <= high) { mid = (low+high)/2; if (a[mid] == e) return mid; if (a[mid] > e) return Bsearch(a,low,mid-1,e); else return Bsearch(a,mid+1,high,e); } return 0;}



练习题举例2. 设计一个算法判断给定的二叉树是否为二叉排序树。

算法思路：对二叉树进行中序编历，每次比较当前结点值与前一个结点值的大小关系是否满足。二叉树采用二叉链表存储结构。算法中 predata 的初值为小于于树中任何结点元素的值。

bool inorder(BSTNode *root) { if (!root) return true; else { return inorder(root->Lchild); if (root->data < predata) return false; predata = root->data; return inorder(root->Rchild); } }



第九章排序本章内容：

9.1 排序的基本概念 9.2 插入排序 9.3 选择排序 9.4 交换排序 9.5 归并排序 9.6 基数排序本章学习要点：

1. 掌握排序稳定性的概念。2. 掌握直接插入排序和希尔排序方法。3. 掌握直接选择排序和堆排序方法。4. 掌握冒泡排序和快速排序方法。5. 掌握归并排序和链式基数排序方法。6. 分析各种排序方法的时间复杂度。



练习题举例 1. 排序方法的稳定性是指（）。 2. 对于直接插入排序 , 当待排序列中记录按关键字（有序）排列时 , 所需进行关键字间比较的次数达最小值 n-1, 记录不需移动。

3. 将两个长度分别为 m和 n 的有序表归并成一个有序表（ m

n ），需要的元素比较次数最少为（ m ）。 4. 快速排序在（元素有序）的情况下排序性能最差。 5. 每趟排序都是从未排序的子序列中依次取出元素与已经排好序

的序列中元素进行比较，然后将其放在已经排好序的序列的合适位置。这种排序法称为（直接插入）排序法。

6. 希尔排序、快速排序、堆排序和二路归并排序法中，要求辅助空间最多的是（二路归并排序）。



练习题举例7. 在希尔排序、冒泡排序、选择排序、直接插入排序、快速排序、

基数排序等方法中，关键字比较的次数与记录的初始排列次序无关的排序方法是（选择排序、基数排序）。

8. 设有序列（ 503， 87， 512， 61， 908， 170， 897 ）（ 1 ）写出增量为 3 时进行一趟希尔排序的结果；（ 2 ）建成一个小顶堆；（ 3 ）给出执行一趟快速排序的结果；（ 4 ）写出进行 3 路归并排序的过程。



练习题举例8. 设有序列（ 503， 87， 512， 61， 908， 170， 897 ）（ 1 ）写出增量为 3 时进行一趟希尔排序的结果； 503， 87， 512， 61， 908， 170， 897

61 , 87, 170 , 503, 908, 512, 897

（ 2 ）建成一个小顶堆；

503

51287

90861 897170

(a)

503

17087

90861 897512

(b)

503

17061

90887 897512

(c)



练习题举例8. 设有序列（ 503， 87， 512， 61， 908， 170， 897 ）（ 2 ）建成一个小顶堆； 503

51287

90861 897170

(a)

503

17087

90861 897512

(b)

503

17061

90887 897512

(c)

61

170503

90887 897512

(d)

61

17087

908503 897512

(e)



练习题举例8. 设有序列（ 503， 87， 512， 61， 908， 170， 897 ）（ 3 ）给出执行一趟快速排序的结果； 503， 87， 512， 61， 908， 170， 897

170， 87， 61， 503， 908， 512， 897

（ 4） 3 路归并排序过程；503， 87， 512， 61， 908， 170， 897

87， 503， 51261， 170， 908 897

61， 87， 170， 503， 512， 897， 908



练习题举例9. 函数 insert_sort(int a[],int count) 是用直接插入排序法对数组

的前 count 个元素从小到大排序。 void insert_sort(int a[],int count) ｛ int i, j, t; for(i = 1; i < count; i++) {//控制 a[i],...,a[count-1] 的比较和插入 t = a[i]; j = i-1 ; while (j>=0 && t < a[j]) { // 在有序部分中寻找元素 a[i] 的插入位置 a[j+1] = a[j] ; j--; } a[j+1] = t ；｝ }



第十章文件本章内容：

10.1 概述 10.2 文件组织 10.3 动态索引 10.4 外排序

本章学习要点：1. 了解顺序文件、索引文件的概念。2. 了解 B-树的定义及其查找、插入、删除运算。3. 了解 B+树的定义。4. 了解外排序的基本方法，了解败者树的概念。5. 掌握置换选择排序生成初始归并段的方法，掌握最佳归并树的构造方法。



练习题举例1. 文件的操作分为（修改）和（检索）两大类。2. 文件是一种（线性）结构。3. 索引文件由（数据区）和（索引表）两部分构成。4. 多关键字文件通常包括多重表文件和（倒排）文件。5. B-树是一种平衡的（多路查找树），适用于组织文件的（索引）。

6. 外排序分为（形成初始归并串）和（归并排序）两个阶段。7. m阶 B-树中的 m 是指（ C ）。 A. 非终端结点至少有 m棵子树　B. 非终端结点中关键字的

个数 C. 非终端结点至多有 m棵子树　D. 树的深度



外排序前面的内排序针对数据量较小的排序情况，即待排序的数据都放在内存中，文件中的数据量可能很大，排序前不能全部读入内存中，在排序的过程中涉及数据在内外存之间的交换处理，这种内外存并用的排序方法称为外排序。



10.4 外排序外排序的基本方法是归并排序，分为以下两个步骤：第一步：形成若干个初始归并段（顺串）。即把含有 n 个记录的文件，按照内存大小分成若干个长度为 L的子文件（段），分别将各子文件（段）调入内存，采用有效的内排序方法排序后送回外存。用置换 -选择排序法形成初始归并段（长度不一定相同）。

第二步：多路归并。对这些初始归并段进行多遍归并，使得有序的归并段逐渐扩大，最后在外存上形成统一的单一归并段，完成排序。采用最佳归并树使得排序过程中总的读写次数达到最少。



最佳归并树构造最佳归并树时可能需要补充空归并段，原则为：若参加归并的初始归并段有 n 个，作 k路平衡归并。由于归并树中只有度为 0 和 k的结点，因此设度为 0 的结点数为 n0 ，度为 k的结点数为 nk ，则有 n0=(k-

1)nk+1

因此，可以得出 nk=(n0-1)/(k-1), 若该式正好能整除，则说明个 n0 叶子结点正好可以构造 k叉归并树，否则需要增加空归并段的数目为 (k-1)-(n0-1)%(k-1) 。

例如，初始归并段分别为 {47， 9 ， 39， 18， 4 ，12， 23， 7 ， 21， 16， 26} ，构造 4 路最佳归并树。



最佳归并树

0 4 7

11

初始归并段分别为{0,0,47， 9 ， 39， 18， 4 ， 12， 23， 7 ， 2

1 ， 16， 26} ，构造 4 路最佳归并树。0

0 4 7

119 12

48

初始归并段分别为{11,47， 9 ， 39， 18， 12， 23， 21， 16，26} ，构造 4 路最佳归并树。

0

16



最佳归并树

21 23 26

88

初始归并段分别为 {48,　47， 39， 18， 23， 21，26} ，构造 4 路最佳归并树。

18

0 4 7

119 12

48

0

16



最佳归并树

4 路最佳归并树

21 23 26

88

0 4 7

11

222

9 12

48 4739

初始归并段分别为 {88,48,47,39} ，构造 4 路最佳归并树。

0

1816

WPL= (4+7)*3+(9+12+16+18+21+23+26)*2+(47+39)*1 = 369归并过程中总的记录读写次数为 738次



练习题举例1. 关键字序列为（ 12,2,16,30,8,28,4,10,20,6,18 ），设内存工作区

可容纳 4条记录，写出用置换－选择排序法得到的全部初时归并段。

2. 设初时归并段的长度分别为（ 37,34,300,41,70,120,35,43 ），画出进行 4 路归并的最佳归并树。



第十一章算法设计方法本章内容： 11.1 迭代法 11.2 穷举法 11.3 递归法 11.4 回溯法 11.5 分枝限界法 11.6 分治法 11.7 动态规划法本章学习要点：

1. 了解各种算法设计方法的思想。2. 掌握迭代法、穷举法、递归法、回溯和分治等算法设

计方法。



练习题举例1. 算法是对问题求解过程的一类精确描述，算法中描述的操作都是

可以通过已经实现的基本操作在限定时间内执行有限次来实现的，这句话说明算法具有（ C ）特性。

A. 正确性 B. 确定性 C. 可行性 D. 健壮性2. 快速排序算法采用的设计方法是（　B ）。 A. 动态规划法（ Dynamic Programming ） B. 分治法（ Divide and Conquer ） C. 回溯法（ Backtracking ） D. 分枝定界法（ Branch and Bound ）



练习题举例1. 在数据压缩编码的应用中，构造哈夫曼树的哈夫曼 (Huffman) 算

法采用了（ A ）策略的算法。 A. 贪心 B. 分治 C. 递推 D. 回溯2. 用递归算法实现 n 个相异元素构成的有序序列的二分查找，采

用一个递归工作栈时，该栈的最小容量应为（ D ）。 A. n B. n/2 Ｃ . nlogn D. log(n+1)

3. 在下列算法设计方法中，（ B ）在求解问题的过程中并不从整体最优上加以考虑，而是做出在当前看来是最好的选择。

A. 分治法 B. 贪心法 C. 动态规划方法 D. 回溯法



练习题举例1. 以关键字比较为基础的排序算法在最坏情况下的计算时间下界为

O(nlogn) 。下面的排序算法中，最坏情况下计算时间可以达到O(nlogn) 的是（ A ）；该算法采用的设计方法是（ E ）。

A. 归并排序 B. 插入排序 C. 选择排序 D. 冒泡排序E. 分治法F. 贪心法 G. 动态规划方法 H. 回溯法2. 设求解某问题的递归算法如下：

F(int n){if ( n = = 1) {

Move ( 1 ) ;} else {

F ( n – 1 ) ;Move ( n ) ;F (n – 1 ) ;

}}



练习题举例2. 设求解某问题的递归算法如下：

求解该算法的计算时间时，仅考虑算法 Move所做的计算为主要计算，且Move 为常数级算法。则算法 F 的计算时间 T(n) 的递推关系式为（　C ）；设算法 Move 的计算时间为 k ，当 n=4 时，算法 F 的计算时间为（　F ）。

A. T(n) = T(n-1) + 1 B. T(n) = 2T(n-1) C. T(n) = 2T(n-1) + 1 D. T(n) = 2T(n+1) + 1E. 14k F. 15k G. 16k H. 17k

F(int n){if ( n = = 1) {

Move ( 1 ) ;} else {

F ( n – 1 ) ;Move ( n ) ;F (n – 1 ) ;

}}



练习题1. 编写递归算法求一棵二叉树中的叶子结点总数。2. 用分治法求数组 A[1..m] 中的最大元素。

二叉树中的

叶子数 =

0 二叉树是空树

左子树叶子数 +右子树叶子数其它二叉树

1 仅有根结点的二叉树



练习题1. 编写递归算法求一棵二叉树中的叶子结点总数。 int leaf_number(Bitree root)

{

if (!root) return 0; // 空树的叶子数为 0

else

if (!root->lchild && !root->rchild)

return 1; // 仅有根结点的二叉树有 1 个叶子 else //左子树叶子数加右子树叶子数是整棵树中叶子数 return leaf_number(root->Lchild) +

leaf_number(root->Rchild) ;

}



练习题2. 用分治法求数组 A[1..m] 中的最大元素。 ElemType Max_elem(ElemType A[], int i, int j) { if (i > j) return ERROR; // else if (i == j) return A[i]; else { m = (i+j)/2; d1 = Max_elem(A,i,m) ; d2 = Max_elem(A,m+1,j) ; if (d1 > d2) return d1; else return d2; } }



结束

数据结构与算法 Data Structures and Algorithm

Documents

Transcript of 数据结构与算法 Data Structures and Algorithm