数据结构严蔚敏课件.ppt

第第3章章 栈和队列栈和队列 栈和队列是两种应用非常广泛的数据结构栈和队列是两种应用非常广泛的数据结构，它们都，它们都来自线性表数据结构，来自线性表数据结构，操作受限操作受限””的线性表的线性表栈在计算机的实现有多种方式：栈在计算机的实现有多种方式：◆ ◆ 硬堆栈硬堆栈：利用：利用CPU中的某些寄存器组或类似的硬中的某些寄存器组或类似的硬件或使用内存的特殊区域来实现这类堆栈容量有限，件或使用内存的特殊区域来实现这类堆栈容量有限，但速度很快；但速度很快；◆ ◆ 软堆栈软堆栈：这类堆栈主要在内存中实现堆栈容量：这类堆栈主要在内存中实现堆栈容量可以达到很大在实现方式上，又有可以达到很大在实现方式上，又有动态方式动态方式和和静态静态方式方式两种 本章将讨论栈和队列的基本概念本章将讨论栈和队列的基本概念、、存储结构存储结构、、基本基本操作以及这些操作的具体实现操作以及这些操作的具体实现数据结构严蔚敏3.1 栈栈3.1.1 栈的基本概念栈的基本概念1 栈的概念栈的概念 栈栈(Stack)：：是限制在表的一端进行插入和删除操是限制在表的一端进行插入和删除操作的线性表。

又称为后进先出作的线性表又称为后进先出LIFO (Last In First Out)或先进后出或先进后出FILO (First In Last Out)线性线性表 栈顶栈顶(Top)：：允许进行插入、删除操作的一端，又允许进行插入、删除操作的一端，又称为表尾用栈顶指针称为表尾用栈顶指针(top)来指示栈顶元素来指示栈顶元素 栈底栈底(Bottom)：：是固定端，又称为表头是固定端，又称为表头 空栈空栈：：当表中没有元素时称为空栈当表中没有元素时称为空栈数据结构严蔚敏 设栈设栈S=(a1，，a2，，…an)，则，则a1称称为栈底元素，为栈底元素，an为栈顶元素，如图为栈顶元素，如图3-1所示 栈中元素按栈中元素按a1，，a2，，…an的次序的次序进栈，退栈的第一个元素应为栈顶元进栈，退栈的第一个元素应为栈顶元素即栈的修改是按后进先出的原则素即栈的修改是按后进先出的原则进行的图图3-1 顺序顺序栈示意图栈示意图a1a2aian⋯⋯⋯⋯bottomtop进栈（进栈（push））出栈出栈(pop)2 栈的抽象数据类型定义栈的抽象数据类型定义ADT Stack{数据对象：数据对象：D ={ ai|ai∈∈ElemSet, i=1,2,…,n，，n≥0 }数据关系：数据关系：R ={|ai-1，，ai∈∈D, i=2,3,…,n }基本操作：初始化、进栈、出栈、取栈顶元素等基本操作：初始化、进栈、出栈、取栈顶元素等} ADT Stack数据结构严蔚敏 栈的顺序存储结构简称为顺序栈，和线性表相类似，栈的顺序存储结构简称为顺序栈，和线性表相类似，用用一维数组一维数组来来存储栈存储栈。

根据数组是否可以根据需要增大，根据数组是否可以根据需要增大，又可分为又可分为静态顺序栈静态顺序栈和和动态顺序栈动态顺序栈◆ ◆ 静态顺序栈静态顺序栈实现简单，但不能根据需要增大栈的实现简单，但不能根据需要增大栈的存储空间；存储空间；◆ ◆ 动态顺序栈动态顺序栈可以根据需要增大栈的存储空间，但可以根据需要增大栈的存储空间，但实现稍为复杂实现稍为复杂3.1.2 栈的顺序存储表示栈的顺序存储表示数据结构严蔚敏 采用采用动态动态一维数组一维数组来来存储栈存储栈所谓动态，指的是栈所谓动态，指的是栈的大小可以根据需要增加的大小可以根据需要增加◆ ◆ 用用bottom表示栈底指针，栈底固定不变的；栈顶表示栈底指针，栈底固定不变的；栈顶则随着进栈和退栈操作而变化用则随着进栈和退栈操作而变化用top( (称为栈顶指针称为栈顶指针) )指示当前栈顶位置指示当前栈顶位置◆ ◆ 用用top=bottom作为栈空的标记作为栈空的标记，每次，每次top指向栈顶指向栈顶数组中的下一个存储位置数组中的下一个存储位置◆◆ 结点进栈结点进栈：：首先将数据元素保存到栈顶首先将数据元素保存到栈顶(top所指所指的当前位置的当前位置)，然后执行，然后执行top加加1，使，使top指向栈顶的下指向栈顶的下一个存储位置一个存储位置;3.1.2.1 栈的动态顺序存储表示栈的动态顺序存储表示数据结构严蔚敏◆ ◆ 结点出栈结点出栈：：首先执行首先执行top减减1，使，使top指向栈顶元指向栈顶元素的存储位置，然后将栈顶元素取出素的存储位置，然后将栈顶元素取出。

图图3-2是一个动态栈的变化示意图是一个动态栈的变化示意图图图3-2 (动态动态)堆栈变化示意图堆栈变化示意图空栈空栈bottomtop元素元素a进栈进栈bottomtopa元素元素b，，c进栈进栈bottomtopabc元素元素c退栈退栈bottomtopabbottomtopabdef元素元素d，，e，，f进栈进栈数据结构严蔚敏基本操作的实现基本操作的实现1 栈的类型定义栈的类型定义#define STACK_SIZE 100 /* 栈初始向量大小栈初始向量大小 */#define STACKINCREMENT 10 /* 存储空间分配增量存储空间分配增量 */#typedef int ElemType ;typedef struct sqstack{ ElemType *bottom; /* 栈不存在时值为栈不存在时值为NULL */ElemType *top; /* 栈顶指针栈顶指针 */int stacksize ; /* 当前已分配空间，以元素为单位当前已分配空间，以元素为单位 */}SqStack ;数据结构严蔚敏2 栈的初始化栈的初始化Status Init_Stack(void){ SqStack S ;S.bottom=(ElemType *)malloc(STACK_SIZE *sizeof(ElemType));if (! S.bottom) return ERROR;S.top=S.bottom ; /* 栈空时栈顶和栈底指针相同栈空时栈顶和栈底指针相同 */S. stacksize=STACK_SIZE; return OK ;}数据结构严蔚敏3 压栈压栈(元素进栈元素进栈)Status push(SqStack S , ElemType e) { if (S.top-S.bottom>=S. stacksize-1) { S.bottom=(ElemType *)realloc((S. STACKINCREMENT+STACK_SIZE) *sizeof(ElemType)); /* 栈满，追加存储空间栈满，追加存储空间 */if (! S.bottom) return ERROR; S.top=S.bottom+S. stacksize ;S. stacksize+=STACKINCREMENT ;} *S.top=e; S.top++ ; /* /* 栈顶指针加栈顶指针加1，，e成为新的栈顶成为新的栈顶 * */ /return OK;}数据结构严蔚敏4 弹栈弹栈( (元素元素出栈出栈) )Status pop( SqStack S, ElemType *e ) /*弹出栈顶元素弹出栈顶元素*/{ if ( S.top== S.bottom ) return ERROR ; /* 栈空，返回失败标志栈空，返回失败标志 */S.top-- ; e=*S. top ; return OK ; } 数据结构严蔚敏 采用采用静态静态一维数组一维数组来来存储栈存储栈。

栈底固定不变的，而栈顶则随着进栈和退栈操作变栈底固定不变的，而栈顶则随着进栈和退栈操作变化的，化的，◆ ◆ 栈底固定不变的；栈顶则随着进栈和退栈操作而栈底固定不变的；栈顶则随着进栈和退栈操作而变化，用一个整型变量变化，用一个整型变量top( (称为栈顶指针称为栈顶指针) )来指示当前来指示当前栈顶位置栈顶位置◆ ◆ 用用top=0表示栈空的初始状态表示栈空的初始状态，每次，每次top指向栈顶指向栈顶在数组中的存储位置在数组中的存储位置 ◆◆ 结点进栈结点进栈：：首先执行首先执行top加加1，使，使top指向新的栈指向新的栈顶位置顶位置，，然后将数据元素保存到栈顶然后将数据元素保存到栈顶(top所指的当前所指的当前位置位置)3.1.2.2 栈的静态顺序存储表示栈的静态顺序存储表示数据结构严蔚敏◆ ◆ 结点出栈结点出栈：：首先首先把把top指向的栈顶元素取出指向的栈顶元素取出，，然然后执行后执行top减减1，使，使top指向新的栈顶位置指向新的栈顶位置 若栈的数组有若栈的数组有Maxsize个元素个元素，则，则top=Maxsize-1时时栈满栈满图3-3是一个大小为是一个大小为5的栈的变化示意图的栈的变化示意图。

图图3-3 静态静态堆栈变化示意图堆栈变化示意图空栈空栈bottomtopTop=11个元素进栈个元素进栈bottomtopaTop=33个元素进栈个元素进栈bottomtopabcTop=4栈满栈满bottomtopabedTop=2元素元素c进栈进栈bottomtopab数据结构严蔚敏基本操作的实现基本操作的实现1 栈的类型定义栈的类型定义# define MAX_STACK_SIZE 100 /* 栈向量大小栈向量大小 */# typedef int ElemType ;typedef struct sqstack{ ElemType stack_array[MAX_STACK_SIZE] ;int top;}SqStack ;数据结构严蔚敏2 栈的初始化栈的初始化SqStack Init_Stack(void){ SqStack S ;S.bottom=S.top=0 ; return(S) ;}数据结构严蔚敏3 压栈压栈(元素进栈元素进栈)Status push(SqStack S , ElemType e) /* /* 使数据元素使数据元素e进栈成为新的栈顶进栈成为新的栈顶 * */ /{ if (S.top==MAX_STACK_SIZE-1) return ERROR; /* 栈满，返回错误标志栈满，返回错误标志 */S.top++ ; /* /* 栈顶指针加栈顶指针加1 */*/S.stack_array[S.top]=e ; /* /* e成为新的栈顶成为新的栈顶 * */ /return OK; /* 压栈成功压栈成功 */}数据结构严蔚敏4 弹栈弹栈( (元素元素出栈出栈) )Status pop( SqStack S, ElemType *e ) /*弹出栈顶元素弹出栈顶元素*/{ if ( S.top==0 )return ERROR ; /* 栈空，返回错误标志栈空，返回错误标志 */*e=S.stack_array[S.top] ; S.top-- ; return OK ; }数据结构严蔚敏 当栈满时做进栈运算必定产生空间溢出，简称当栈满时做进栈运算必定产生空间溢出，简称““上上溢溢””。

上溢是一种出错状态，应设法避免上溢是一种出错状态，应设法避免 当栈空时做退栈运算也将产生溢出，简称当栈空时做退栈运算也将产生溢出，简称““下溢下溢””下溢则可能是正常现象，因为栈在使用时，其初态或终下溢则可能是正常现象，因为栈在使用时，其初态或终态都是空栈，所以下溢常用来作为控制转移的条件态都是空栈，所以下溢常用来作为控制转移的条件数据结构严蔚敏1 栈的链式表示栈的链式表示 栈的栈的链式存储结构链式存储结构称为链栈，是运算受限的单链表称为链栈，是运算受限的单链表其插入和删除操作只能在表头位置上进行因此，链栈其插入和删除操作只能在表头位置上进行因此，链栈没有必要像单链表那样附加头结点，栈顶指针没有必要像单链表那样附加头结点，栈顶指针top就是就是链表的头指针图链表的头指针图3-4是栈的链式存储表示形式是栈的链式存储表示形式3.1.3 栈的链式存储表示栈的链式存储表示空栈空栈top ⋀非空栈非空栈top a4 a3 a1 ⋀ a2图图图图3-4 3-4 链链链链栈存储形式栈存储形式链栈的链栈的结点类型说明如下：结点类型说明如下：typedef struct Stack_Node{ ElemType data ;struct Stack_Node *next ;} Stack_Node ;数据结构严蔚敏2 链栈基本操作的实现链栈基本操作的实现(1) 栈的初始化栈的初始化Stack_Node *Init_Link_Stack(void){ Stack_Node *top ;top=(Stack_Node *)malloc(sizeof(Stack_Node )) ;top->next=NULL ; return(top) ;}数据结构严蔚敏(2) 压栈压栈(元素进栈元素进栈)Status push(Stack_Node *top , ElemType e){ Stack_Node *p ;p=(Stack_Node *)malloc(sizeof(Stack_Node)) ; if (!p) return ERROR; /* 申请新结点失败，返回错误标志申请新结点失败，返回错误标志 */p->data=e ; p->next=top->next ; top->next=p ; /* 钩链钩链 */return OK;}数据结构严蔚敏(3) 弹栈弹栈( (元素元素出栈出栈) )Status pop(Stack_Node *top , ElemType *e)/* /* 将栈顶元素将栈顶元素出出栈栈 * */ /{ Stack_Node *p ;ElemType e ;if (top->next==NULL )return ERROR ; /* 栈空，返回错误标志栈空，返回错误标志 */p=top->next ; e=p->data ; /* /* 取栈顶元素取栈顶元素 * */ /top->next=p->next ; /* /* 修改栈顶指针修改栈顶指针 * */ /free(p) ; return OK ;}数据结构严蔚敏3.2 栈的应用栈的应用 由于栈具有的由于栈具有的““后进先出后进先出””的固有特性，因此，栈的固有特性，因此，栈成为程序设计中常用的工具和数据结构。

以下是几个栈成为程序设计中常用的工具和数据结构以下是几个栈应用的例子应用的例子数据结构严蔚敏3.2.1 数制转换数制转换 十进制整数十进制整数N向其它进制数向其它进制数d(二二、、八八、、十六十六) )的转换的转换是计算机实现计算的基本问题是计算机实现计算的基本问题转换法则转换法则：该转换法则对应于一个简单算法原理该转换法则对应于一个简单算法原理: :n=(n div d)*d+n mod d 其中：其中：div为整除运算为整除运算, ,mod为求余运算为求余运算例如例如 (1348)10= (2504)8，，其运算过程如下：其运算过程如下： n n div 8 n mod 8 1348 168 4 168 21 0 21 2 5 2 0 2数据结构严蔚敏 采用静态顺序栈方式实现采用静态顺序栈方式实现 void conversion(int n , int d) /*将将十进制整数十进制整数N转换为转换为d(2或或8)进制数进制数*/{ SqStack S ; int k, *e ;S=Init_Stack();while (n>0) { k=n%d ; push(S , k) ; n=n/d ; } /* 求出所有的余求出所有的余数，数，进栈进栈 */while (S.top!=0) /* 栈不空时出栈，输出栈不空时出栈，输出 */{ pop(S, e) ; printf(“%1d” , *e) ; }} 数据结构严蔚敏3.2.2 括号匹配问题括号匹配问题 在文字处理软件或编译程序设计时，常常需要检查在文字处理软件或编译程序设计时，常常需要检查一个字符串或一个表达式中的括号是否相匹配一个字符串或一个表达式中的括号是否相匹配?匹配思想匹配思想：：从左至右扫描一个字符串从左至右扫描一个字符串(或表达式或表达式)，则，则每个右括号将与最近遇到的那个左括号相匹配每个右括号将与最近遇到的那个左括号相匹配。

则可以则可以在从左至右扫描过程中把所遇到的左括号存放到堆栈中在从左至右扫描过程中把所遇到的左括号存放到堆栈中每当遇到一个右括号时，就将它与栈顶的左括号每当遇到一个右括号时，就将它与栈顶的左括号(如果如果存在存在)相匹配，同时从栈顶删除该左括号相匹配，同时从栈顶删除该左括号算法思想算法思想：：设置一个栈，当读到左括号时，左括号进设置一个栈，当读到左括号时，左括号进栈当读到右括号时，则从栈中弹出一个元素，与读到栈当读到右括号时，则从栈中弹出一个元素，与读到的左括号进行匹配，若匹配成功，继续读入；否则匹配的左括号进行匹配，若匹配成功，继续读入；否则匹配失败，返回失败，返回FLASE数据结构严蔚敏算法描述算法描述#define TRUE 0#define FLASE -1SqStack S ; S=Init_Stack() ; /*堆栈初始化堆栈初始化*/int Match_Brackets( ){ char ch , x ;scanf(“%c” , &ch) ; while (asc(ch)!=13)数据结构严蔚敏{ if ((ch==‘(’)||(ch==‘[’)) push(S , ch) ; else if (ch==‘]’) { x=pop(S) ; if (x!=‘[’) { printf(“’[’括号不匹配括号不匹配”) ; return FLASE ; } }else if (ch==‘)’) { x=pop(S) ; if (x!=‘(’) { printf(“’(’括号不匹配括号不匹配”) ; return FLASE ;} } }数据结构严蔚敏if (S.top!=0) { printf(“括号数量不匹配！括号数量不匹配！”) ; return FLASE ;}else return TRUE ; }数据结构严蔚敏3.2.2 栈与递归调用的实现栈与递归调用的实现 栈的另一个重要应用是在程序设计语言中实现递归栈的另一个重要应用是在程序设计语言中实现递归调用。

调用 递归调用递归调用：：一个函数一个函数( (或过程或过程) )直接或间接地调用直接或间接地调用自己本身，简称自己本身，简称递归递归(Recursive) 递归递归是程序设计中的一个强有力的工具因为递归是程序设计中的一个强有力的工具因为递归函数结构清晰，程序易读，正确性很容易得到证明函数结构清晰，程序易读，正确性很容易得到证明 为了使递归调用不至于无终止地进行下去，实际上为了使递归调用不至于无终止地进行下去，实际上有效的递归调用函数有效的递归调用函数( (或过程或过程) )应包括两部分：应包括两部分：递推规则递推规则( (方法方法) )，，终止条件终止条件例如：求例如：求n!数据结构严蔚敏Fact(n)=1 当当n=0时时 终止条件终止条件n*fact(n-1) 当当n>0时时 递推规则递推规则 为保证递归调用正确执行，系统设立一个为保证递归调用正确执行，系统设立一个““递归工递归工作栈作栈””，作为整个递归调用过程期间使用的数据存储区作为整个递归调用过程期间使用的数据存储区 每一层递归包含的信息如：每一层递归包含的信息如：参数参数、、局部变量局部变量、、上一上一层的返回地址构成层的返回地址构成一个一个“工作记录工作记录” 。

每进入一层递归，每进入一层递归，就产生一个新的工作记录压入栈顶；每退出一层递归，就产生一个新的工作记录压入栈顶；每退出一层递归，就从栈顶弹出一个工作记录就从栈顶弹出一个工作记录数据结构严蔚敏 从被调函数返回调用函数的一般步骤：从被调函数返回调用函数的一般步骤：(1) 若栈为空，则执行正常返回若栈为空，则执行正常返回⑵ ⑵ 从栈顶弹出一个工作记录从栈顶弹出一个工作记录⑶ ⑶ 将将“工作记录工作记录”中的参数值、局部变量值赋给相中的参数值、局部变量值赋给相应的变量；读取返回地址应的变量；读取返回地址⑷ ⑷ 将函数值赋给相应的变量将函数值赋给相应的变量5) 转移到返回地址转移到返回地址数据结构严蔚敏1 队列的基本概念队列的基本概念 队列队列(Queue)：也是运算受限的线性表是一种：也是运算受限的线性表是一种先先进先出进先出(First In First Out ，简称，简称FIFO)的线性表只允的线性表只允许在表的一端进行插入，而在另一端进行删除许在表的一端进行插入，而在另一端进行删除 队首队首(front) ：允许进行删除的一端称为队首允许进行删除的一端称为队首。

队尾队尾(rear) ：允许进行插入的一端称为队尾允许进行插入的一端称为队尾　　例如：排队购物操作系统中的作业排队先进入　　例如：排队购物操作系统中的作业排队先进入队列的成员总是先离开队列队列的成员总是先离开队列　　3.3 队队 列列3.3.1 队列及其基本概念队列及其基本概念数据结构严蔚敏 队列中没有元素时称为空队列在空队列中依次队列中没有元素时称为空队列在空队列中依次加入元素加入元素a1, a2, …, an之后，之后，a1是队首元素，是队首元素，an是队尾元是队尾元素显然退出队列的次序也只能是素显然退出队列的次序也只能是a1, a2, …, an ，即队，即队列的修改是依列的修改是依先进先出先进先出的原则进行的，如图的原则进行的，如图3-5所示a1 , a2 , … , an出队出队入队入队队尾队尾队首队首图图3-5 队列示意图队列示意图2 队列的抽象数据类型定义队列的抽象数据类型定义ADT Queue{数据对象：数据对象：D ={ ai|ai∈∈ElemSet, i=1, 2, …, n, n >= 0 }数据结构严蔚敏数据关系：数据关系：R = { | ai-1, ai∈∈D, i=2,3,…,n } 约定约定a1端为队首，端为队首，an端为队尾。

端为队尾基本操作：基本操作：Create()：创建一个空队列：创建一个空队列；；EmptyQue()：若队列为空：若队列为空，，则返回则返回true ，，否则返否则返回回flase ；；⋯⋯⋯⋯InsertQue(x) ：向队尾插入元素：向队尾插入元素x；；DeleteQue(x) ：删除队首元素：删除队首元素x；；} ADT Queue数据结构严蔚敏3.3.2 队列的顺序表示和实现队列的顺序表示和实现 利用利用一组连续的存储单元一组连续的存储单元(一维数组一维数组) 依次存放从队依次存放从队首到队尾的各个元素，称为首到队尾的各个元素，称为顺序队列顺序队列 对于队列，和顺序栈相类似，也有动态和静态之分对于队列，和顺序栈相类似，也有动态和静态之分本部分介绍的是本部分介绍的是静态顺序队列静态顺序队列，其类型定义如下：，其类型定义如下：#define MAX_QUEUE_SIZE 100typedef struct queue{ ElemType Queue_array[MAX_QUEUE_SIZE] ;int front ;int rear ;}SqQueue;数据结构严蔚敏3.3.2.1 队列的顺序队列的顺序存储结构存储结构 设立一个设立一个队首指针队首指针front ，一个，一个队尾指针队尾指针rear ，分，分别指向队首和队尾元素别指向队首和队尾元素。

◆◆ 初始化初始化：：front=rear=0 ◆◆ 入队入队：：将新元素插入将新元素插入rear所指的位置，然后所指的位置，然后rear加加1 ◆◆ 出队出队：：删去删去front所指的元素，然后加所指的元素，然后加1并返回被删并返回被删元素 ◆◆ 队列为空队列为空：：front=rear◆◆ 队满队满：：rear=MAX_QUEUE_SIZE-1或或front=rear数据结构严蔚敏 在非空队列里，队首指针始终指向队头元素，而队在非空队列里，队首指针始终指向队头元素，而队尾指针始终指向队尾元素的下一位置尾指针始终指向队尾元素的下一位置 顺序队列中存在顺序队列中存在““假溢出假溢出””现象因为在入队和出现象因为在入队和出队操作中，头、尾指针只增加不减小，致使被删除元素队操作中，头、尾指针只增加不减小，致使被删除元素的空间永远无法重新利用因此，尽管队列中实际元素的空间永远无法重新利用因此，尽管队列中实际元素个数可能远远小于数组大小，但可能由于尾指针巳超出个数可能远远小于数组大小，但可能由于尾指针巳超出向量空间的上界而不能做入队操作该现象称为向量空间的上界而不能做入队操作。

该现象称为假溢出假溢出如图如图3-6所示是数组大小为所示是数组大小为5的顺序队列中队首的顺序队列中队首、、队尾指队尾指针和队列中元素的变化情况针和队列中元素的变化情况数据结构严蔚敏　(a) 空队列空队列Q.frontQ.rear(b)入队入队3个元素个元素a3a2a1Q.frontQ.rear(c) 出队出队3个元素个元素Q.frontQ.rear(d) 入队入队2个元素个元素a5a4Q.frontQ.rear图图3-6 队列示意图队列示意图数据结构严蔚敏3.3.2.2 循环队列循环队列 为充分利用向量空间，克服上述为充分利用向量空间，克服上述“假溢出假溢出”现象的现象的方法是：将为队列分配的方法是：将为队列分配的向量空间看成为一个首尾相接向量空间看成为一个首尾相接的圆环的圆环，并称这种队列为，并称这种队列为循环队列循环队列(Circular Queue) 在循环队列中进行出队、入队操作时，队首、队尾在循环队列中进行出队、入队操作时，队首、队尾指针仍要加指针仍要加1，朝前移动只不过当队首、队尾指针指，朝前移动只不过当队首、队尾指针指向向量上界向向量上界(MAX_QUEUE_SIZE-1)时，其加时，其加1操作的结操作的结果是指向向量的下界果是指向向量的下界0。

这种循环意义下的加这种循环意义下的加1操作可以描述为：操作可以描述为：if (i+1==MAX_QUEUE_SIZE) i=0;else i++ ;其中：其中： i代表队首指针代表队首指针(front)或队尾指针或队尾指针(rear)数据结构严蔚敏用模运算可简化为：用模运算可简化为：i=(i+1)%MAX_QUEUE_SIZE ; 显然，为循环队列所分配的空间可以被充分利用，显然，为循环队列所分配的空间可以被充分利用，除非向量空间真的被队列元素全部占用，否则不会上溢除非向量空间真的被队列元素全部占用，否则不会上溢因此，真正实用的顺序队列是循环队列因此，真正实用的顺序队列是循环队列 例：设例：设有循环队列有循环队列QU[0，，5]，其初始状态是，其初始状态是front=rear=0，各种操作后队列的头、尾指针的状态变，各种操作后队列的头、尾指针的状态变化情况如下图化情况如下图3-7所示 123450(a) 空队列空队列frontrear123450(b) d, e, b, g入入队队frontdebgrear123450(c) d, e出队出队bgfrontrear数据结构严蔚敏 入队时尾指针向前追赶头指针，出队时头指针向前入队时尾指针向前追赶头指针，出队时头指针向前追赶尾指针，故队空和队满时头尾指针均相等。

因此，追赶尾指针，故队空和队满时头尾指针均相等因此，无法通过无法通过front=rear来判断队列来判断队列““空空””还是还是““满满””解决此问题的方法是：约定入队前，测试尾指针在循环意决此问题的方法是：约定入队前，测试尾指针在循环意义下加义下加1后是否等于头指针，若相等则认为队满后是否等于头指针，若相等则认为队满即：：◆ ◆ rear所指的单元始终为空所指的单元始终为空123450(d) i, j, k入入队队bgfrontijkrear123450(e) b, g出队出队ijkrearfront123450(f) r, p, s, t入队入队ijkfrontrprear图图3-7 循环队列操作及指针变化情况循环队列操作及指针变化情况数据结构严蔚敏◆ ◆ 循环队列为空循环队列为空：：front=rear ◆ ◆ 循环队列满循环队列满：：(rear+1)%MAX_QUEUE_SIZE =front循环队列的基本操作循环队列的基本操作1 循环队列的初始化循环队列的初始化SqQueue Init_CirQueue(void){ SqQueue Q ;Q.front=Q.rear=0; return(Q) ;}数据结构严蔚敏　2 入队操作入队操作Status Insert_CirQueue(SqQueue Q , ElemType e) /* /* 将数据元素将数据元素e插入到循环队列插入到循环队列Q的队尾的队尾 * */ /{ if ((Q.rear+1)%MAX_QUEUE_SIZE== Q.front)return ERROR; /* 队满，返回错误标志队满，返回错误标志 */Q.Queue_array[Q.rear]=e ; /* /* 元素元素e入队入队 * */ /Q.rear=(Q.rear+1)% MAX_QUEUE_SIZE ; /* 队尾指针向前移动队尾指针向前移动 */return OK; /* 入队成功入队成功 */}数据结构严蔚敏　3 出队操作出队操作Status Delete_CirQueue(SqQueue Q, ElemType *x ) /* /* 将循环队列将循环队列Q的队首元素出队的队首元素出队 * */ /{ if (Q.front+1== Q.rear)return ERROR ; /* 队空，返回错误标志队空，返回错误标志 */*x=Q.Queue_array[Q.front] ; /* /* 取队首元素取队首元素 * */ /Q.front=(Q.front+1)% MAX_QUEUE_SIZE ; /* 队首指针向前移动队首指针向前移动 */return OK ;}数据结构严蔚敏1 队列的链式存储表示队列的链式存储表示 队列的链式存储结构简称为链队列，它是限制仅队列的链式存储结构简称为链队列，它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。

在表头进行删除操作和表尾进行插入操作的单链表 需要两类不同的结点需要两类不同的结点：：数据元素数据元素结点结点，，队列的队列的队首队首指针和队尾指针指针和队尾指针的结点的结点，如图，如图3-8所示3.3.3 队列的链式表示和实现队列的链式表示和实现数据元素结点类型定义：数据元素结点类型定义：typedef struct Qnode{ ElemType data ;struct Qnode *next ;}QNode ;数据元素结点数据元素结点data指针结点指针结点front rear图图3-8 链队列结点示意图链队列结点示意图数据结构严蔚敏指针结点类型定义：指针结点类型定义：typedef struct link_queue{ QNode *front , *rear ;}Link_Queue ;2 链队运算及指针变化链队运算及指针变化 链队的操作实际上是单链表的操作，只不过是删链队的操作实际上是单链表的操作，只不过是删除在表头进行，插入在表尾进行插入、删除时分别修除在表头进行，插入在表尾进行插入、删除时分别修改不同的指针链队运算及指针变化如图改不同的指针。

链队运算及指针变化如图3-9所示数据结构严蔚敏图图3-9 队列操作及指针变化队列操作及指针变化(a) 空队列空队列front rear∧(b) x入队入队 x ∧front rear(c) y再入队再入队 y ∧front rear x(d) x出队出队 y ∧ xfront rear数据结构严蔚敏　3 链队列的基本操作链队列的基本操作⑴⑴ 链队列的初始化链队列的初始化LinkQueue *Init_LinkQueue(void){ LinkQueue *Q ; QNode *p ;p=(QNode *)malloc(sizeof(QNode)) ; /* 开辟头结点开辟头结点 */p->next=NULL ;Q=(LinkQueue *)malloc(sizeof(LinkQueue)) ; /* 开辟链队的指针结点开辟链队的指针结点 */Q.front=Q.rear=p ; return(Q) ;}数据结构严蔚敏　⑵⑵ 链队列的链队列的入队操作入队操作 在已知队列的队尾插入一个元素在已知队列的队尾插入一个元素e ，即，即修改队尾修改队尾指针指针(Q.rear)。

Status Insert_CirQueue(LinkQueue *Q , ElemType e) /* /* 将数据元素将数据元素e插入到链队列插入到链队列Q的队尾的队尾 * */ /{ p=(QNode *)malloc(sizeof(QNode)) ;if (!p) return ERROR;/* 申请新结点失败，返回错误标志申请新结点失败，返回错误标志 */p->data=e ; p->next=NULL ; /* 形成新结点形成新结点 */Q.rear->next=p ; Q.rear=p ; /* 新结点插入到队尾新结点插入到队尾 */return OK;}数据结构严蔚敏　⑶⑶ 链队列的出队操作链队列的出队操作Status Delete_LinkQueue(LinkQueue *Q, ElemType *x) { QNode *p ;if (Q.front==Q.rear) return ERROR ; /* 队空队空 */p=Q.front->next ; /* /* 取队首结点取队首结点 * */ /*x=p->data ; Q.front->next=p->next ; /* 修改队首指针修改队首指针 */if (p==Q.rear) Q.rear=Q.front ; /* 当队列只有一个结点时应防止丢失队尾指针当队列只有一个结点时应防止丢失队尾指针 */ free(p) ; return OK ; }数据结构严蔚敏　⑷⑷ 链队列的撤消链队列的撤消void Destroy_LinkQueue(LinkQueue *Q ) /* 将链队列将链队列Q的队首元素出队的队首元素出队 */{ while (Q.front!=NULL){ Q.rear=Q.front->next; /* 令尾指针指向队列的第一个结点令尾指针指向队列的第一个结点 */free(Q.front); /* 每次释放一个结点每次释放一个结点 */ /* 第一次是头结点，以后是元素结点第一次是头结点，以后是元素结点 */Q.ront=Q.rear;}}数据结构严蔚敏习习 题题 三三1 设有一个栈，元素进栈的次序为设有一个栈，元素进栈的次序为a, b, c。

问经过栈问经过栈操作后可以得到哪些输出序列？操作后可以得到哪些输出序列？2 循环队列的优点是什么循环队列的优点是什么? ?如何判断它的空和满如何判断它的空和满? ?3 设有一个静态顺序队列，向量大小为设有一个静态顺序队列，向量大小为MAX，判断，判断队列为空的条件是什么？队列满的条件是什么？队列为空的条件是什么？队列满的条件是什么？4 设有一个静态循环队列，向量大小为设有一个静态循环队列，向量大小为MAX，判断，判断队列为空的条件是什么？队列满的条件是什么？队列为空的条件是什么？队列满的条件是什么？5 利用栈的基本操作，利用栈的基本操作，写一个返回栈写一个返回栈S中结点个数的中结点个数的算法算法int StackSize(SeqStack S) ，并说明，并说明S S为何不作为指为何不作为指针参数针参数的算法的算法? ?数据结构严蔚敏6 一个双向栈一个双向栈S是在同一向量空间内实现的两个栈是在同一向量空间内实现的两个栈，，它们的栈底分别设在向量空间的两端试为此双向栈设它们的栈底分别设在向量空间的两端试为此双向栈设计初始化计初始化InitStack(S) ，入栈，入栈Push(S,i,x)，出栈，出栈Pop(S,i,x)算法算法，其中，其中i为为0或或1 ，用以表示栈号。

用以表示栈号7 设设Q[0,6]是一个静态顺序队列是一个静态顺序队列，初始状态为，初始状态为front=rear=0，请画出做完下列操作后队列的头尾指针，请画出做完下列操作后队列的头尾指针的状态变化情况，若不能入对，请指出其元素，并说明的状态变化情况，若不能入对，请指出其元素，并说明理由a, b, c, d入队入队a, b, c出队出队i , j , k , l , m入队入队d, i出队出队n, o, p, q, r入队入队数据结构严蔚敏8 假设假设Q[0,5]是一个循环队列是一个循环队列，初始状态为，初始状态为front=rear=0，请画出做完下列操作后队列的头尾指针，请画出做完下列操作后队列的头尾指针的状态变化情况，若不能入对，请指出其元素，并说明的状态变化情况，若不能入对，请指出其元素，并说明理由d, e, b, g, h入队入队d, e出队出队i , j , k , l , m入队入队b出队出队n, o, p, q, r入队入队 数据结构严蔚敏第第4章章 串串 在非数值处理、事务处理等问题常涉及到一系列在非数值处理、事务处理等问题常涉及到一系列的字符操作。

计算机的硬件结构主要是反映数值计算的的字符操作计算机的硬件结构主要是反映数值计算的要求，因此，字符串的处理比具体数值处理复杂本章要求，因此，字符串的处理比具体数值处理复杂本章讨论串的存储结构及几种基本的处理讨论串的存储结构及几种基本的处理数据结构严蔚敏4.1 串类型的定义串类型的定义4.1.1 串的基本概念串的基本概念 串串( (字符串字符串) )：是零个或多个字符组成的有限序列是零个或多个字符组成的有限序列记作：记作： S=“a1a2a3…”，其中，其中S是串名，是串名，ai(1≦≦i≦≦n)是单是单个，个，可以是字母、数字或其它字符可以是字母、数字或其它字符 串值串值：双引号括起来的字符序列是串值双引号括起来的字符序列是串值 串长串长：串中所包含的字符个数称为该串的长度串中所包含的字符个数称为该串的长度 空串空串( (空的字符串空的字符串) )：长度为零的串称为空串，它不：长度为零的串称为空串，它不包含任何字符包含任何字符 空格串空格串( (空白串空白串) )：构成串的所有字符都是空格的串：构成串的所有字符都是空格的串称为空白串。

称为空白串数据结构严蔚敏注意注意：空串和空白串的不同，例如：空串和空白串的不同，例如“ ”“ ”和和“”“”分别表分别表示长度为示长度为1 1的空白串和长度为的空白串和长度为0的空串 子串子串( (substring) )：串中任意个连续字符组成的子：串中任意个连续字符组成的子序列称为该串的子串，包含子串的串相应地称为主串序列称为该串的子串，包含子串的串相应地称为主串 子串的序号子串的序号：将子串在主串中首次出现时的该子串：将子串在主串中首次出现时的该子串的首字符对应在主串中的序号，称为子串在主串中的序的首字符对应在主串中的序号，称为子串在主串中的序号（或位置）号（或位置）例如，例如，设有串设有串A和和B分别是：分别是： A=“这是字符串这是字符串”，，B=“是是”则则B是是A的子串，的子串，A为主串B在在A中出现了两次，其中中出现了两次，其中首次出现所对应的主串位置是首次出现所对应的主串位置是3因此，称因此，称B在在A中的序中的序号为号为3 数据结构严蔚敏 特别地，空串是任意串的子串，任意串是其自身的特别地，空串是任意串的子串，任意串是其自身的子串。

子串 串相等串相等：如果两个串的串值相等：如果两个串的串值相等( (相同相同) )，称这两个，称这两个串相等换言之，只有当两个串的长度相等，且各个对串相等换言之，只有当两个串的长度相等，且各个对应位置的字符都相同时才相等应位置的字符都相同时才相等 通常在程序中使用的串可分为两种：串变量和串常通常在程序中使用的串可分为两种：串变量和串常量 串常量和整常数、实常数一样，在程序中只能被引串常量和整常数、实常数一样，在程序中只能被引用但不能不能改变其值，即只能读不能写通常串常量用但不能不能改变其值，即只能读不能写通常串常量是由直接量来表示的，例如语句错误是由直接量来表示的，例如语句错误(“(“溢出溢出””) )中中““溢溢出出””是直接量是直接量 串变量和其它类型的变量一样，其值是可以改变串变量和其它类型的变量一样，其值是可以改变数据结构严蔚敏4.1.2 串的抽象数据类型定义串的抽象数据类型定义 ADT String{数据对象：数据对象：D = { ai|ai∈∈CharacterSet, i=1,2,…,n, n ≥0 }数据关系：数据关系：R = {| ai-1, ai∈∈D, i=2,3,…,n }基本操作：基本操作：StrAssign(t , chars)初始条件：初始条件： chars是一个字符串常量。

是一个字符串常量操作结果：生成一个值为操作结果：生成一个值为chars的串的串t StrConcat(s, t)初始条件：串初始条件：串s, t 已存在数据结构严蔚敏操作结果：将串操作结果：将串t联结到串联结到串s后形成新串存放到后形成新串存放到s中StrLength(t)初始条件：字符串初始条件：字符串t已存在操作结果：返回串操作结果：返回串t中的元素个数，称为串长中的元素个数，称为串长SubString (s, pos, len, sub)初始条件：串初始条件：串s, 已存在已存在, 1≦≦pos≦≦StrLength(s)且且 0≦≦len≦≦StrLength(s) –pos+1操作结果：用操作结果：用sub返回串返回串s的第的第pos个字符起长度为个字符起长度为len的子串……} ADT String数据结构严蔚敏4.2 串的存储表示和实现串的存储表示和实现 串是一种特殊的线性表，其存储表示和线性表类似，串是一种特殊的线性表，其存储表示和线性表类似，但又不完全相同串的存储方式取决于将要对串所进行但又不完全相同串的存储方式取决于将要对串所进行的操作串在计算机中有的操作。

串在计算机中有3种表示方式：种表示方式：◆ ◆ 定长顺序存储表示定长顺序存储表示：将串定义成字符数组，利用：将串定义成字符数组，利用串名可以直接访问串值用这种表示方式，串的存串名可以直接访问串值用这种表示方式，串的存储空间在编译时确定，其大小不能改变储空间在编译时确定，其大小不能改变◆ ◆ 堆分配存储方式堆分配存储方式：仍然用一组地址连续的存储单：仍然用一组地址连续的存储单元来依次存储串中的字符序列，但串的存储空间是元来依次存储串中的字符序列，但串的存储空间是在程序运行时根据串的实际长度动态分配的在程序运行时根据串的实际长度动态分配的◆ ◆ 块链存储方式块链存储方式：是一种链式存储结构表示是一种链式存储结构表示数据结构严蔚敏4.2.1 串的定长顺序存储表示串的定长顺序存储表示 这种存储结构又称为串的顺序存储结构是用一这种存储结构又称为串的顺序存储结构是用一组连续的存储单元来存放串中的字符序列所谓定长顺组连续的存储单元来存放串中的字符序列所谓定长顺序存储结构，是直接使用定长的字符数组来定义，数组序存储结构，是直接使用定长的字符数组来定义，数组的上界预先确定的上界预先确定定长顺序存储结构定义为：定长顺序存储结构定义为：#define MAX_STRLEN 256typedef struct{ char str[MAX_STRLEN] ;int length;} StringType ; 数据结构严蔚敏1 串的联结操作串的联结操作Status StrConcat ( StringType s, StringType t)/* 将串将串t联结到串联结到串s之后，结果仍然保存在之后，结果仍然保存在s中中 */{ int i, j ;if ((s.length+t.length)>MAX_STRLEN)Return ERROR ; /* 联结后长度超出范围联结后长度超出范围 */ for (i=0 ; is.length||len<0||len>(s.length-pos+1))return ERROR ; /* 参数非法参数非法 */sub->length=len-pos+1 ; /* 求得子串长度求得子串长度 */for (j=0, k=pos ; k<=leng ; k++, j++)sub->str[j]=s.str[i] ; /* 逐个字符复制求得子串逐个字符复制求得子串 */return OK ;}数据结构严蔚敏4.2.2 串的堆分配存储表示串的堆分配存储表示 实现方法：系统提供一个空间足够大且地址连续的实现方法：系统提供一个空间足够大且地址连续的存储空间存储空间( (称为称为““堆堆””) )供串使用。

可使用供串使用可使用C语言的动态语言的动态存储分配函数存储分配函数malloc()和和free()来来管理 特点是：仍然以一组地址连续的存储空间来存储字特点是：仍然以一组地址连续的存储空间来存储字符串值，但其所需的存储空间是在程序执行过程中动态符串值，但其所需的存储空间是在程序执行过程中动态分配，故是动态的，变长的分配，故是动态的，变长的串的堆式存储结构的类型定义串的堆式存储结构的类型定义typedef struct{ char *ch; /* 若非空，按长度分配，否则为若非空，按长度分配，否则为NULL */int length; /* 串的长度串的长度 */} HString ;数据结构严蔚敏1 串的联结操作串的联结操作Status Hstring *StrConcat(HString *T, HString *s1, HString *s2)/* 用用T返回由返回由s1和和s2联结而成的串联结而成的串 */ { int k, j , t_len ; if (T.ch) free(T); /* 释放旧空间释放旧空间 */t_len=s1->length+s2->length ;if ((p=(char *)malloc(sizeof((char)*t_len))==NULL){ printf(“系统空间不够，申请空间失败系统空间不够，申请空间失败 ！！\n”) ; return ERROR ; }for (j=0 ; jlength; j++) T->ch[j]=s1->ch[j] ; /* 将串将串s复制到串复制到串T中中 */数据结构严蔚敏for (k=s1->length, j=0 ; jlength; k++, j++) T->ch[j]=s1->ch[j] ; /* 将串将串s2复制到串复制到串T中中 */free(s1->ch) ; free(s2->ch) ; return OK ; }数据结构严蔚敏4.2.3 串的链式存储表示串的链式存储表示 串的链式存储结构和线性表的串的链式存储结构类串的链式存储结构和线性表的串的链式存储结构类似，采用单链表来存储串，似，采用单链表来存储串，结点的构成是：结点的构成是：◆◆ data域：存放字符，域：存放字符，data域可存放的字符个数称为域可存放的字符个数称为结点的大小；结点的大小；◆◆ next域：存放指向下一结点的指针。

域：存放指向下一结点的指针 若每个结点仅存放一个字符，则结点的指针域就非若每个结点仅存放一个字符，则结点的指针域就非常多，造成系统空间浪费，为节省存储空间，考虑串结常多，造成系统空间浪费，为节省存储空间，考虑串结构的特殊性，使每个结点存放若干个字符，这种结构称构的特殊性，使每个结点存放若干个字符，这种结构称为块链结构如为块链结构如图图4-1是块大小为是块大小为3的串的块链式存储结的串的块链式存储结构示意图构示意图数据结构严蔚敏串的块链式存储的类型定义包括：串的块链式存储的类型定义包括：⑴ ⑴ 块结点的类型定义块结点的类型定义#define BLOCK_SIZE 4typedef struct Blstrtype{ char data[BLOCK_SIZE] ;struct Blstrtype *next;}BNODE ;a b c e p c g @ @ ⋀ ⋯⋯head图图4-1 串的块链式存储结构示意图串的块链式存储结构示意图数据结构严蔚敏(2) 块链串的类型定义块链串的类型定义typedef struct { BNODE head; /* 头指针头指针 */ int Strlen ; /* 当前长度当前长度 */ } Blstring ; 在这种存储结构下，结点的分配总是完整的结点为在这种存储结构下，结点的分配总是完整的结点为单位，因此，为使一个串能存放在整数个结点中，在串单位，因此，为使一个串能存放在整数个结点中，在串的末尾填上不属于串值的特殊字符，以表示串的终结。

的末尾填上不属于串值的特殊字符，以表示串的终结 当一个块当一个块(结点结点)内存放多个字符时，往往会使操作内存放多个字符时，往往会使操作过程变得较为复杂，如在串中插入或删除字符操作时通过程变得较为复杂，如在串中插入或删除字符操作时通常需要在块间移动字符常需要在块间移动字符数据结构严蔚敏4.3 串的模式匹配算法串的模式匹配算法模式匹配模式匹配( (模范匹配模范匹配) )：：子串在主串中的定位称为模子串在主串中的定位称为模式匹配或串匹配式匹配或串匹配( (字符串匹配字符串匹配) ) 模式匹配成功是指在模式匹配成功是指在主串主串S中能够找到模式串中能够找到模式串T，否则，称模式串，否则，称模式串T在主串在主串S中不存在中不存在 模式匹配的应用在非常广泛例如，在文本编辑程模式匹配的应用在非常广泛例如，在文本编辑程序中，我们经常要查找某一特定单词在文本中出现的位序中，我们经常要查找某一特定单词在文本中出现的位置显然，解此问题的有效算法能极大地提高文本编辑置显然，解此问题的有效算法能极大地提高文本编辑程序的响应性能程序的响应性能 模式匹配是一个较为复杂的串操作过程。

迄今为止，模式匹配是一个较为复杂的串操作过程迄今为止，人们对串的模式匹配提出了许多思想和效率各不相同的人们对串的模式匹配提出了许多思想和效率各不相同的计算机算法介绍两种主要的模式匹配算法计算机算法介绍两种主要的模式匹配算法数据结构严蔚敏4.3.1 Brute-Force模式匹配算法模式匹配算法 设设S为目标串，为目标串，T为模式串，且不妨设：为模式串，且不妨设：S=“s0s1s2…sn-1” ，， T=“t0t1t2 …tm-1” 串的匹配实际上是对合法的位置串的匹配实际上是对合法的位置0≦≦i≦≦n-m依次将目依次将目标串中的子串标串中的子串s[i…i+m-1]和模式串和模式串t[0…m-1]进行比较：进行比较： ◆◆ 若若s[i…i+m-1]=t[0…m-1]：则称从位置：则称从位置i开始的匹开始的匹配成功，亦称模式配成功，亦称模式t在目标在目标s中出现；中出现； ◆◆ 若若s[i…i+m-1]≠t[0…m-1]：从：从i开始的匹配失败开始的匹配失败位置位置i称为位移，当称为位移，当s[i…i+m-1]=t[0…m-1]时，时，i称为称为有效位移；当有效位移；当s[i…i+m-1] ≠t[0…m-1]时，时，i称为无效称为无效位移。

位移数据结构严蔚敏 这样，串匹配这样，串匹配问题可简化为找出某给定模式问题可简化为找出某给定模式T在给在给定目标串定目标串S中首次出现中首次出现的有效位移的有效位移算法实现算法实现int IndexString(StringType s , StringType t , int pos ) /* 采用顺序存储方式存储主串采用顺序存储方式存储主串s和模式和模式t，， */ /* 若模式若模式t在主串在主串s中从第中从第pos位置开始有匹配的子串，位置开始有匹配的子串，*/ /* 返回位置，否则返回返回位置，否则返回-1 */{ char *p , *q ;int k , j ;k=pos-1 ；； j=0 ; p=s.str+pos-1 ; q=t.str ; /* 初始匹配位置设置初始匹配位置设置 */ /* 顺序存放时第顺序存放时第pos位置的下标值为位置的下标值为pos-1 */数据结构严蔚敏while (k

在一些场合的应用里，如该算法简单，易于理解在一些场合的应用里，如文字处理中的文本编辑，其效率较高文字处理中的文本编辑，其效率较高 该算法的时间复杂度为该算法的时间复杂度为O(n*m) ，其中，其中n 、、m分别是分别是主串和模式串的长度通常情况下，实际运行过程中，主串和模式串的长度通常情况下，实际运行过程中，该算法的执行时间近似于该算法的执行时间近似于O(n+m) 理解该算法的关键点理解该算法的关键点 当第一次当第一次sk≠tj时：主串要退回到时：主串要退回到k-j+1的位置，而模的位置，而模式串也要退回到第一个字符（即式串也要退回到第一个字符（即j=0的位置）的位置）比较出现比较出现sk≠tj时：则应该有时：则应该有sk-1=tj-1，，…，，sk-j+1=t1，， sk-j=t0 数据结构严蔚敏4.3.2 模式匹配的一种改进算法模式匹配的一种改进算法 该改进算法是由该改进算法是由D.E.Knuth ，，J.H.Morris和和 V.R.Pratt提出来的，简称为提出来的，简称为KMP算法其改进在于：改进在于： 每当一趟匹配过程出现字符不相等时，主串指示器每当一趟匹配过程出现字符不相等时，主串指示器不用回溯，而是利用已经得到的不用回溯，而是利用已经得到的“部分匹配部分匹配”结果，将结果，将模式串的指示器向右模式串的指示器向右“滑动滑动”尽可能远的一段距离后，尽可能远的一段距离后，继续进行比较。

继续进行比较例：例：设有串设有串s=“abacabab” ，，t=“abab” 则第一次匹配则第一次匹配过程如图过程如图4-2所示图图4-2 模式匹配示例模式匹配示例 s=“a b cbb” i=3 || || ≠ 匹配失败 t=“a b b” j=3数据结构严蔚敏 在在i=3和和j=3时，匹配失败但重新开始第二次匹配时，匹配失败但重新开始第二次匹配时，不必从时，不必从i=1 ，，j=0开始因为开始因为s1=t1，，t0≠t1，必有，必有s1≠t0，又因为，又因为t0=t2，，s2=t2，所以必有，所以必有s2=t0由此可知，第二由此可知，第二次匹配可以直接从次匹配可以直接从i=3 、、j=1开始 总之，在主串总之，在主串s与模式串与模式串t的匹配过程中，一旦出现的匹配过程中，一旦出现si≠tj ，主串，主串s的指针不必回溯，而是直接与模式串的的指针不必回溯，而是直接与模式串的tk(0≦≦k

值)数据结构严蔚敏 不失一般性，设不失一般性，设主串主串s=“s1s2…sn” ，，模式串模式串t=“t1 t2 …tm” 当当si≠tj(1≦≦i≦≦n-m，，1≦≦jk满足满足4-1式t1t2…tk-1= si-(k-1) si-(k-2) … si-2 si-1 (4-1)而已经得到的而已经得到的 “部分匹配部分匹配”的结果为：的结果为：tj-(k-1) tj-k… tj-1=si-(k-1) si-(k-2) … si-2 si-1 (4-2)由式由式(4-1)和式和式(4-2)得：得：t1t2…tk-1=tj-(k-1) tj-k… tj-1 (4-3) 该推导过程可用图该推导过程可用图4-3形象描述。

实际上，式形象描述实际上，式(4-3)描描述了模式串中存在相互重叠的子串的情况述了模式串中存在相互重叠的子串的情况数据结构严蔚敏图图4-3 KMP算法示例算法示例主串si模式串tkj0 当当j=1时时Max{k|1

否则，否则，i不变，不变，j退退回到回到j=next[j]的位置，再比较的位置，再比较si和和tj，若相等，则，若相等，则i和和j分分别加别加1否则，i不变，不变，j再次退回到再次退回到j=next[j]的位置，依的位置，依此类推直到下列两种可能：此类推直到下列两种可能：(1) j退回到某个下一个退回到某个下一个[j]值时字符比较相等，则指值时字符比较相等，则指针各自加针各自加1继续进行匹配继续进行匹配2)退回到退回到j=0，将，将i和和j分别加分别加1，即从主串的下一个字符，即从主串的下一个字符si+1模式串的模式串的t1重新开始匹配重新开始匹配KMP算法如下算法如下数据结构严蔚敏#define Max_Strlen 1024int next[Max_Strlen];int KMP_index (StringType s , StringType t) /* 用用KMP算法进行模式匹配，匹配返回位置，否则返回算法进行模式匹配，匹配返回位置，否则返回-1 */ /*用静态存储方式保存字符串，用静态存储方式保存字符串， s和和t分别表示主串和模式串分别表示主串和模式串 */{ int k=0 , j=0 ; /*初始匹配位置设置初始匹配位置设置 */while (k= t.length) return(k-t.length) ; else return(-1) ; } 数据结构严蔚敏 很显然，很显然，KMP_index函数是在已知下一个函数值的函数是在已知下一个函数值的基础上执行的，以下讨论如何求基础上执行的，以下讨论如何求next函数值函数值? 由式由式(4-3)知，求模式串的知，求模式串的next[j]值与主串值与主串s无关，只无关，只与模式串与模式串t本身的构成有关，则可把求本身的构成有关，则可把求next函数值的问题函数值的问题看成是一个模式匹配问题。

由看成是一个模式匹配问题由next函数定义可知：函数定义可知：当当j=1时：时：next[1]=0设设next[j]=k，即在模式串中存在：，即在模式串中存在：t1t2…tk-1=tj-(k-1)tj-k… tj-1 ，其中下标，其中下标k满足满足1k满足上式，即：满足上式，即：next[j+1]=next[j]+1=k+1数据结构严蔚敏(2) 若有若有tk≠tj ：则表明在模式串中有：：则表明在模式串中有：t1 t2…tk-1 tk≠tj-(k-1) tj-k… tj-1 tj ，当，当tk≠tj时应时应将模式向右滑动将模式向右滑动至以模式至以模式中的第中的第next[k]个字符和主串中的第个字符和主串中的第j个字符相比较个字符相比较若若next[k]= k’，且，且tj = tk’，则说明在主串中第，则说明在主串中第j+1字符字符之前存在一个长度为之前存在一个长度为k’(即即next[k])的最长子串，与模的最长子串，与模式串中从第一个字符起长度为式串中从第一个字符起长度为k’的子串相等。

即的子串相等即 next[j+1]=k’+1 同理，若同理，若tj≠tk，应，应将模式继续向右滑动将模式继续向右滑动至将模式中至将模式中的第的第next[k’]个字符和个字符和tj对齐，对齐，⋯⋯⋯⋯，依此类推，直到，依此类推，直到tj和和模式串中的某个字符匹配成功或者不存在任何模式串中的某个字符匹配成功或者不存在任何k’(1< k’

和子串；目标串和模式串⑵ ⑵ 若若x和和y是两个采用顺序结构存储的串，写一算法是两个采用顺序结构存储的串，写一算法比较这两个字符串是否相等比较这两个字符串是否相等⑶ ⑶ 写一算法写一算法void StrRelace(char *T, char *P, char *S)，将，将T中第一次出现的与中第一次出现的与P相等的子串替换为相等的子串替换为S，串，串S和和P的长度不一定相等，并分析时间复杂度的长度不一定相等，并分析时间复杂度数据结构严蔚敏第第5章章 数组和广义表数组和广义表 数组是一种人们非常熟悉的数据结构，几乎所有的数组是一种人们非常熟悉的数据结构，几乎所有的程序设计语言都支持这种数据结构或将这种数据结构设程序设计语言都支持这种数据结构或将这种数据结构设定为语言的固有类型定为语言的固有类型数组数组这种数据结构可以看成这种数据结构可以看成是线是线性表的推广性表的推广 科学计算中涉及到大量的矩阵问题，在程序设计语科学计算中涉及到大量的矩阵问题，在程序设计语言中一般都采用数组来存储，被描述成一个二维数组言中一般都采用数组来存储，被描述成一个二维数组。

但但当矩阵规模很大且具有特殊结构当矩阵规模很大且具有特殊结构(对角矩阵、三角矩对角矩阵、三角矩阵、对称矩阵、稀疏矩阵等阵、对称矩阵、稀疏矩阵等)，为减少程序的时间和空，为减少程序的时间和空间需求，间需求，采用自定义的描述方式采用自定义的描述方式 广义表广义表是另一种推广形式的线性表，是一种灵活的是另一种推广形式的线性表，是一种灵活的数据结构，在许多方面有广泛的应用数据结构，在许多方面有广泛的应用数据结构严蔚敏5.1 数组的定义数组的定义 数组数组是一组偶对是一组偶对( (下标值，数据元素值下标值，数据元素值) )的集合在数组中，对于一组有意义的下标，都存在一个与其对在数组中，对于一组有意义的下标，都存在一个与其对应的值一维数组对应着一个下标值，二维数组对应着应的值一维数组对应着一个下标值，二维数组对应着两个下标值，如此类推两个下标值，如此类推 数组数组是由是由n(n>1)个具有相同数据类型的数据元素个具有相同数据类型的数据元素a1，，a2，，…，，an组成的有序序列组成的有序序列，且该，且该序列必须存储在一序列必须存储在一块地址连续的存储单元中块地址连续的存储单元中。

◆◆ 数组中的数据元素数组中的数据元素具有相同数据类型具有相同数据类型◆◆ 数组是一种随机存取结构，给定一组下标，就可数组是一种随机存取结构，给定一组下标，就可以访问与其对应的数据元素以访问与其对应的数据元素◆◆ 数组中的数据元素个数是固定的数组中的数据元素个数是固定的数据结构严蔚敏5.1.1 数组的数组的抽象数据类型定义抽象数据类型定义 1 抽象数据类型定义抽象数据类型定义 ADT Array{数据对象：数据对象：ji= 0,1,…,bi-1 , 1,2, …,n ; D = { aj1j2…jn | n>0称为数组的维数称为数组的维数，，b bi是数组第是数组第i维的维的长度长度，，ji是数组元素是数组元素第第i维的下标维的下标，，aj1j2…jn∈∈ElemSet }数据关系：数据关系：R = {R1, R2, …, Rn}Ri={|0≦≦jk≦≦bk-1 ，， 1≦≦k≦≦n且且k≠i，，0≦≦ji≦≦bi-2，， aj1j2 …ji+1…jn∈∈D } 基本操作：基本操作： ………… } ADT Array数据结构严蔚敏 由上述定义知由上述定义知，，n维数组中有维数组中有b1 b2   …   bn个数据个数据元素元素，，每个数据元素都受到每个数据元素都受到n维关系的约束维关系的约束。

2 直观的直观的n维数组维数组 以二维数组为例讨论将以二维数组为例讨论将二维数组看成是一个定长二维数组看成是一个定长的线性表的线性表，其其每个元素又是一个定长的线性表每个元素又是一个定长的线性表 设二维数组设二维数组A=(aij)m n，则，则 A=(α1，，α2，，…，，αp) (p=m或或n)其中每个数据元素其中每个数据元素αj是一个列向量是一个列向量(线性表线性表) ：： αj =(a1j ，，a2j ，，…，，amj) 1≦≦j≦≦n或或是一个行向量是一个行向量：： αi =(ai1 ，，ai2 ，，…，，ain) 1≦≦i≦≦m如图如图5-1所示数据结构严蔚敏 a11 a12 … a1n a21 a22 … a2n… … … … … am1 am2 … amnA=… … … … …A=a11 a12 … a1na21 a22 … a2nam1 am2 … amna11 a21 ┆ am1a12 a22 ┆ am2a1n a2n ┆ amn┆┆┆A=图图5-1 二维数组图二维数组图例形式例形式(a) 矩阵矩阵表示形式表示形式(b) 列向量的一维数组形式列向量的一维数组形式(c) 行向量的一维数组形式行向量的一维数组形式数据结构严蔚敏5.2 数组的数组的顺序表示和实现顺序表示和实现 数组一般不做插入和删除操作，也就是说，数组数组一般不做插入和删除操作，也就是说，数组一旦建立，结构中的元素个数和元素间的关系就不再发一旦建立，结构中的元素个数和元素间的关系就不再发生变化。

因此，一般都是生变化因此，一般都是采用顺序存储的方法来表示数采用顺序存储的方法来表示数组组 问题问题：：计算机的计算机的内存结构是一维内存结构是一维( (线性线性) )地址结构地址结构，，对于多维数组，将其存放对于多维数组，将其存放( (映射映射) )到内存一维结构时，有到内存一维结构时，有个个次序约定问题次序约定问题即必须按某种次序将数组元素排成一即必须按某种次序将数组元素排成一列序列，然后将这个线性序列存放到内存中列序列，然后将这个线性序列存放到内存中 二维数组是最简单的多维数组，以此为例说明多维二维数组是最简单的多维数组，以此为例说明多维数组存放数组存放( (映射映射) )到内存一维结构时的到内存一维结构时的次序约定问题次序约定问题数据结构严蔚敏通常有两种顺序存储方式通常有两种顺序存储方式⑴⑴ 行优先顺序行优先顺序(Row Major Order) ：：将数组元素将数组元素按行排列，第按行排列，第i+1个行向量紧接在第个行向量紧接在第i个行向量后面对个行向量后面对二维数组，按行优先顺序存储的线性序列为：二维数组，按行优先顺序存储的线性序列为： a11,a12,…,a1n, a21,a22,…a2n ,……, am1,am2,…,amn PASCAL、、C是按行优先顺序存储的，如图是按行优先顺序存储的，如图5-2(b)示。

示⑵⑵ 列优先顺序列优先顺序(Column Major Order) ：：将数组将数组元素按列向量排列，第元素按列向量排列，第j+1个列向量紧接在第个列向量紧接在第j个列向量个列向量之后，对二维数组，按列优先顺序存储的线性序列为：之后，对二维数组，按列优先顺序存储的线性序列为： a11,a21,…,am1, a12,a22,…am2, ……, an1,an2,…,anm FORTRAN是按列优先顺序存储的，如图是按列优先顺序存储的，如图5-2(c)数据结构严蔚敏图图5-2 二维数组及其顺序存储图二维数组及其顺序存储图例形式例形式 a11 a12 … a1n a21 a22 … a2n… … … … … am1 am2 … amnA=(a) 二维数组的表示形式二维数组的表示形式(b) 行优先顺序存储行优先顺序存储(c) 列列优先顺序存储优先顺序存储a11 a12 … a1n第第 1行行a21 a22 … a2n第第 2行行am1 am2 … Amn 第第 m行行┆┆……a11 a21 … am1第第 1列列a12 a22 … am2第第 2列列a1m a2m … amn第第 n列列┆┆……数据结构严蔚敏 设有二维数组设有二维数组A=(aij)m n，若每个元素占用的存储单，若每个元素占用的存储单元数为元数为l( (个个) )，，LOC[a11]表示元素表示元素a11的首地址的首地址，即，即数组的数组的首地址首地址。

1 以以““行优先顺序行优先顺序””存储存储⑴ ⑴ 第第1行中的行中的每个元素对应的每个元素对应的( (首首) )地址是：地址是： LOC[a1j]=LOC[a11]+(j-1) l j=1,2, …,n(2) 第第2行中的行中的每个元素对应的每个元素对应的( (首首) )地址是：地址是： LOC[a2j]=LOC[a11]+n l +(j-1) l j=1,2, …,n… … …⑶ ⑶ 第第m行中的行中的每个元素对应的每个元素对应的( (首首) )地址是：地址是：LOC[amj]=LOC[a11]+(m-1) n l +(j-1) l j=1,2, …,n 数据结构严蔚敏 由此可知由此可知，二维数组中，二维数组中任一元素任一元素aij的的( (首首) )地址地址是：是：LOC[aij]=LOC[a11]+[(i-1) n +(j-1)] l (5-1)i=1,2, …,m j=1,2, …,n 根据根据(5-1)式式，对于三维数组，对于三维数组A=(aijk)m n p，若每个，若每个元素占用的存储单元数为元素占用的存储单元数为l( (个个) )，，LOC[a111]表示元素表示元素a111的首地址的首地址，即，即数组的数组的首地址首地址。

以以““行优先顺序行优先顺序””存储在存储在内存中内存中 三维数组中任一元素三维数组中任一元素aijk的的( (首首) )地址是：地址是： LOC(aijk)=LOC[a111]+[(i-1) n p+(j-1) p+(k-1)] l (5-2) 推而广之推而广之，对，对n维数组维数组A=(aj1j2…jn) ，若每个元素占，若每个元素占用的存储单元数为用的存储单元数为l( (个个) )，，LOC[a11 …1]表示元素表示元素a11 …1的的首地址首地址则 以以““行优先顺序行优先顺序””存储在内存中存储在内存中数据结构严蔚敏 n维数组中任一元素维数组中任一元素aj1j2…jn的的( (首首) )地址是：地址是： LOC[aj1j2…jn]=LOC[a11 …1]+[(b2 … bn) (j1-1) + (b3 … bn) (j2-1)+ … + bn (jn-1-1)+ (jn-1)]  l (5-3)数据结构严蔚敏2 以以““列优先顺序列优先顺序””存储存储⑴ ⑴ 第第1列中的列中的每个元素对应的每个元素对应的( (首首) )地址是：地址是： LOC[aj1]=LOC[a11]+(j-1) l j=1,2, …,m(2) 第第2列中的列中的每个元素对应的每个元素对应的( (首首) )地址是：地址是： LOC[aj2]=LOC[a11]+m l +(j-1) l j=1,2, …,m… … …⑶ ⑶ 第第n列中的列中的每个元素对应的每个元素对应的( (首首) )地址是：地址是：LOC[ajn]=LOC[a11]+ (n-1) m l +(j-1) l j=1,2, …,m 由此可知由此可知，二维数组中，二维数组中任一元素任一元素aij的的( (首首) )地址地址是：是：LOC[aij]=LOC[a11]+[(i-1) m+(j-1)] l (5-1)i=1,2, …,n j=1,2, …,m 数据结构严蔚敏5.3 矩阵的压缩存储矩阵的压缩存储 在科学与工程计算问题中，矩阵是一种常用的数学在科学与工程计算问题中，矩阵是一种常用的数学对象，在高级语言编程时，通常将一个矩阵描述为一个对象，在高级语言编程时，通常将一个矩阵描述为一个二维数组。

这样，可以对其元素进行随机存取，各种矩二维数组这样，可以对其元素进行随机存取，各种矩阵运算也非常简单阵运算也非常简单 对于对于高阶矩阵高阶矩阵，若其中，若其中非零元素呈某种规律分布非零元素呈某种规律分布或或者者矩阵中有大量的零元素矩阵中有大量的零元素，若仍然用常规方法存储，可，若仍然用常规方法存储，可能存储重复的非零元素或零元素，将造成存储空间的大能存储重复的非零元素或零元素，将造成存储空间的大量浪费对这类矩阵进行压缩存储：量浪费对这类矩阵进行压缩存储：◆◆ 多个相同的非零元素只分配一个存储空间多个相同的非零元素只分配一个存储空间；◆◆ 零元素不分配空间零元素不分配空间数据结构严蔚敏5.3.1 特殊矩阵特殊矩阵特殊矩阵特殊矩阵：：是指非零元素或零元素的分布有一定规律是指非零元素或零元素的分布有一定规律的矩阵1 对称矩阵对称矩阵 若一个若一个n阶方阵阶方阵A=(aij)n n中的元素满足性质：中的元素满足性质：aij=aji 1≦≦i,j≦≦n且且i≠j则称则称A为对称矩阵，如图为对称矩阵，如图5-3所示图图5-3 对称矩阵示例对称矩阵示例1 5 1 3 73 0 2 5 17 0 6 1 35 0 8 0 01 8 9 2 6A= a11 a21 a22 a31 a32 a33… … … … an1 an2 … annA=数据结构严蔚敏 对称矩阵中的对称矩阵中的元素关于主对角线对称元素关于主对角线对称，因此，让，因此，让每一对对称元素每一对对称元素aij和和aji(i≠j)分配一个存储空间，则分配一个存储空间，则n2个个元素压缩存储到元素压缩存储到n(n+1)/2个存储空间，能节约近一半的个存储空间，能节约近一半的存储空间。

存储空间 不失一般性，假设按不失一般性，假设按““行优先顺序行优先顺序””存储下三角形存储下三角形( (包括对角线包括对角线) )中的元素中的元素 设用一维数组设用一维数组( (向量向量) )sa[0…n(n+1)/2]存储存储n阶对称阶对称矩阵，如图矩阵，如图5-4所示为了便于访问，必须找出矩阵所示为了便于访问，必须找出矩阵A中中的元素的下标值的元素的下标值（（i,j））和向量和向量sa[k]的的下标值下标值k之间的对之间的对应关系sa a11 a21 a22 a31 a32 a33 … an1 an2 … annK 1 2 3 4 … n(n-1)/2 … n(n+1)/2图图5-4 对称矩阵的对称矩阵的压缩存储示例压缩存储示例数据结构严蔚敏 若若i≧≧j：：ai j在下三角形中，直接保存在在下三角形中，直接保存在sa中ai j之之前的前的i-1行共有元素个数：行共有元素个数： 1+2+…+(i-1)=i (i-1)/2而在第而在第i行上，行上，ai j之前恰有之前恰有j-1个元素，因此，元素个元素，因此，元素ai j保保存存在向量在向量sa中时的中时的下标值下标值k之间的对应关系之间的对应关系是：是： k=i (i-1)/2+j-1 i≧≧j 若若i

因为是在上三角矩阵中因为aij=aji，在向，在向量量sa中保存的是中保存的是aji 依上述分析可得：依上述分析可得： k=j (j-1)/2+i-1 i

种 上三角矩阵的下三角（不包括主对角线）中的元素上三角矩阵的下三角（不包括主对角线）中的元素均为常数均为常数c( (一般为一般为0) )下三角矩阵正好相反，它的主对下三角矩阵正好相反，它的主对角线上方均为常数，如图角线上方均为常数，如图5-5所示数据结构严蔚敏a11 a12 … a1nc a22 … a2nc c … ann… … …a11 c … ca21 a22 … can1 an2 … ann… … …图图5-5 三角矩阵三角矩阵示例示例(b) 下下三角矩阵三角矩阵示例示例(a) 上上三角矩阵三角矩阵示例示例 三角矩阵中的重复元素三角矩阵中的重复元素c可共享一个存储空间，其可共享一个存储空间，其余的元素正好有余的元素正好有n(n+1)/2个，因此，三角矩阵可压缩存个，因此，三角矩阵可压缩存储到向量储到向量sa[0…n(n+1)/2]中，其中中，其中c存放在向量的第存放在向量的第1个个分量中 上三角矩阵元素上三角矩阵元素ai j保存保存在向量在向量sa中时的中时的下标值下标值k与与（（i,j）之间的对应关系）之间的对应关系是：是：数据结构严蔚敏 下三角矩阵元素下三角矩阵元素ai j保存保存在向量在向量sa中时的中时的下标值下标值k与与（（i,j）之间的对应关系）之间的对应关系是：是：i (i-1)/2+j-1 当当i≧≧j时时n (n+1)/2 当当ij时时K=1≦≦i,j≦≦n (5-6)3 对角矩阵对角矩阵 矩阵中，除了主对角线和主对角线上或下方若干矩阵中，除了主对角线和主对角线上或下方若干条对角线上的元素之外，其余元素皆为零。

即所有的非条对角线上的元素之外，其余元素皆为零即所有的非零元素集中在以主对角线为了中心的带状区域中，如图零元素集中在以主对角线为了中心的带状区域中，如图5-6所示数据结构严蔚敏a11 a12 0 …. 0a21 a22 a23 0 …. 00 a32 a33 a34 0 …. 0 … … … …. 0 …. 0 0 an n-1 an n0 …. 0 an-1 n-2 an-1 n-1 an-1 nA=图图5-6 三对角矩阵三对角矩阵示例示例 如上图三对角矩阵，非零元素仅出现在主对角如上图三对角矩阵，非零元素仅出现在主对角(ai i,1≦≦i≦≦n)上、主对角线上的那条对角线上、主对角线上的那条对角线(ai i+1,1≦≦i≦≦n-1) 、主对角线下的那条对角线上、主对角线下的那条对角线上(ai+1 i,1≦≦i≦≦n-1)显然，当当| i-j |>1时，元素时，元素aij=0 由此可知，一个由此可知，一个k对角矩阵对角矩阵( (k为奇数为奇数) )A是满足下述是满足下述条件：条件： 当当| i-j |>(k-1)/2时，时， ai j=0 数据结构严蔚敏 对角矩阵可按对角矩阵可按行优先顺序行优先顺序或或对角线顺序对角线顺序，将其压缩，将其压缩存储到一个向量中，并且也能找到每个非零元素和向量存储到一个向量中，并且也能找到每个非零元素和向量下标的对应关系。

下标的对应关系 仍然以三对角矩阵为例讨论仍然以三对角矩阵为例讨论当当i=1，，j=1、、2，，或或i=n，， j=n-1、、n或或1

的压缩存储 上述各种特殊矩阵，其非零元素的分布都是有规律上述各种特殊矩阵，其非零元素的分布都是有规律的，因此总能找到一种方法将它们压缩存储到一个向量的，因此总能找到一种方法将它们压缩存储到一个向量中，并且一般都能找到矩阵中的元素与该向量的对应关中，并且一般都能找到矩阵中的元素与该向量的对应关系，通过这个关系，仍能对矩阵的元素进行随机存取系，通过这个关系，仍能对矩阵的元素进行随机存取 数据结构严蔚敏5.3.2 稀疏矩阵稀疏矩阵稀疏矩阵稀疏矩阵(Sparse Matrix)：：对于稀疏矩阵，目前还对于稀疏矩阵，目前还没有一个确切的定义设矩阵没有一个确切的定义设矩阵A是一个是一个n m的的矩阵中有矩阵中有s个非零元素，设个非零元素，设 δ=s/(n m)，，称称δ为为稀疏因子，如果稀疏因子，如果某一矩阵的稀疏因子某一矩阵的稀疏因子δ满足满足δ≦≦0.05时称为稀疏矩阵，如时称为稀疏矩阵，如图图5-8所示0 12 9 0 0 0 0 00 0 0 0 0 0 0 0-3 0 0 0 0 0 0 40 0 24 0 0 2 0 00 18 0 0 0 0 0 00 0 0 0 0 0 -7 0A=0 0 0 -6 0 0 0 0图图5-8 稀疏稀疏矩阵矩阵示例示例数据结构严蔚敏5.3.2.1 稀疏矩阵的压缩存储稀疏矩阵的压缩存储 对于稀疏矩阵，采用压缩存储方法时，只存储非对于稀疏矩阵，采用压缩存储方法时，只存储非0元素。

必须存储非元素必须存储非0元素的行下标值、列下标值、元素元素的行下标值、列下标值、元素值因此，一个三元组值因此，一个三元组(i, j, aij)唯一确定稀疏矩阵的一唯一确定稀疏矩阵的一个非零元素个非零元素 如图如图5-8的稀疏矩阵的稀疏矩阵A的三元组线性表为：的三元组线性表为：( (1,2,12), (1,3,9), (3,1,-3), (3,8,4), (4,3,24), (5,2,18), (6,7,-7), (7,4,-6) ) 1 三元组顺序表三元组顺序表 若以行序为主序，稀疏矩阵中所有非若以行序为主序，稀疏矩阵中所有非0元素的三元组，元素的三元组，就可以得构成该稀疏矩阵的一个三元组顺序表就可以得构成该稀疏矩阵的一个三元组顺序表数据结构严蔚敏1 三元组顺序表三元组顺序表 若以行序为主序，稀疏矩阵中所有非若以行序为主序，稀疏矩阵中所有非0元素的三元元素的三元组，就可以得构成该稀疏矩阵的一个三元组顺序表相组，就可以得构成该稀疏矩阵的一个三元组顺序表相应的数据结构定义如下：应的数据结构定义如下：⑴⑴ 三元组结点定义三元组结点定义 #define MAX_SIZE 101typedef int elemtype ;typedef struct{ int row ; /* 行下标行下标 */int col ; /* 列下标列下标 */elemtype value; /* 元素值元素值 */}Triple ;数据结构严蔚敏⑵⑵ 三元组顺序表定义三元组顺序表定义 typedef struct { int rn ; /* 行数行数 */int cn ; /* 列数列数 */int tn ; /* 非非0元素个数元素个数 */Triple data[MAX_SIZE] ; }TMatrix ; 图图5-8所示的稀疏矩阵及其相应的转置矩阵所对应的所示的稀疏矩阵及其相应的转置矩阵所对应的三元组顺序表如图三元组顺序表如图5-9所示。

所示 数据结构严蔚敏图图5-9 稀疏稀疏矩阵及其转置矩阵的三元组顺序表矩阵及其转置矩阵的三元组顺序表798rn行数行数cn列数列数tn元素个数元素个数row col value1 2 121 3 93 1 -33 8 44 3 245 2 186 7 -77 4 -64 6 2(a) 原原矩阵的三元组表矩阵的三元组表897rn行数行数cn列数列数tn元素个数元素个数row col value1 3 -32 1 122 5 183 1 93 4 244 7 -67 6 -78 2 46 4 2(b)转置矩阵的三元组表转置矩阵的三元组表数据结构严蔚敏 矩阵的运算包括矩阵的转置、矩阵求逆、矩阵的加矩阵的运算包括矩阵的转置、矩阵求逆、矩阵的加减、矩阵的乘除等在此，先讨论在这种压缩存储结构减、矩阵的乘除等在此，先讨论在这种压缩存储结构下的求矩阵的转置的运算。

下的求矩阵的转置的运算 一个一个m n的矩阵的矩阵A，它的转置，它的转置B是一个是一个n m的矩的矩阵，且阵，且b[i][j]=a[j][i]，，0≦≦i≦≦n，，0≦≦j≦≦m，即，即B的行是的行是A的列，的列，B的列是的列是A的行 设稀疏矩阵设稀疏矩阵A是是按行优先顺序按行优先顺序压缩存储在三元组表压缩存储在三元组表a.data中，若仅仅是简单地交换中，若仅仅是简单地交换a.data中中i和和j的内容，得的内容，得到三元组表到三元组表b.data，，b.data将是一个将是一个按列优先顺序按列优先顺序存储存储的稀疏矩阵的稀疏矩阵B，要得到按行优先顺序存储的，要得到按行优先顺序存储的b.data，就，就必须重新排列三元组表必须重新排列三元组表b.data中元素的顺序中元素的顺序数据结构严蔚敏 求转置矩阵的基本算法思想是：求转置矩阵的基本算法思想是：①① 将矩阵的行将矩阵的行、、列下标值交换即将三元组表中的列下标值交换即将三元组表中的行行、、列位置值列位置值i 、、j相互相互交换交换；； ②② 重排三元组表重排三元组表中元素中元素的顺序即交换后仍然是的顺序。

即交换后仍然是按按行优先顺序行优先顺序排序的方法一方法一：算法思想算法思想：：按稀疏矩阵按稀疏矩阵A的的三元组表三元组表a.data中的中的列次序列次序依次依次找到相应的三元组存入找到相应的三元组存入b.data中 每找转置后矩阵的一个三元组，需从头至尾扫描整每找转置后矩阵的一个三元组，需从头至尾扫描整个三元组表个三元组表a.data 找到之后自然就成为按行优先的转找到之后自然就成为按行优先的转置矩阵的压缩存储表示置矩阵的压缩存储表示数据结构严蔚敏按方法一求转置矩阵的算法如下：按方法一求转置矩阵的算法如下：void TransMatrix(TMatrix a , TMatrix b){ int p , q , col ;b.rn= ; =a.rn ; b.tn=a.tn ;/* 置置三元组表三元组表b.data的的行行、、列数和非列数和非0元素个数元素个数 */if (b.tn==0) printf(“ The Matrix A=0\n” );else{ q=0;for (col=1; col<= ; col++) /* 每循环一次找到转置后的一个三元组每循环一次找到转置后的一个三元组 */for (p=0 ;p

元素的个数的乘积成正比数据结构严蔚敏而一般传统矩阵的转置算法为：而一般传统矩阵的转置算法为：for(col=1; col<=n ;++col)for(row=0 ; row<=m ;++row)b[col][row]=a[row][col] ; 其时间复杂度为其时间复杂度为O(n m)当非零元素的个数当非零元素的个数tn和和m n同数量级时，算法同数量级时，算法TransMatrix的时间复杂度为的时间复杂度为O(m n2) 由此可见，虽然节省了存储空间，但时间复杂度却由此可见，虽然节省了存储空间，但时间复杂度却大大增加所以上述算法只适合于稀疏矩阵中非大大增加所以上述算法只适合于稀疏矩阵中非0元素元素的个数的个数tn远远小于远远小于m n的情况的情况数据结构严蔚敏方法二方法二( (快速转置的算法快速转置的算法) ) 算法思想算法思想：直接按照稀疏矩阵直接按照稀疏矩阵A的的三元组表三元组表a.data的的次次序依次顺序转换序依次顺序转换，并将转换后的三元组，并将转换后的三元组放置于放置于三元组表三元组表b.data的的恰当位置恰当位置 前提前提：：若能预先确定原矩阵若能预先确定原矩阵A中每一列的中每一列的(即即B中每中每一行一行)第一个非第一个非0元素在元素在b.data中应有中应有的位置，则在作转的位置，则在作转置时就可直接放在置时就可直接放在b.data中恰当中恰当的位置。

因此，应的位置因此，应先求先求得得A中每一列的非中每一列的非0元素个数元素个数附设两个辅助向量附设两个辅助向量num[ ]和和cpot[ ] ◆◆ num[col]：统计：统计A中第中第col列中非列中非0元素的个数元素的个数；；◆◆ cpot[col] ：指示：指示A中第一个非中第一个非0元素在元素在b.data中的中的恰当恰当位置数据结构严蔚敏显然有位置对应关系：显然有位置对应关系：cpot[1]=1cpot[col]=cpot[col-1]+num[col-1] 2≦≦col≦≦ 例图例图5-8中的矩阵中的矩阵A和表和表5-9(a)的的相应的三元组表可相应的三元组表可以求得以求得num[col]和和cpot[col]的值如表的值如表5-1：：num[col] 1 2 2 1 0 1 1 1 col 1 2 3 4 5 6 7 8cpot[col] 1 3 5 6 6 7 8 9表表5-1 num[col]和和cpot[col]的值表的值表数据结构严蔚敏快速转置算法如下：快速转置算法如下： void FastTransMatrix(TMatrix a, TMatrix b){ int p , q , col , k ;int num[MAX_SIZE] , copt[MAX_SIZE] ;b.rn= ; =a.rn ; b.tn=a.tn ; /* 置置三元组表三元组表b.data的的行行、、列数和非列数和非0元素个数元素个数 */ if (b.tn==0) printf(“ The Matrix A=0\n” ) ;else{ for (col=1 ; col<= ; ++col) num[col]=0 ; /* 向量向量num[]初始化为初始化为0 */ for (k=1 ; k<=a.tn ; ++k) ++num[ a.data[k].col] ; /* 求原求原矩阵中每一列非矩阵中每一列非0元素个数元素个数 */数据结构严蔚敏for (cpot[0]=1, col=2 ; col<= ; ++col) cpot[col]=cpot[col-1]+num[col-1] ; /* 求第求第col列中第一个非列中第一个非0元在元在b.data中的序号中的序号 */for (p=1 ; p<=a.tn ; ++p) { col=a.data[p].col ; q=cpot[col] ; b.data[q].row=a.data[p].col ; b.data[q].col=a.data[p].row ; b.data[q].value=a.data[p].value ; ++cpot[col] ; /*至关重要至关重要!!当本当本列中列中 */ }}}数据结构严蔚敏2 行逻辑链接的三元组顺序表行逻辑链接的三元组顺序表 将上述方法二中的辅助向量将上述方法二中的辅助向量cpot[ ]固定在稀疏矩阵固定在稀疏矩阵的三元组表中，用来指示的三元组表中，用来指示“行行”的信息。

得到另一种顺的信息得到另一种顺序存储结构：序存储结构：行逻辑链接的三元组顺序表行逻辑链接的三元组顺序表其类型描述其类型描述如下：如下：#define MAX_ROW 100typedef struct { Triple data[MAX_SIZE] ; /* 非非0元素的三元组表元素的三元组表 */ int rpos[MAX_ROW]; /* 各行第一个非各行第一个非0位置表位置表 */ int rn ,cn , tn ; /* 矩阵的行、列数和非矩阵的行、列数和非0元个数元个数 */}RLSMatrix ;数据结构严蔚敏稀疏矩阵的乘法稀疏矩阵的乘法设有两个矩阵：设有两个矩阵：A=(aij)m n ，，B=(bij)n p则：则： C=(cij)m p 其中其中 cij=∑aik bkj 1≦≦k≦≦n ，， 1≦≦i≦≦m ，，1≦≦j≦≦p经典算法是三重循环：经典算法是三重循环：for ( i=1 ; i<=m ; ++i)for ( j=1 ; j<=p ; ++j){ c[i][j]=0 ;for ( k=1 ; k<=n ; ++k) c[i][j]= c[i][j]+a[i][k] b[k][j];}此算法的复杂度为此算法的复杂度为O(m n p)。

数据结构严蔚敏 设有两个稀疏矩阵设有两个稀疏矩阵A=(aij)m n ，，B=(bij)n p ，其，其存储存储结构采用行逻辑链接的三元组顺序表结构采用行逻辑链接的三元组顺序表算法思想算法思想：：对于对于A中的每个元素中的每个元素a.data[p](p=1, 2, … , a.tn)，找到，找到B中所有满足条件：中所有满足条件： a.data[p].col=b.data[q].row的元素的元素b.data[q]，，求得求得a.data[p].value b.data[q].value，该乘积是，该乘积是cij中的一部中的一部分求得所有这样的乘积并累加求和就能得到分求得所有这样的乘积并累加求和就能得到cij 为得到非为得到非0 0的乘积的乘积，只要，只要对对a.data[1…a.tn] 中每个元中每个元素素(i，，k，，aik)(1≦≦i≦≦a.rn，，1≦≦k≦≦) ，，找到找到b.data中中所有相应的元素所有相应的元素(k，，j，，bkj)(1≦≦k≦≦b.rn，，1≦≦j≦≦) 相相乘即可乘即可则必须知道必须知道矩阵矩阵B中第中第k行的所有非行的所有非0元素，而元素，而b.rpos[ ]向量中提供了相应的信息向量中提供了相应的信息。

数据结构严蔚敏 b.rpos[row]指示了指示了矩阵矩阵B的第的第row行中第一个非行中第一个非0元元素在素在b.data[ ]中的位置中的位置(序号序号)，显然，，显然，b.rpos[row+1]-1指指示了第示了第row行中最后一个非行中最后一个非0元素在元素在b.data[ ]中的位置中的位置(序序号号) 最后一行中最后一个非行中最后一个非0元素在元素在b.data[ ]中的位置中的位置显然就是显然就是b.tn 两个稀疏矩阵相乘的两个稀疏矩阵相乘的算法如下：算法如下：void MultsMatrix(RLSMatrix a, RLSMatrix b, RLSMatrix c) /* 求求矩阵矩阵A 、、B的积的积C=A B，，采用行逻辑链接的顺序表采用行逻辑链接的顺序表 * */ /{ elemtype ctemp[Max_Size] ;int p , q , arow , ccol , brow , t ; if (!=b.rn) { printf(“Error\n”) ; exit(0); }数据结构严蔚敏else { c.rn=a.rn ; =b. n ; c.tn=0 ; /* 初始化初始化C */if (a.tn*b.tn!=0) /* C 是非零矩阵是非零矩阵 */{ for (arow=1 ; arow<=a.rn ; ++arow) { ctemp[arow]=0 ; /* 当前行累加器清零当前行累加器清零 */ c.rpos[arow]=c.tn+1; p=a.rops[arow]; for ( ; pMAX_SIZE) { printf(“Error\n”) ; exit(0); } else数据结构严蔚敏c.data[c.tn]=(arow , ccol , ctemp[ccol]) ; }}}}数据结构严蔚敏3 十字链表十字链表 对于稀疏矩阵，当非对于稀疏矩阵，当非0元素的个数和位置在操作过元素的个数和位置在操作过程中变化较大时，采用链式存储结构表示比三元组的线程中变化较大时，采用链式存储结构表示比三元组的线性表更方便。

性表更方便 矩阵中非矩阵中非0元素的结点所含的域有：元素的结点所含的域有：行行、列列、值值、行指针行指针(指向同一行的下一个非指向同一行的下一个非0元元)、、列指针列指针(指向同一指向同一列的下一个非列的下一个非0元元)其次，十字交叉链表还有一个头结其次，十字交叉链表还有一个头结点，结点的结构如图点，结点的结构如图5-10所示图图5-10 十字链十字链表结点结构表结点结构row col value down right rn cn tn down right(a) 结点结构结点结构(b) 头头结点结构结点结构数据结构严蔚敏 由定义知，稀疏矩阵中同一行的非由定义知，稀疏矩阵中同一行的非0元素的由元素的由right指针域链接成一个行链表指针域链接成一个行链表，， 由由down指针域链接成一个指针域链接成一个列链表列链表则每个非则每个非0元素既是元素既是某个行链表中的一个结点某个行链表中的一个结点，，同时又同时又是是某个列链表中的一个结点某个列链表中的一个结点，所有的，所有的非非0元素元素构构成一个成一个十字交叉十字交叉的链表。

称为的链表称为十字链表十字链表 此外，还可用两个此外，还可用两个一一维数组分别存储行维数组分别存储行链表的头指链表的头指针和列链表的头指针针和列链表的头指针对于图5-11(a)的的稀疏矩阵稀疏矩阵A ，对，对应的十字交叉链表如图应的十字交叉链表如图5-11(b)所示，结点的描述如下：所示，结点的描述如下：typedef struct Clnode { int row , col ; /* 行号和列号行号和列号 */ elemtype value ; /* 元素值元素值 */struct Clnode *down , *right ;}OLNode ; /* 非非0元素结点元素结点 */数据结构严蔚敏typedef struct Clnode { int rn; /* 矩阵的矩阵的行数行数 */ int cn; /* 矩阵的矩阵的列数列数 */int tn; /* 非非0元素总数元素总数 */OLNode *rhead ; OLNode *chead ; } CrossList ;图图5-11 稀疏稀疏矩阵矩阵及其及其十字交叉链表十字交叉链表0 12 0 0 00 0 0 0 -40 5 0 0 00 0 3 0 0A=(a) 稀疏稀疏矩阵矩阵(b(b) 稀疏稀疏矩阵的十字交叉链表矩阵的十字交叉链表A.cheadA.rchead⋀ ⋀1 2 12 ⋀3 2 5 ⋀ ⋀2 5 -4 ⋀ ⋀4 3 3 ⋀ ⋀数据结构严蔚敏5.4 广义表广义表 广义表是线性表的推广和扩充，在人工智能领域广义表是线性表的推广和扩充，在人工智能领域中应用十分广泛。

中应用十分广泛 在第在第2章中，我们把线性表定义为章中，我们把线性表定义为n(n≧≧0 )个元素个元素a1, a2 ,…, an的有穷序列，该序列中的所有元素具有相同的的有穷序列，该序列中的所有元素具有相同的数据类型且只能是原子项数据类型且只能是原子项(Atom)所谓原子项可以是一原子项可以是一个数或一个结构，是指结构上不可再分的个数或一个结构，是指结构上不可再分的若放松对元若放松对元素的这种限制，容许它们具有其自身结构，就产生了广素的这种限制，容许它们具有其自身结构，就产生了广义表的概念义表的概念 广义表广义表(Lists，又称为列表又称为列表 )：：是由是由n(n ≧≧0)个个元素组成的有穷序列：元素组成的有穷序列： LS=(a1，，a2，，…，，an)数据结构严蔚敏其中其中ai或者是原子项，或者是一个广义表或者是原子项，或者是一个广义表LS是广义是广义表的名字，表的名字，n为它的长度若为它的长度若ai是广义表，则称为是广义表，则称为LS的子表习惯上：原子用习惯上：原子用小写字母小写字母，子表用，子表用大写字母大写字母若广义表若广义表LS非空时：非空时：◆◆ a1(表中第一个元素表中第一个元素)称为称为表头表头；；◆◆ 其余元素组成的子表称为其余元素组成的子表称为表尾表尾；；(a2，，a3，，…，，an)◆◆ 广义表中所包含的元素广义表中所包含的元素(包括原子和子表包括原子和子表)的个数称的个数称为表的长为表的长 度。

度◆◆ 广义表中括号的最大层数称为表深广义表中括号的最大层数称为表深 (度度)有关广义表的这些概念的例子如表有关广义表的这些概念的例子如表5-2所示数据结构严蔚敏表表5-2 广义广义表及其示例表及其示例广广 义义 表表表长表长n 表深表深hA=()00B=(e)11C=(a,(b,c,d))22D=(A,B,C)33E=(a,E)2∞F=(())12abecdABCD图图5-12 广义广义表的图形表示表的图形表示数据结构严蔚敏广义表的重要结论广义表的重要结论：⑴ ⑴ 广义表的元素可以是原子，也可以是子表，子表广义表的元素可以是原子，也可以是子表，子表的元素又可以是子表，的元素又可以是子表， ……即即广义表是一个多层次广义表是一个多层次的结构 表表5-2中的中的广义表广义表D的图形表示如图的图形表示如图5 5-12所示所示2) (2) 广义表可以被其它广义表广义表可以被其它广义表所共享所共享，也可以，也可以共享共享其其它广义表广义表它广义表广义表共享共享其它广义表时通过表名引用其它广义表时通过表名引用3) (3) 广义表本身可以是一个递归表广义表本身可以是一个递归表。

4) (4) 根据对根据对表头、表尾表头、表尾的定义，任何一个非空广义表的定义，任何一个非空广义表的的表头表头可以是原子，也可以是子表，可以是原子，也可以是子表， 而表尾而表尾必定是必定是广义表数据结构严蔚敏5.4.1 广义表的存储结构广义表的存储结构 由于广义表中的数据元素具有不同的结构，通常由于广义表中的数据元素具有不同的结构，通常用链式存储结构用链式存储结构表示，每个数据元素用一个结点表示表示，每个数据元素用一个结点表示因此，广义表中就有两类结点：因此，广义表中就有两类结点：◆◆ 一类是一类是表结点表结点，用来表示广义表项，由标志域，，用来表示广义表项，由标志域，表头指针域，表尾指针域组成表头指针域，表尾指针域组成;◆◆ 另一类是另一类是原子原子结点结点，用来表示原子项，由标志域，，用来表示原子项，由标志域，原子的值域组成原子的值域组成如图如图5-13所示所示 只要广义表非空，都是由只要广义表非空，都是由表头和表尾组成表头和表尾组成即一个确定的确定的表头和表尾就唯一确定一个表头和表尾就唯一确定一个广义表数据结构严蔚敏相应的数据结构定义如下：相应的数据结构定义如下：typedef struct GLNode{ int tag ; /* 标志域，为标志域，为1：表结点：表结点; ;为为0 ：原子结点：原子结点 */union{ elemtype value; /* 原子结点的原子结点的值域值域 */struct { struct GLNode *hp , *tp ; }ptr ; /* ptr和和atom两成员共用两成员共用 */}Gdata ; } GLNode ; /* 广义表广义表结点类型结点类型 */标志标志tag=0 原子的原子的值值 标志标志tag=1 表头指针表头指针hp 表尾指针表尾指针tp 图图5-13 广义广义表的链表结点结构示意图表的链表结点结构示意图(b) 表结点表结点(a) 原子结点原子结点数据结构严蔚敏例例：： 对对A=()，，B=(e)，，C=(a, (b, c, d) )，，D=(A, B, C)，，E=(a, E)的广义表的存储结构的广义表的存储结构如图如图5 5-14所示所示。

A=NULL1 ∧0 eB10 aC10 b1 ∧10 c1 ∧0 dD1 ∧1 11 ∧10 aE1 ∧图图5-14 广义广义表的存储结构示意图表的存储结构示意图数据结构严蔚敏对于上述对于上述存储结构，有如下几个特点：存储结构，有如下几个特点：(1) 若广义表为空，表头指针为空若广义表为空，表头指针为空；；否则否则，表头指针，表头指针总是指向一个表结点，其中总是指向一个表结点，其中hp指向广义表的表头结点指向广义表的表头结点( (或为原子结点，或为表结点或为原子结点，或为表结点) ) ，，tp指向广义表的表指向广义表的表尾尾( (表尾为空时，指针为空，否则必为表结点表尾为空时，指针为空，否则必为表结点) )2) 这种结构求这种结构求广义表的长度广义表的长度、、深度深度、、表头表头、、表尾的表尾的操作十分方便操作十分方便3) 表结点太多表结点太多，，造成空间浪费造成空间浪费也可用图图5 5-15所示所示的结点结构的结点结构图图5-15 广义广义表的链表结点结构示意图表的链表结点结构示意图(b) 表结点表结点(a) 原子结点原子结点tag=1 表头指针表头指针hp 表尾指针表尾指针tp tag=0 原子的原子的值值 表尾指针表尾指针tp 数据结构严蔚敏习习 题题 五五⑴⑴ 什么是广义表？请简述广义表与线性表的区别？什么是广义表？请简述广义表与线性表的区别？⑵⑵ 一个广义表是一个广义表是(a, (a, b), d, e, (a, (i, j), k)) ，请画出，请画出该广义表的链式存储结构。

该广义表的链式存储结构⑶⑶ 设有二维数组设有二维数组a[6][8]，每个元素占相邻的，每个元素占相邻的4个字个字节，存储器按字节编址，已知节，存储器按字节编址，已知a的起始地址是的起始地址是1000，试，试计算：计算：① ① 数组数组a的最后一个元素的最后一个元素a[5][7]起始地址；起始地址；② ② 按行序优先时，元素按行序优先时，元素a[4][6]起始地址；起始地址；③ ③ 按行序优先时，元素按行序优先时，元素a[4][6]起始地址起始地址数据结构严蔚敏0 3 0 0 0 0 0 00 0 0 0 0 0 0 0-3 0 0 0 0 0 0 40 0 2 0 0 2 0 00 18 0 0 0 0 0 00 0 0 0 4 0 5 0A=0 0 -3 0 0 0 0 0⑷⑷ 设设A和和B是稀疏矩阵，都以三元组作为存储结构，是稀疏矩阵，都以三元组作为存储结构，请写出矩阵相加的算法，其结果存放在三元组表请写出矩阵相加的算法，其结果存放在三元组表C中，中，并分析时间复杂度并分析时间复杂度⑸⑸ 设有稀疏矩阵设有稀疏矩阵B如下图所示，请画出该稀疏矩阵如下图所示，请画出该稀疏矩阵的三元组表和十字链表存储结构。

的三元组表和十字链表存储结构数据结构严蔚敏第第6章章 树和二叉树树和二叉树 树型结构是一类非常重要的非线性结构直观地，树型结构是一类非常重要的非线性结构直观地，树型结构是树型结构是以分支关系定义的层次结构以分支关系定义的层次结构 树在计算机领域中也有着广泛的应用，例如在编译树在计算机领域中也有着广泛的应用，例如在编译程序中，用树来表示源程序的语法结构；在数据库系统程序中，用树来表示源程序的语法结构；在数据库系统中，可用树来组织信息；在分析算法的行为时，可用树中，可用树来组织信息；在分析算法的行为时，可用树来描述其执行过程等等来描述其执行过程等等 本章将详细讨论树和二叉树数据结构，主要介绍树本章将详细讨论树和二叉树数据结构，主要介绍树和二叉树的概念、术语，二叉树的遍历算法树和二叉和二叉树的概念、术语，二叉树的遍历算法树和二叉树的各种存储结构以及建立在各种存储结构上的操作及树的各种存储结构以及建立在各种存储结构上的操作及应用等数据结构严蔚敏6.1 树的基本概念树的基本概念1 树的定义树的定义 树树(Tree)是是n(n≧≧0)个结点的有限集合个结点的有限集合T，若，若n=0时称时称为空树，否则：为空树，否则：⑴⑴ 有且只有一个特殊的称为树的根有且只有一个特殊的称为树的根(Root)结点；结点；⑵⑵ 若若n>1时，其余的结点被分为时，其余的结点被分为m(m>0)个个互不相交互不相交的子集的子集T1, T2, T3…Tm，其中每个子集本身又是一棵树，其中每个子集本身又是一棵树，称其为根的子树，称其为根的子树(Subtree)。

这是树的递归定义，即用树来定义树，而只有一个这是树的递归定义，即用树来定义树，而只有一个结点的树必定仅由根组成，如图结点的树必定仅由根组成，如图6-1(a)所示 6.1.1 树的定义和基本术语树的定义和基本术语数据结构严蔚敏2 树的基本术语树的基本术语⑴⑴ 结点结点(node)：：一个数据元素及其若干指向其子树一个数据元素及其若干指向其子树的分支⑵⑵ 结点的度结点的度(degree) 、树的度树的度：：结点所拥有的子结点所拥有的子树的棵数称为树的棵数称为结点的度结点的度树中结点度的最大值称为树中结点度的最大值称为树树的度的度 图图6-1 树的示树的示例形式例形式AABDCEGFHIMJNKL(a) 只有根结点只有根结点(b) 一般的树一般的树数据结构严蔚敏 如图如图6-1(b)中结点中结点A的度是的度是3 ，结点，结点B的度是的度是2 ，结点，结点M的度是的度是0，树的度是，树的度是3 ⑶⑶ 叶子叶子(left)结点结点、、非叶子结点非叶子结点：：树中树中度为度为0的的结结点称为点称为叶子结点叶子结点( (或终端结点或终端结点) )。

相对应地，相对应地，度不为度不为0的的结点称为结点称为非叶子结点非叶子结点(或非终端结点或分支结点或非终端结点或分支结点) )除根结点外，分支结点又称为内部结点除根结点外，分支结点又称为内部结点 如图如图6-1(b)中结点中结点H、、I、、J、、K、、L、、M、、N是叶子是叶子结点，而所有其它结点都是分支结点结点，而所有其它结点都是分支结点⑷⑷ 孩子结点孩子结点、、双亲结点双亲结点、、兄弟结点兄弟结点 一个结点的一个结点的子树的根子树的根称为该结点的孩子结点称为该结点的孩子结点(child)或子结点或子结点；；相应地，该结点是其孩子结点的双亲结点相应地，该结点是其孩子结点的双亲结点(parent)或父结点或父结点数据结构严蔚敏 如图如图6-1(b)中结点中结点B 、、C、、D是结点是结点A的子结点的子结点，而，而结点结点A是是结点结点B 、、C、、D的的父结点父结点；；类似地结点类似地结点E 、、F是是结点结点B的子结点的子结点，结点，结点B是是结点结点E 、、F的的父结点同一双亲结点的所有子结点互称为同一双亲结点的所有子结点互称为兄弟结点兄弟结点。

如图如图6-1(b)中结点中结点B 、、C、、D是兄弟结点；结点是兄弟结点；结点E 、、F是兄弟结点是兄弟结点⑸⑸ 层次层次、、堂兄弟结点堂兄弟结点 规定树中根结点的层次为规定树中根结点的层次为1，其余结点的层次等于，其余结点的层次等于其双亲结点的层次加其双亲结点的层次加1 若某结点在第若某结点在第l(l≧≧1)层，则其子结点在第层，则其子结点在第l+1层 双亲结点在同一层上的所有结点互称为双亲结点在同一层上的所有结点互称为堂兄弟结点堂兄弟结点如图如图6-1(b)中结点中结点E、、F、、G、、H、、I、、J数据结构严蔚敏⑹⑹ 结点的层次路径结点的层次路径、、祖先祖先、、子孙子孙 从根结点开始，到达某结点从根结点开始，到达某结点p所经过的所有结点成所经过的所有结点成为为结点结点p的的层次路径层次路径( (有且只有一条有且只有一条) ) 结点结点p的层次路径上的所有结点（的层次路径上的所有结点（p除外）称为除外）称为p的的祖先祖先(ancester) 以某一结点为根的子树中的任意结点称为该结点的以某一结点为根的子树中的任意结点称为该结点的子孙结点子孙结点(descent)。

⑺⑺ 树的深度树的深度(depth)：：树中结点的最大层次值，又树中结点的最大层次值，又称为树的高度，如图称为树的高度，如图6-1(b)中树的高度为中树的高度为4⑻⑻ 有序树和无序树有序树和无序树：对于一棵树，若其中每一个对于一棵树，若其中每一个结点的子树（若有）具有一定的次序，则该树称为结点的子树（若有）具有一定的次序，则该树称为有有序树序树，否则称为，否则称为无序树无序树数据结构严蔚敏⑼⑼ 森林森林(forest)：是是m(m≧≧0)棵互不相交的棵互不相交的树的集树的集合显然，若将一棵树的根结点删除，剩余的子树就合显然，若将一棵树的根结点删除，剩余的子树就构成了森林构成了森林3 树的表示形式树的表示形式⑴⑴ 倒悬树倒悬树是最常用的表示形式，如图是最常用的表示形式，如图6-1(b)⑵⑵ 嵌套集合嵌套集合是一些集合的集体，对于任何两个集是一些集合的集体，对于任何两个集合，或者不相交，或者一个集合包含另一个集合图合，或者不相交，或者一个集合包含另一个集合图6-2(a)是图是图6-1(b)树的嵌套集合形式树的嵌套集合形式⑶⑶ 广义表形式广义表形式图图6-2(b)是树的广义表形式是树的广义表形式。

⑷⑷ 凹入法表示形式凹入法表示形式见见P120 树的表示方法的多样化说明了树结构的重要性树的表示方法的多样化说明了树结构的重要性数据结构严蔚敏图图6-2 树的表示树的表示形式形式(a) 嵌套集合嵌套集合形式形式(b) 广义表广义表形式形式(A(B(E(K,L),F),C(G(M,N)),D(H,I,J)HIJDFBKLECM NGA数据结构严蔚敏6.1.2 树的抽象数据类型定义树的抽象数据类型定义ADT Tree{数据对象数据对象D：：D是具有相同数据类型的数据元素的集是具有相同数据类型的数据元素的集合合数据关系数据关系R：若：若D为空集为空集，，则称为空树则称为空树；； …………基本操作：基本操作： …………} ADT Tree 详见详见p118~119数据结构严蔚敏6.2 二叉树二叉树6.2.1 二叉树的定义二叉树的定义1 二叉树的定义二叉树的定义 二叉树二叉树(Binary tree)是是n(n≥0)个结点的有限集合个结点的有限集合若若n=0时称为空树，否则：时称为空树，否则：⑴⑴ 有且只有一个特殊的称为树的根有且只有一个特殊的称为树的根(Root)结点；结点；⑵⑵ 若若n>1时，其余的结点被分成为时，其余的结点被分成为二个互不相交二个互不相交的子的子集集T1,T2，分别称之为左，分别称之为左、、右子树，并且左右子树，并且左、、右子树右子树又都是二叉树。

又都是二叉树 由此可知，二叉树的由此可知，二叉树的定义是递归定义是递归的数据结构严蔚敏 二叉树在树结构中起着非常重要的作用因为二叉二叉树在树结构中起着非常重要的作用因为二叉树结构简单，存储效率高，树的操作算法相对简单，且树结构简单，存储效率高，树的操作算法相对简单，且任何树都很容易转化成二叉树结构上节中引入的有关任何树都很容易转化成二叉树结构上节中引入的有关树的术语也都适用于二叉树树的术语也都适用于二叉树2 二叉树的基本形态二叉树的基本形态 二叉树有二叉树有5种基本形态，如图种基本形态，如图6-3所示AAAA(a)(b)(c)(d)(e)(a) 空空二叉树二叉树(b) 单结点单结点二叉树二叉树(c) 右子树为空右子树为空(d) 左子树为空左子树为空(e) 左左、、右子树都不空右子树都不空图图6-3 二叉二叉树的基本树的基本形态形态数据结构严蔚敏6.2.2 二叉树的性质二叉树的性质性质性质1：：在非空二叉树中，第在非空二叉树中，第i i层上至多有层上至多有2i-1个结点个结点(i≧≧1)证明证明：：用数学归纳法证明用数学归纳法证明。

当当i=1时：只有一个根结点，时：只有一个根结点，21-1=20 =1，命题成立命题成立 现假设对现假设对i>1时，处在第时，处在第i-1层上至多有层上至多有2(i-1)-1个结点 由归纳假设知，第由归纳假设知，第i-1层上至多有层上至多有2i-2个结点由于二个结点由于二叉树每个结点的度最大为叉树每个结点的度最大为2，故在第，故在第i i层上最大结点数为层上最大结点数为第第i-1层上最大结点数的层上最大结点数的2倍 即即 2×2i-2＝＝2i-1 证毕证毕性质性质2：深度为深度为k的二叉树至多有的二叉树至多有2k-1个结点个结点（（k≧≧1) 数据结构严蔚敏证明证明：：深度为深度为k的二叉树的最大的结点数为二叉树中每的二叉树的最大的结点数为二叉树中每层上的最大结点数之和层上的最大结点数之和 由性质由性质1知知，二叉树的第，二叉树的第1层层、、第第2层层⋯ ⋯第第k层上的结层上的结点数至多有：点数至多有： 20、、21 ……2k-1 ∴∴ 总的总的结点数至多有：结点数至多有： 20+21+ ……+ +2k-1=2k-1 证毕证毕 性质性质3：对任何一棵二叉树，若其叶子结点数为对任何一棵二叉树，若其叶子结点数为n0，，度为度为2的结点数为的结点数为n2，则，则n0=n2+1。

证明：证明：设二叉树中度为设二叉树中度为1的结点数为的结点数为n1，二叉树中总结，二叉树中总结点数为点数为N，因为二叉树中所有结点均小于或等于，因为二叉树中所有结点均小于或等于2，则有：，则有：N=n0+n1+n2再看二叉树中的分支数：再看二叉树中的分支数：数据结构严蔚敏 除根结点外，其余每个结点都有唯一的一个进入分除根结点外，其余每个结点都有唯一的一个进入分支，而所有这些分支都是由度为支，而所有这些分支都是由度为1和和2的结点射出的设的结点射出的设B为二叉树中的分支总数，则有：为二叉树中的分支总数，则有： N=B+1 ∴∴ B＝＝n1+2 n2 ∴∴ N=B+1=n1+2 n2+1 ∴∴ n0+n1+n2=n1+2 n2+1 即即 n0=n2+1 证毕证毕满二叉树和完全二叉树满二叉树和完全二叉树 一棵深度为一棵深度为k且有且有2k-1个结点的二叉树称为个结点的二叉树称为满二叉满二叉树树(Full Binary Tree)。

如图如图6-4(a) 就是一棵深度为就是一棵深度为4的满二叉树的满二叉树数据结构严蔚敏894101151213614157213894101152112673(a) 满二叉树满二叉树(b) 完全二叉树完全二叉树1362455674213(c) 非完全二叉树非完全二叉树图图6-4 特殊形态的特殊形态的二叉二叉树树数据结构严蔚敏满二叉树的特点满二叉树的特点：◆ ◆ 基本特点是每一层上的结点数总是最大结点数基本特点是每一层上的结点数总是最大结点数◆ ◆ 满二叉树的所有的支结点都有左满二叉树的所有的支结点都有左、、右子树◆ ◆ 可对满二叉树的结点进行连续编号，若规定从根可对满二叉树的结点进行连续编号，若规定从根结点开始，按结点开始，按““自上而下自上而下、、自左至右自左至右””的原则进行的原则进行完全二叉树完全二叉树( (Complete Binary Tree) )：如果深度为：如果深度为k，由，由n个结点的二叉树，当且仅当其每一个结点都与深度为个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号从的满二叉树中编号从1到到n的结点一一对应，该二叉树称的结点一一对应，该二叉树称为完全二叉树。

为完全二叉树 或深度为或深度为k的满二叉树中编号从的满二叉树中编号从1到到n的前的前n个结点构个结点构成了一棵深度为成了一棵深度为k的完全二叉树的完全二叉树其中其中 2k-1 ≦≦ n≦≦2k-1 数据结构严蔚敏 完全二叉树是满二叉树的一部分，而满二叉树是完完全二叉树是满二叉树的一部分，而满二叉树是完全二叉树的特例全二叉树的特例完全二叉树的特点完全二叉树的特点： 若完全二叉树的深度为若完全二叉树的深度为k ，则所有的叶子结点都出现，则所有的叶子结点都出现在第在第k k层或层或k-1层对于任一结点，如果其右子树的最大层对于任一结点，如果其右子树的最大层次为层次为l，则其左子树的最大层次为，则其左子树的最大层次为l或或l+1 1性质性质4：：n个结点的完全二叉树深度为：个结点的完全二叉树深度为： ㏒㏒2n  + +1 1 其中符号：其中符号：  x 表示不大于表示不大于x的最大整数的最大整数  x  表示不小于表示不小于x的最小整数的最小整数证明：证明：假设完全二叉树的深度为假设完全二叉树的深度为k，则根据性质，则根据性质2及完及完全二叉树的定义有：全二叉树的定义有：数据结构严蔚敏2k-1-1

是整数 ∴ ∴ k=  ㏒㏒2n  + +1 1 证毕证毕性质性质5：：若对一棵有若对一棵有n n个结点的完全二叉树个结点的完全二叉树( (深度为深度为└㏒㏒2n┘+ +1)1)的结点按层（从第的结点按层（从第1层到第层到第 ㏒㏒2n  + +1 1层层) )序自左至序自左至右进行编号右进行编号, ,则对于编号为则对于编号为i（（1≦≦i≦≦n)的的结点：结点：⑴ ⑴ 若若i=1：则结点：则结点i是二叉树的根，无双亲结点；否是二叉树的根，无双亲结点；否则，若则，若i>1，则其双亲结点编号是，则其双亲结点编号是  i/2  ⑵ ⑵ 如果如果2i>n：则结点：则结点i为叶子结点，无左孩子；否则，为叶子结点，无左孩子；否则，其左孩子结点编号是其左孩子结点编号是2i⑶ ⑶ 如果如果2i+1>n：则结点：则结点i无右孩子；否则，其右孩子无右孩子；否则，其右孩子结点编号是结点编号是2i+1数据结构严蔚敏 证明证明：：用数学归纳法证明首先证明用数学归纳法证明首先证明⑵⑵和和⑶⑶，然后，然后由由⑵⑵和和⑶⑶导出导出⑴⑴。

当当i=1时时，由完全二叉树的定义知，结点，由完全二叉树的定义知，结点i的左孩子的左孩子的编号是的编号是2，右孩子的编号是，右孩子的编号是3 若若2>n，则二叉树中不存在编号为，则二叉树中不存在编号为2的结点，说明的结点，说明结点结点i的左的左孩子孩子不存在 若若3>n，则二叉树中不存在编号为，则二叉树中不存在编号为3的结点，说明的结点，说明结点结点i的右的右孩子孩子不存在 现假设对于编号为现假设对于编号为j(1≦≦j≦≦i)的结点的结点，，(2)(2)和和(3)(3)成立即：即：◆◆ 当当2j≦≦n ：结点：结点j的左孩子编号是的左孩子编号是2j；当；当2j>n时时，，结点结点j的左孩子结点不存在的左孩子结点不存在数据结构严蔚敏◆◆ 当当2j+1≦≦n ：结点：结点j的右孩子编号是的右孩子编号是2j+1；当；当2j+1>n时，结点时，结点j的右孩子结点不存在的右孩子结点不存在 当当i=j+1时，由完全二叉树的定义知，若结点时，由完全二叉树的定义知，若结点i的左的左孩子结点存在，则其左孩子结点的编号一定等于编号为孩子结点存在，则其左孩子结点的编号一定等于编号为j的右孩子的编号加的右孩子的编号加1，即结点，即结点i的左孩子的编号为：的左孩子的编号为： (2j+1)+1=2(j+1)=2i如图如图6-5所示，且有所示，且有2i≦≦n。

相反，若相反，若2i>n，则左孩子结，则左孩子结点不存在同样地，若结点点不存在同样地，若结点i的右孩子结点存在，则其的右孩子结点存在，则其右孩子的编号为：右孩子的编号为：2i+1，且有，且有2i+1≦≦n相反，若相反，若2i+1>n，则左孩子结点不存在结论，则左孩子结点不存在结论(2)(2)和和(3)(3)得证 再由再由(2)(2)和和(3)(3)来证明来证明(1) 当当i=1时时，显然编号为，显然编号为1的的是根结点，无双亲结点是根结点，无双亲结点数据结构严蔚敏 当当i>1时，设编号为时，设编号为i的结点的双亲结点的编号为的结点的双亲结点的编号为m，，若编号为若编号为i的结点是其双亲结点的左孩子，则由的结点是其双亲结点的左孩子，则由(2)有：有：i=2m ，即，即m= i/2  ；；若编号为若编号为i的结点是其的结点是其双亲结点的右孩子，则由双亲结点的右孩子，则由(3)有：有：i=2m+1 ，即，即m= (i-1) /2  ；；∴ ∴ 当当i>1时时，其双亲结点的编号为，其双亲结点的编号为 i/2  证毕证毕ii+12i2i+12i+22i+3└i/2┘(a) i和和i+1结点在同一层结点在同一层i+12i+22i+3i2i2i+1……(b) i和和i+1结点不在同一层结点不在同一层图图6-5 完全完全二叉二叉树中结点树中结点i和和i+1的左右孩子的左右孩子数据结构严蔚敏6.2.3 二叉树的存储结构二叉树的存储结构1 顺序存储结构顺序存储结构 二叉树存储结构的类型定义：二叉树存储结构的类型定义：#define MAX_SIZE 100 typedef telemtype sqbitree[MAX_SIZE]; 用一组地址连续的存储单元依次用一组地址连续的存储单元依次““自上而下自上而下、、自左自左至右至右””存储完全二叉树的数据元素。

存储完全二叉树的数据元素 对于完全二叉树上编号为对于完全二叉树上编号为i的结点元素存储在一维数的结点元素存储在一维数组的下标值为组的下标值为i-1的分量中的分量中，如图，如图6-6(c)所示 对于一般的二叉树，将其每个结点与完全二叉树上对于一般的二叉树，将其每个结点与完全二叉树上的结点相对照，的结点相对照，存储在一维数组中存储在一维数组中，如图，如图6-6(d)所示数据结构严蔚敏abcdhiejklfg(a) 完全二叉树完全二叉树(b) 非完全二叉树非完全二叉树abcdefghØØØ1 2 3 4 5 6 7 8 9 10 11 12 a b c d e f g h i j k l (c) 完全二叉树的顺序存储形式完全二叉树的顺序存储形式1 2 3 4 5 6 7 8 9 10 11a b c d e Ø h Ø Ø f g(d) 非完全二叉树的顺序存储形式非完全二叉树的顺序存储形式图图6-6 二叉二叉树及其树及其顺序存储形式顺序存储形式数据结构严蔚敏 最坏的情况下，一个深度为最坏的情况下，一个深度为k且只有且只有k个结点的单支个结点的单支树需要长度为树需要长度为2k-1的一维数组的一维数组。

2 链式存储结构链式存储结构 设计不同的结点结构可构成不同的链式存储结构设计不同的结点结构可构成不同的链式存储结构1) 结点的类型及其定义结点的类型及其定义① ① 二叉链表结点二叉链表结点有三个域：一个数据域，两个分有三个域：一个数据域，两个分别指向左右子结点的指针域，如图别指向左右子结点的指针域，如图6-7(a)所示 typedef struct BTNode{ ElemType data ;struct BTNode *Lchild , *Rchild ;}BTNode ; 数据结构严蔚敏②② 三三叉链表结点叉链表结点除二叉链表的三个域外，再增加一除二叉链表的三个域外，再增加一个指针域，用来指向结点的父结点，如图个指针域，用来指向结点的父结点，如图6-7(b)所示typedef struct BTNode_3{ ElemType data ;struct BTNode_3 *Lchild , *Rchild , *parent ;}BTNode_3 ; Lchild data RchildLchild data parent Rchild(a) 二叉链表结点二叉链表结点(b) 三三叉链表结点叉链表结点图图6-7 链表结点结构链表结点结构形式形式数据结构严蔚敏(2) 二叉树的链式存储形式二叉树的链式存储形式 例有一棵一般的二叉树，如图例有一棵一般的二叉树，如图6-8(a)所示。

以二叉链所示以二叉链表和三叉链表方式存储的结构图分别如图表和三叉链表方式存储的结构图分别如图6-8(b) 、、 6-8(c)所示图图6-8 二叉树及其二叉树及其链式存储结构链式存储结构(a) 二叉树二叉树afedcbg(c) 三三叉链表叉链表 a ⋀ ⋀ b⋀ c ⋀ d⋀ e⋀ f ⋀⋀ g ⋀T(b) 二二叉链表叉链表 a ⋀ b⋀ c ⋀ d⋀ e⋀ g ⋀⋀ f ⋀T数据结构严蔚敏6.3 遍历二叉树及其应用遍历二叉树及其应用遍历二叉树遍历二叉树(Traversing Binary Tree)：：是指是指按指定按指定的规律的规律对二叉树中的对二叉树中的每个结点访问一次且仅访问一次每个结点访问一次且仅访问一次 所谓所谓访问访问是指对结点做某种处理如：输出信息是指对结点做某种处理如：输出信息、、修改结点的值等修改结点的值等 二叉树是一种非线性结构，每个结点都可能有左二叉树是一种非线性结构，每个结点都可能有左、、右两棵子树，因此，需要寻找一种规律，使二叉树上的右两棵子树，因此，需要寻找一种规律，使二叉树上的结点能排列在一个线性队列上，从而便于遍历。

结点能排列在一个线性队列上，从而便于遍历 二叉树的基本组成：根结点二叉树的基本组成：根结点、、左子树左子树、、右子树若右子树若能依次遍历这三部分，就是遍历了二叉树能依次遍历这三部分，就是遍历了二叉树数据结构严蔚敏 若以若以L、、D、、R分别表示遍历左子树、遍历根结点和分别表示遍历左子树、遍历根结点和遍历右子树，遍历右子树，则有六种遍历方案：则有六种遍历方案：DLR、、LDR、、LRD、、DRL、、RDL、、RLD若规定若规定先左后右先左后右，则只有，则只有前三种前三种情况情况三种情况，分别是：三种情况，分别是：DLR————先先( (根根) )序遍历LDR————中中( (根根) )序遍历LRD————后后( (根根) )序遍历 对于二叉树的遍历，分别讨论递归遍历算法和非递对于二叉树的遍历，分别讨论递归遍历算法和非递归遍历算法递归遍历算法具有非常清晰的结构，但初归遍历算法递归遍历算法具有非常清晰的结构，但初学者往往难以接受或怀疑，不敢使用实际上，递归算学者往往难以接受或怀疑，不敢使用实际上，递归算法是由系统通过使用堆栈来实现控制的而非递归算法法是由系统通过使用堆栈来实现控制的。

而非递归算法中的控制是由设计者定义和使用堆栈来实现的中的控制是由设计者定义和使用堆栈来实现的数据结构严蔚敏6.3.1 先序遍历二叉树先序遍历二叉树1 递归算法递归算法算法的递归定义是：算法的递归定义是： 若二叉树为空，则遍历结束；否则若二叉树为空，则遍历结束；否则⑴⑴ 访问根结点；访问根结点；⑵⑵ 先序遍历左子树先序遍历左子树(递归调用本算法递归调用本算法)；；⑶⑶ 先序遍历右子树先序遍历右子树(递归调用本算法递归调用本算法)数据结构严蔚敏先序遍历的递归算法先序遍历的递归算法void PreorderTraverse(BTNode *T){ if (T!=NULL) { visit(T->data) ; /* 访问根结点访问根结点 */PreorderTraverse(T->Lchild) ;PreorderTraverse(T->Rchild) ; }}说明：说明：visit()函数是访问结点的数据域，其要求视具体函数是访问结点的数据域，其要求视具体问题而定树采用二叉链表的存储结构，用指针变量问题而定树采用二叉链表的存储结构，用指针变量T T来指向。

来指向数据结构严蔚敏2 非递归算法非递归算法设设T是指向二叉树根结点的指针变量，非递归算法是：是指向二叉树根结点的指针变量，非递归算法是：若二叉树为空，则返回；否则，令若二叉树为空，则返回；否则，令p=T；；⑴ ⑴ 访问访问p所指向的结点；所指向的结点；⑵ ⑵ q=p->Rchild ，若，若q不为空，则不为空，则q进栈；进栈；⑶ ⑶ p=p->Lchild ，若，若p不为空，转不为空，转(1)，否则转，否则转(4)；；⑷⑷ 退栈到退栈到p ，转，转(1)，直到栈空为止直到栈空为止算法实现算法实现：：数据结构严蔚敏#define MAX_NODE 50void PreorderTraverse( BTNode *T){ BTNode *Stack[MAX_NODE] ,*p=T, *q ;int top=0 ;if (T==NULL) printf(“ Binary Tree is Empty!\n”) ;else { do { visit( p-> data ) ; q=p->Rchild ; if ( q!=NULL ) stack[++top]=q ; p=p->Lchild ; if (p==NULL) { p=stack[top] ; top-- ; } } while (p!=NULL) ;}}数据结构严蔚敏6.3.2 中序遍历二叉树中序遍历二叉树1 递归算法递归算法算法的递归定义是：算法的递归定义是： 若二叉树为空，则遍历结束；否则若二叉树为空，则遍历结束；否则⑴⑴ 中序遍历左子树中序遍历左子树(递归调用本算法递归调用本算法)；；⑵⑵ 访问根结点；访问根结点；⑶⑶ 中序遍历右子树中序遍历右子树(递归调用本算法递归调用本算法)。

数据结构严蔚敏中序遍历的递归算法中序遍历的递归算法void InorderTraverse(BTNode *T){ if (T!=NULL) { InorderTraverse(T->Lchild) ;visit(T->data) ; /* 访问根结点访问根结点 */InorderTraverse(T->Rchild) ;}} /*图图6-8(a) 的二叉树，输出的次序是：的二叉树，输出的次序是： cbegdfa */数据结构严蔚敏2 非递归算法非递归算法设设T是指向二叉树根结点的指针变量，非递归算法是：是指向二叉树根结点的指针变量，非递归算法是：若二叉树为空，则返回；否则，令若二叉树为空，则返回；否则，令p=T⑴ ⑴ 若若p不为空，不为空，p进栈，进栈， p=p->Lchild ；；⑵ ⑵ 否则否则(即即p为空为空)，退栈到，退栈到p，访问，访问p所指向的结点；所指向的结点；⑶ ⑶ p=p->Rchild ，转，转(1)；；直到栈空为止直到栈空为止算法实现算法实现：：数据结构严蔚敏#define MAX_NODE 50void InorderTraverse( BTNode *T){ BTNode *Stack[MAX_NODE] ,*p=T ; int top=0 , bool=1 ; if (T==NULL) printf(“ Binary Tree is Empty!\n”) ; else { do { while (p!=NULL) { stack[++top]=p ; p=p->Lchild ; } if (top==0) bool=0 ; else { p=stack[top] ; top-- ; visit( p->data ) ; p=p->Rchild ; } } while (bool!=0) ; } }数据结构严蔚敏6.3.3 后序遍历二叉树后序遍历二叉树1 递归算法递归算法算法的递归定义是：算法的递归定义是： 若二叉树为空，则遍历结束；否则若二叉树为空，则遍历结束；否则⑴⑴ 后序遍历左子树后序遍历左子树(递归调用本算法递归调用本算法)；；⑵⑵ 后序遍历右子树后序遍历右子树(递归调用本算法递归调用本算法) ；；⑶⑶ 访问根结点访问根结点 。

数据结构严蔚敏后序遍历的递归算法后序遍历的递归算法void PostorderTraverse(BTNode *T){ if (T!=NULL) { PostorderTraverse(T->Lchild) ;PostorderTraverse(T->Rchild) ; visit(T->data) ; /* 访问根结点访问根结点 */ }} /*/*图图6-8(a) 的二叉树，输出的次序是：的二叉树，输出的次序是： cgefdba */cgefdba */ 遍历二叉树的算法中基本操作是访问结点，因此，遍历二叉树的算法中基本操作是访问结点，因此，无论是哪种次序的遍历，对有无论是哪种次序的遍历，对有n个结点的二叉树，其时个结点的二叉树，其时间复杂度均为间复杂度均为O(n) 数据结构严蔚敏 如图如图6-9所示的二叉树表示表达式：所示的二叉树表示表达式：(a+b*(c-d)-e/f)按不同的次序遍历此二叉树，将访问的结点按先后次序按不同的次序遍历此二叉树，将访问的结点按先后次序排列起来的次序是：排列起来的次序是： 其先序序列为：其先序序列为： -+a*b-cd/ef 其中序序列为：其中序序列为： a+b*c-d-e/f 其后序序列为：其后序序列为： abcd-*+ef/-－/fe-dcb*a+图图6-9 表达式表达式 (a+b*(c-d)-e/f)二叉树二叉树数据结构严蔚敏2 非递归算法非递归算法 在后序遍历中，根结点是最后被访问的。

因此，在在后序遍历中，根结点是最后被访问的因此，在遍历过程中，当搜索指针指向某一根结点时，不能立即遍历过程中，当搜索指针指向某一根结点时，不能立即访问，而要先遍历其左子树，此时访问，而要先遍历其左子树，此时根结点进栈根结点进栈当其左子树遍历完后再搜索到该根结点时，还是不能访问，还子树遍历完后再搜索到该根结点时，还是不能访问，还需遍历其右子树所以，此需遍历其右子树所以，此根结点还需再次进栈根结点还需再次进栈，当其，当其右子树遍历完后再退栈到到该根结点时，才能被访问右子树遍历完后再退栈到到该根结点时，才能被访问 因此，设立一个状态标志变量因此，设立一个状态标志变量tag ：：0 ：： 结点暂不能访问结点暂不能访问1 ：： 结点可以被访问结点可以被访问tag=数据结构严蔚敏 其次，设两个堆栈其次，设两个堆栈S1、、S2 ，，S1保存结点，保存结点，S2保存结保存结点的点的状态标志变量状态标志变量tag S1和和S2共用一个栈顶共用一个栈顶指针 设设T是指向根结点的指针变量，非递归算法是：是指向根结点的指针变量，非递归算法是：若二叉树为空，则返回；否则，令若二叉树为空，则返回；否则，令p=T；；⑴ ⑴ 第一次经过根结点第一次经过根结点p，不访问：，不访问： p进栈进栈S1 ，， tag 赋值赋值0，进栈，进栈S2，，p=p->Lchild 。

⑵ ⑵ 若若p不为空，转不为空，转(1)，否则，取状态标志值，否则，取状态标志值tag ：： ⑶⑶ 若若tag=0：对栈：对栈S1，不访问，不出栈；修改，不访问，不出栈；修改S2栈顶栈顶元素值元素值(tag赋值赋值1) ，取，取S1栈顶元素的右子树，即栈顶元素的右子树，即p=S1[top]->Rchild ，转，转(1)；；⑷ ⑷ 若若tag=1：：S1退栈，访问该结点；退栈，访问该结点；直到栈空为止直到栈空为止数据结构严蔚敏算法实现算法实现：：#define MAX_NODE 50void PostorderTraverse( BTNode *T){ BTNode *S1[MAX_NODE] ,*p=T ;int S2[MAX_NODE] , top=0 , bool=1 ;if (T==NULL) printf(“Binary Tree is Empty!\n”) ;else { do { while (p!=NULL) { S1[++top]=p ; S2[top]=0 ; p=p->Lchild ; } if (top==0) bool=0 ;数据结构严蔚敏 else if (S2[top]==0) { p=S1[top]->Rchild ; S2[top]=1 ; } else { p=S1[top] ; top-- ; visit( p->data ) ; p=NULL ; /* 使循环继续进行而不至于死循环使循环继续进行而不至于死循环 */ }} while (bool!=0) ;}}数据结构严蔚敏6.3.4 层次遍历二叉树层次遍历二叉树 层次遍历二叉树，是从根结点开始遍历，按层次次层次遍历二叉树，是从根结点开始遍历，按层次次序序“自上而下自上而下，，从左至右从左至右”访问树中的各结点。

访问树中的各结点 为保证是按层次遍历，必须设置一个队列，初始化为保证是按层次遍历，必须设置一个队列，初始化时为空 设设T是指向根结点的指针变量，层次遍历非递归算是指向根结点的指针变量，层次遍历非递归算法是：法是：若二叉树为空，则返回；否则，令若二叉树为空，则返回；否则，令p=T，，p入队；入队；⑴⑴ 队首元素出队到队首元素出队到p；；⑵⑵访问访问p所指向的结点；所指向的结点； ⑶⑶将将p所指向的结点的左、右子结点依次入队直到所指向的结点的左、右子结点依次入队直到队空为止队空为止数据结构严蔚敏#define MAX_NODE 50void LevelorderTraverse( BTNode *T){ BTNode *Queue[MAX_NODE] ,*p=T ;int front=0 , rear=0 ;if (p!=NULL) { Queue[++rear]=p; /* 根结点入队根结点入队 */while (frontdata ); if (p->Lchild!=NULL) Queue[++rear]=p; /* 左结点入队左结点入队 */ if (p->Rchild!=NULL) Queue[++rear]=p; /* 左结点入队左结点入队 */ }}}数据结构严蔚敏 “遍历遍历”是二叉树最重要的基本操作，是各种其它是二叉树最重要的基本操作，是各种其它操作的基础，二叉树的许多其它操作都可以通过遍历来操作的基础，二叉树的许多其它操作都可以通过遍历来实现。

如建立二叉树的存储结构、求二叉树的结点数、实现如建立二叉树的存储结构、求二叉树的结点数、求二叉树的深度等求二叉树的深度等6.3.5 二叉树遍历算法的应用二叉树遍历算法的应用数据结构严蔚敏1 二叉树的二叉链表创建二叉树的二叉链表创建⑴⑴ 按满二叉树方式建立按满二叉树方式建立 (补充补充) 在此补充按满二叉树的方式对结点进行编号建立链式在此补充按满二叉树的方式对结点进行编号建立链式二叉树对每个结点，输入二叉树对每个结点，输入i、、chi ：： 结点编号，按从小到大的顺序输入结点编号，按从小到大的顺序输入ch ：： 结点内容，假设是字符结点内容，假设是字符 在建立过程中借助一个一维数组在建立过程中借助一个一维数组S[n] ，编号为，编号为i的结的结点保存在点保存在S[i]中中算法实现算法实现：：数据结构严蔚敏#define MAX_NODE 50typedef struct BTNode{ char data ;struct BTNode *Lchild , *Rchild ;}BTNode ;BTNode *Create_BTree(void) /* 建立链式二叉树，返回指向根结点的指针变量建立链式二叉树，返回指向根结点的指针变量 */{ BTNode *T , *p , *s[MAX_NODE] ; char ch ; int i , j ;while (1){ scanf(“%d”, &i) ;if (i==0) break ; /* 以编号以编号0作为输入结束作为输入结束 */else { ch=getchar() ;数据结构严蔚敏 p=(BTNode *)malloc(sizeof(BTNode)) ; p–>data=ch ; p–>Lchild=p–>Rchild=NULL ; s[i]=p ; if (i==1) T=p ; else { j=i/2 ; /* j是是i的双亲结点编号的双亲结点编号 */ if (i%2==0) s[j]->Lchild=p ; else s[j]->Rchild=p ; } }}return(T) ;}数据结构严蔚敏⑵⑵ 按先序遍历方式建立按先序遍历方式建立 对一棵二叉树进行对一棵二叉树进行“扩充扩充”，就可以得到有该二叉，就可以得到有该二叉树所扩充的二叉树。

有两棵二叉树树所扩充的二叉树有两棵二叉树T1及其扩充的二叉树及其扩充的二叉树T2如图如图6-10所示图图6-10 二叉树二叉树T1及其扩充及其扩充二叉树二叉树T2ABCDEFG(a) 二叉树二叉树T1(b) T1的扩充的扩充二叉树二叉树T2ABCDEFG????????数据结构严蔚敏 二叉树的扩充方法是：在二叉树中结点的每一个空二叉树的扩充方法是：在二叉树中结点的每一个空链域处增加一个扩充的结点链域处增加一个扩充的结点(总是叶子结点，用方框总是叶子结点，用方框“□”表示表示)对于二叉树的结点值：对于二叉树的结点值：◆◆ 是是char类型：扩充结点值为类型：扩充结点值为“？？”；；◆◆ 是是int类型：扩充结点值为类型：扩充结点值为0或或-1；； 下面的算法是二叉树的前序创建的递归算法，读入下面的算法是二叉树的前序创建的递归算法，读入一棵二叉树对应的扩充二叉树的前序遍历的结点值序列一棵二叉树对应的扩充二叉树的前序遍历的结点值序列每读入一个结点值就进行分析：每读入一个结点值就进行分析：◆◆ 若是扩充结点值：令根指针为若是扩充结点值：令根指针为NULL；；◆◆ 若是若是(正常正常)结点值：动态地为根指针分配一个结结点值：动态地为根指针分配一个结点，将该值赋给根结点，然后递归地创建根的左子点，将该值赋给根结点，然后递归地创建根的左子树和右子树。

树和右子树数据结构严蔚敏算法实现算法实现：：#define NULLKY ‘?’#define MAX_NODE 50typedef struct BTNode{ char data ;struct BTNode *Lchild , *Rchild ;}BTNode ;BTNode *Preorder_Create_BTree(BTNode *T) /* 建立链式二叉树，返回指向根结点的指针变量建立链式二叉树，返回指向根结点的指针变量 */{ char ch ; ch=getchar() ; getchar(); if (ch==NULLKY) { T=NULL; return(T) ; }数据结构严蔚敏else{ T=(BTNode *)malloc(sizeof(BTNode)) ;T–>data=ch ;Preorder_Create_BTree(T->Lchild) ;Preorder_Create_BTree(T->Rchild) ;return(T) ; }} 当希望创建图当希望创建图6-10(a)所示的二叉树时，输入的字符所示的二叉树时，输入的字符序列应当是：序列应当是：ABD??E?G??CF???数据结构严蔚敏2 求二叉树的叶子结点数求二叉树的叶子结点数 可以直接利用先序遍历二叉树算法求二叉树的叶子可以直接利用先序遍历二叉树算法求二叉树的叶子结点数。

只要将先序遍历二叉树算法中结点数只要将先序遍历二叉树算法中vist()函数简单地函数简单地进行修改就可以进行修改就可以算法实现算法实现：：#define MAX_NODE 50int search_leaves( BTNode *T){ BTNode *Stack[MAX_NODE] ,*p=T;int top=0, num=0;if (T!=NULL)数据结构严蔚敏{ stack[++top]=p ; while (top>0) { p=stack[top--] ; if (p->Lchild==NULL&&p->Rchild==NULL) num++ ; if (p->Rchild!=NULL ) stack[++top]=p->Rchild; if (p->Lchild!=NULL ) stack[++top]=p->Lchild; }}return(num) ;}数据结构严蔚敏3 求二叉树的深度求二叉树的深度 利用层次遍历算法可以直接求得二叉树的深度。

利用层次遍历算法可以直接求得二叉树的深度算法实现算法实现：：#define MAX_NODE 50int search_depth( BTNode *T){ BTNode *Stack[MAX_NODE] ,*p=T;int front=0 , rear=0, depth=0, level ;/* level总是指向访问层的最后一个结点在队列的位置总是指向访问层的最后一个结点在队列的位置 */if (T!=NULL){ Queue[++rear]=p; /* 根结点入队根结点入队 */level=rear ; /* 根是第根是第1层的最后一个节点层的最后一个节点 */数据结构严蔚敏while (frontLchild!=NULL) Queue[++rear]=p; /* 左结点入队左结点入队 */ if (p->Rchild!=NULL) Queue[++rear]=p; /* 左结点入队左结点入队 */ if (front==level) /* 正访问的是当前层的最后一个结点正访问的是当前层的最后一个结点 */ { depth++ ; level=rear ; } }}}数据结构严蔚敏 遍历二叉树是按一定的规则将树中的结点排列成一遍历二叉树是按一定的规则将树中的结点排列成一个线性序列个线性序列，即是对非线性结构的线性化操作。

如何找，即是对非线性结构的线性化操作如何找到到遍历过程中动态得到遍历过程中动态得到的每个结点的直接前驱和直接后的每个结点的直接前驱和直接后继继( (第一个和最后一个除外第一个和最后一个除外)?)?如何保存这些信息如何保存这些信息? ? 设一棵二叉树有设一棵二叉树有n个结点个结点，则有，则有n-1条边条边(指针连线指针连线) ，， 而而n个结点共有个结点共有2n个指针域个指针域(Lchild和和Rchild) ，显然，显然有有n+1个空闲指针域个空闲指针域未用未用则可以利用这些则可以利用这些空闲的指针空闲的指针域来存放结点的域来存放结点的直接前驱和直接后继信息直接前驱和直接后继信息对结点的指针域做如下规定对结点的指针域做如下规定：： 6.4 线索树线索树数据结构严蔚敏◆◆ 若结点有左孩子，则若结点有左孩子，则Lchild指向其左孩子，否则，指向其左孩子，否则，指向其直接前驱；指向其直接前驱；◆◆ 若结点有右孩子若结点有右孩子，，则则Rchild指向其右孩子指向其右孩子，否则，，否则，指向其直接后继；指向其直接后继；为避免混淆为避免混淆, ,对结点结构加以改进，增加两个标志域，对结点结构加以改进，增加两个标志域，如图如图6-10所示。

所示Lchild Ltag data Rchild Rtag图图6-10 线索二叉树的结点结构线索二叉树的结点结构0：Lchild域指示结点的左孩子域指示结点的左孩子1 1：：Lchild域指示结点的前驱域指示结点的前驱Ltag=0 0：：Rchild域指示结点的右孩子域指示结点的右孩子1 1：：Rchild域指示结点的后继域指示结点的后继Rtag=数据结构严蔚敏 用这种结点结构构成的二叉树的存储结构；叫做线用这种结点结构构成的二叉树的存储结构；叫做线索链表；指向结点前驱和后继的指针叫做线索；按照某索链表；指向结点前驱和后继的指针叫做线索；按照某种次序遍历，加上线索的二叉树称之为线索二叉树种次序遍历，加上线索的二叉树称之为线索二叉树线索二叉树的结点结构与示例线索二叉树的结点结构与示例typedef struct BiThrNode{ ElemType data;struct BiTreeNode *Lchild , *Rchild ; int Ltag , Rtag ;}BiThrNode ; 如图如图6-11是二叉树及相应的各种线索树示例。

是二叉树及相应的各种线索树示例数据结构严蔚敏AFHIEGBDC(a) 二叉树二叉树 (b) 先序线索树的逻辑形式先序线索树的逻辑形式 结点序列：结点序列：ABDCEGFHIAFHIEGBDCNIL(d) 后序线索树的逻辑形式后序线索树的逻辑形式 结点序列：结点序列：DBGEHIFCA(c) 中序线索树的逻辑形式中序线索树的逻辑形式 结点序列：结点序列：DBAGECHFIAFHIEGBDCNILNILAFHIEGBDCNIL数据结构严蔚敏 0 A 0 0 B 1 0 C 0⋀ 1 D 1 0 E 1 0 F 0 1 G 1 1 H 1 1 F 1 ⋀(e) 中序线索树的链表结构中序线索树的链表结构图图6-11 线索二叉树及其存储结构线索二叉树及其存储结构说明说明：：画线索二叉树时，画线索二叉树时，实线实线表示指针，指向其左表示指针，指向其左、、右右孩子；孩子；虚线虚线表示线索，指向其直接前驱或直接后继表示线索，指向其直接前驱或直接后继。

索树上进行遍历，只要先找到序列中的第一个索树上进行遍历，只要先找到序列中的第一个结点，然后就可以依次找结点的直接后继结点直到后继结点，然后就可以依次找结点的直接后继结点直到后继为空为止为空为止数据结构严蔚敏 如何索树中找结点的直接后继如何索树中找结点的直接后继? ?以图以图6-11(d) ，，(e)所示的中序线索树为例：所示的中序线索树为例：◆◆ 树中树中所有叶子结点的右链都是所有叶子结点的右链都是线索线索右链直接指右链直接指示了结点的直接后继示了结点的直接后继，如结点，如结点G的直接后继是结点的直接后继是结点E◆◆ 树中树中所有非叶子结点的右链都是所有非叶子结点的右链都是指针指针根据中序遍根据中序遍历的规律，历的规律，非叶子结点的直接后继是遍历其右子树时非叶子结点的直接后继是遍历其右子树时访问的第一个结点访问的第一个结点，即右子树中最左下的，即右子树中最左下的( (叶子叶子) )结点如结点如结点C的直接后继的直接后继：沿右指针找到右子树的根结点：沿右指针找到右子树的根结点F，然后沿左链往下直到，然后沿左链往下直到Ltag=1的结点即为的结点即为C的直接后的直接后继结点继结点H。

数据结构严蔚敏 如何索树中找结点的直接前驱如何索树中找结点的直接前驱? ?若若结点的结点的Ltag=1，则左链是线索，指示其直接前驱；否则，遍历，则左链是线索，指示其直接前驱；否则，遍历左子树时访问的最后一个结点左子树时访问的最后一个结点( (即沿左子树中最右往下即沿左子树中最右往下的结点的结点) ) 为其为其直接前驱结点直接前驱结点 对于后序遍历的线索树中找结点的直接后继比较复对于后序遍历的线索树中找结点的直接后继比较复杂，可分以下三种情况杂，可分以下三种情况：： ◆◆ 若若结点是二叉树的根结点结点是二叉树的根结点：其：其直接后继为空直接后继为空；； ◆◆ 若若结点是其父结点的左孩子或右孩子且其父结点结点是其父结点的左孩子或右孩子且其父结点没有右子树没有右子树：：直接后继为其直接后继为其父父结点结点；； ◆◆ 若若结点是其父结点的左孩子且其父结点有右子树结点是其父结点的左孩子且其父结点有右子树：：直接后继是对其直接后继是对其父父结点的右子树按后序遍历的第一个结点的右子树按后序遍历的第一个结点结点数据结构严蔚敏6.4.1 线索化二叉树线索化二叉树 二叉树的线索化二叉树的线索化指的是依照某种遍历次序使二叉树指的是依照某种遍历次序使二叉树成为线索二叉树的过程。

成为线索二叉树的过程 线索化的过程就是线索化的过程就是在遍历过程中修改空指针使其指向在遍历过程中修改空指针使其指向直接前驱或直接后继直接前驱或直接后继的过程 仿照线性表的存储结构，在二叉树的线索链表上也添仿照线性表的存储结构，在二叉树的线索链表上也添加一个头结点加一个头结点head，头结点的指针域的安排是：，头结点的指针域的安排是： ◆◆ Lchild域：指向二叉树的根结点；域：指向二叉树的根结点； ◆◆ Rchild域：指向中序遍历时的最后一个结点；域：指向中序遍历时的最后一个结点； ◆◆ 二叉树中序序列中的二叉树中序序列中的第一个结点第一个结点Lchild指针域指针域和和最后一个结点最后一个结点Rchild指针域指针域均指向头结点均指向头结点head数据结构严蔚敏 如同为二叉树建立了一个双向线索链表，对一棵线如同为二叉树建立了一个双向线索链表，对一棵线索二叉树既可从头结点也可从最后一个结点开始按寻找索二叉树既可从头结点也可从最后一个结点开始按寻找直接后继进行遍历显然，这种遍历不需要堆栈，如图直接后继进行遍历显然，这种遍历不需要堆栈，如图6-12所示所示结点类型定义结点类型定义#define MAX_NODE 50typedef enmu{Link , Thread} PointerTag ;/* Link=0表示指针，表示指针， Thread=1表示线索表示线索 */typedef struct BiThrNode{ ElemType data;struct BiTreeNode *Lchild , *Rchild ; PointerTag Ltag , Rtag ;}BiThrNode;数据结构严蔚敏(a) 二叉树二叉树(b) 中序线索树的逻辑形式中序线索树的逻辑形式AFHIEGBDCNILNILAFHIEGBDC图图6-12 中序线索二叉树及其存储结构中序线索二叉树及其存储结构(c) 中序线索二叉链表 0 A 0 0 B 1 0 C 0 1 D 1 0 E 1 0 F 0 1 G 1 1 H 1 1 F 1Thrt 0 1head数据结构严蔚敏1 先序线索化二叉树先序线索化二叉树void preorder_Threading(BiThrNode *T) { BiThrNode *stack[MAX_NODE];BiThrNode *last=NULL, *p ;int top=0 ;if (T!=NULL){ stack[++top]=T;while (top>0) { p=stack[top--] ; if (p->Lchild!=NULL) p->Ltag=0 ; else { p->Ltag=1 ; p->Lchild!=last ; } if (last!=NULL) if (last->Rchild!=NULL) last->Rtag=0 ;数据结构严蔚敏 else { last->Rtag=1 ; last->Rchild!=p ; } last=p ; if (p->Rchild!=NULL) stack[++top]=p->Rchild ; if (p->Lchild!=NULL) stack[++top]=p->Lchild ; }Last->Rtag=1; /* 最后一个结点是叶子结点最后一个结点是叶子结点 */}}数据结构严蔚敏2 中序线索化二叉树中序线索化二叉树void inorder_Threading(BiThrNode *T) { BiThrNode *stack[MAX_NODE];BiThrNode *last=NULL, *p=T ;int top=0 ;while (p!=NULL||top>0)if (p!=NULL) { stack[++top]=p; p=p->Lchild; }else{ p=stack[top--] ; if (p->Lchild!=NULL) p->Ltag=0 ; else { p->Ltag=1 ; p->Lchild!=last ; } if (last!=NULL) if (last->Rchild!=NULL) last->Rtag=0 ;数据结构严蔚敏 else { last->Rtag=1 ; last->Rchild!=p ; } last=p ; P=p->Rchild; }last->Rtag=1; /* 最后一个结点是叶子结点最后一个结点是叶子结点 */}}数据结构严蔚敏6.4.2 线索二叉树的遍历线索二叉树的遍历 索二叉树中，由于有线索存在，在某些情况下索二叉树中，由于有线索存在，在某些情况下可以方便地找到指定结点在某种遍历序列中的直接前驱可以方便地找到指定结点在某种遍历序列中的直接前驱或直接后继。

此外，索二叉树上进行某种遍历比在或直接后继此外，索二叉树上进行某种遍历比在一般的二叉树上进行这种遍历要容易得多，不需要设置一般的二叉树上进行这种遍历要容易得多，不需要设置堆栈，且算法十分简洁堆栈，且算法十分简洁数据结构严蔚敏1 先序线索二叉树的先序遍历先序线索二叉树的先序遍历void preorder_Thread_bt(BiThrNode *T) { BiThrNode *p=T ;while (p!=NULL) { visit(p->data) ; if (p->Ltag==0) p=p->Lchild ; else p=p->Rchild}} 数据结构严蔚敏2 中序线索二叉树的中序遍历中序线索二叉树的中序遍历void inorder_Thread_bt(BiThrNode *T) { BiThrNode *p ;if (T!=NULL){ p=T;while (p->Ltag==0 ) p=p->Lchild; /* 寻找最左的结点寻找最左的结点 */while (p!=NULL) { visit(p->data) ; if (p->Rtag==1) p=p->Rchild ; /* 通过右线索找到后继通过右线索找到后继 */ else /* 否则，右子树的最左结点为后继否则，右子树的最左结点为后继 */ { p=p->Rchild ; 数据结构严蔚敏 while (p->Ltag==0 ) p=p->Lchild; } }}}数据结构严蔚敏6.5 树与森林树与森林 本节将讨论树的存储结构、树及森林与二叉树之间本节将讨论树的存储结构、树及森林与二叉树之间的相互转换、树的遍历等。

的相互转换、树的遍历等数据结构严蔚敏6.5.1 树的存储结构树的存储结构 树的存储结构根据应用的不同而不同树的存储结构根据应用的不同而不同1 双亲表示法双亲表示法(顺序存储结构顺序存储结构) 用一组连续的存储空间来存储树的结点用一组连续的存储空间来存储树的结点，，同时在同时在每个结点中附加一个每个结点中附加一个指示器指示器(整数域整数域) ，，用以指示双亲结用以指示双亲结点的位置点的位置(下标值下标值) 数组元素及数组的类型定义如下数组元素及数组的类型定义如下：：#define MAX_SIZE 100typedef struct PTNode{ ElemType data ;int parent ;}PTNode ;数据结构严蔚敏typedef struct{ PTNode Nodes[MAX_SIZE] ;int root; /* 根结点位置根结点位置 */int num ; /* 结点数结点数 */ }Ptree ; 图图6-13所示是一棵树及其双亲所示是一棵树及其双亲表示的存储结构表示的存储结构。

这种存储结构利这种存储结构利用了任一结点的父结点唯一的性质用了任一结点的父结点唯一的性质可以方便地直接找到可以方便地直接找到任一结点的父任一结点的父结点结点，，但求结点的子结点时需要扫但求结点的子结点时需要扫描整个数组描整个数组FGHIRABCDE图图6-13 树的双亲存储结构树的双亲存储结构R -10A 01B 02C 03D 14E 15F 36G 67H 68I 69数据结构严蔚敏2 孩子链表表示法孩子链表表示法 树中每个结点有多个指针域，每个指针指向其一棵树中每个结点有多个指针域，每个指针指向其一棵子树的根结点子树的根结点有两种结点结构两种结点结构⑴⑴ 定长结点结构定长结点结构 指针域的数目就是树的度指针域的数目就是树的度 其特点是其特点是：链表结构简单，但指针域的浪费明显：链表结构简单，但指针域的浪费明显结点结构如图结点结构如图6-14(a) 所示所示在一棵有在一棵有n个结点，度为个结点，度为k的树中必有的树中必有n(k-1)+1空指针域空指针域⑵⑵ 不定长结点结构不定长结点结构 树中每个结点的指针域数量不同，是该结点的度，树中每个结点的指针域数量不同，是该结点的度，如图如图6-14(b) 所示。

没有多余的指针域，但操作不便没有多余的指针域，但操作不便数据结构严蔚敏图图6-14 孩子表示法的结点结构孩子表示法的结点结构data child1 child2 ⋯ childn(a) 定长结点结构定长结点结构(b) 不不定长结点结构定长结点结构data k child1 child2 ⋯ childk⑶⑶ 复合链表结构复合链表结构 对于树中的每个结点，其孩子结点用带头结点的单对于树中的每个结点，其孩子结点用带头结点的单链表表示，表结点和头结点的结构如图链表表示，表结点和头结点的结构如图6-15所示所示 n个结点的树有个结点的树有n个个(孩子孩子)单链表单链表(叶子结点的孩子链叶子结点的孩子链表为空表为空)，而，而n个头结点又组成一个线性表且以顺序存储个头结点又组成一个线性表且以顺序存储结构表示结构表示data firstchild(a) 头结点头结点childno next(b) 表结点表结点图图6-15 孩子链表结点结构孩子链表结点结构数据结构严蔚敏数据结构类型定义如下：数据结构类型定义如下：#define MAX_NODE 100typedef struct listnode{ int childno ; /* 孩子结点编号孩子结点编号 */struct listno *next ;}CTNode; /* 表结点结构表结点结构 */typedef struct{ ElemType data ;CTNode *firstchild ;}HNode; /* 头结点结构头结点结构 */数据结构严蔚敏typedef struct{ HNode nodes[MAX_NODE] ;int root; /* 根结点位置根结点位置 */int num ; /* 结点数结点数 */}CLinkList; /* 头结点结构头结点结构 */ 图图6-13所示的树所示的树T的孩子链表表示的存储结构如图的孩子链表表示的存储结构如图6-16所示。

所示数据结构严蔚敏nodes789 ⋀ 35 ⋀ 012 ⋀ 6 ⋀ 0123456789MAX_NODE-1rootnumA B ⋀ C D ⋀ E ⋀F G ⋀H ⋀ I ⋀┇┇ ┇ ┇ R 49图图6-16 图图6-13的树的树T的孩子链表存储结构的孩子链表存储结构数据结构严蔚敏3 孩子兄弟表示法孩子兄弟表示法(二叉树表示法二叉树表示法) 以二叉链表作为树的存储结构，其结点形式如图以二叉链表作为树的存储结构，其结点形式如图6-17(a)所示所示 两个指针域：分别指向结点的第一个子结点和下一两个指针域：分别指向结点的第一个子结点和下一个兄弟结点结点类型定义如下：个兄弟结点结点类型定义如下：typedef struct CSnode{ ElemType data ;struct CSnode *firstchild, *nextsibing ;}CSNode; 图图6-17(b)所示树的孩子兄弟表示的存储结构如图所示树的孩子兄弟表示的存储结构如图6-17(c)。

数据结构严蔚敏图图6-17 树及孩子兄弟存储结构树及孩子兄弟存储结构(b) 树树 FGRABCDE(c) 孩子兄弟存储结构孩子兄弟存储结构 R ⋀ A⋀ D C ⋀⋀ G⋀ B⋀ F ⋀⋀ E ⋀孩子结点孩子结点兄弟结点兄弟结点firstchild data nextsibing(a) 结点结构结点结构数据结构严蔚敏6.5.2 森林与二叉树的转换森林与二叉树的转换 由于二叉树和树都可用二叉链表作为存储结构，对由于二叉树和树都可用二叉链表作为存储结构，对比各自的结点结构可以看出，以二叉链表作为媒介可以比各自的结点结构可以看出，以二叉链表作为媒介可以导出树和二叉树之间的一个对应关系导出树和二叉树之间的一个对应关系◆◆ 从物理结构来看，树和二叉树的二叉链表是相同从物理结构来看，树和二叉树的二叉链表是相同的，只是对指针的逻辑解释不同而已的，只是对指针的逻辑解释不同而已 ◆◆ 从树的二叉链表表示的定义可知，任何一棵和树从树的二叉链表表示的定义可知，任何一棵和树对应的二叉树，其右子树一定为空对应的二叉树，其右子树一定为空 图图6-18直观地展示了树和二叉树之间的对应关系。

直观地展示了树和二叉树之间的对应关系数据结构严蔚敏图图6-18 树与二叉树的对应关系树与二叉树的对应关系二叉树二叉树 CERADB R ⋀ A⋀ D ⋀⋀ C ⋀ B⋀ E ⋀ 树树 RABCDE对应关系对应关系 R ⋀ A⋀ D ⋀⋀ C ⋀ B⋀ E ⋀⋀ C ⋀ B⋀ E ⋀ R A ⋀ D ⋀存储存储解释解释存储存储解释解释数据结构严蔚敏1 树转换成二叉树树转换成二叉树 对于一般的树，可以方便地转换成一棵唯一的二叉对于一般的树，可以方便地转换成一棵唯一的二叉树与之对应将树转换成二叉树在树与之对应将树转换成二叉树在“孩子兄弟表示法孩子兄弟表示法”中已给出，其详细步骤是：中已给出，其详细步骤是：⑴⑴ 加虚线加虚线在树的每层按从在树的每层按从“左至右左至右”的顺序在兄的顺序在兄弟结点之间加虚线相连弟结点之间加虚线相连⑵⑵ 去连线去连线除最左的第一个子结点外，父结点与所除最左的第一个子结点外，父结点与所有其它子结点的连线都去掉有其它子结点的连线都去掉⑶⑶ 旋转旋转将树顺时针旋转将树顺时针旋转450，原有的实线左斜。

原有的实线左斜⑷⑷ 整型整型将旋转后树中的所有虚线改为实线，并向将旋转后树中的所有虚线改为实线，并向右斜该转换过程如图右斜该转换过程如图6-19所示数据结构严蔚敏 这样转换后的二叉树的特点是这样转换后的二叉树的特点是：： ◆◆ 二叉树的二叉树的根结点没有右子树根结点没有右子树，只有左，只有左子树；子树； ◆◆ 左子结点仍然是原来树中相应结点的左子结点仍然是原来树中相应结点的左子结点，而所有沿右链往下的右子结点左子结点，而所有沿右链往下的右子结点均是原来树中该结点的兄弟结点均是原来树中该结点的兄弟结点图图6-19 树向二叉树的转换过程树向二叉树的转换过程(a) 一般的树一般的树 FGRABCDEFGRABCDE(b) 加虚线加虚线，，去连线后去连线后 (C) 转换后的二叉树转换后的二叉树FGRACDBE数据结构严蔚敏2 二叉树转换成树二叉树转换成树 对于一棵转换后的二叉树，如何还原成原来的树对于一棵转换后的二叉树，如何还原成原来的树? 其步骤是：其步骤是：⑴⑴ 加虚线加虚线若某结点若某结点i是其父结点的左子树的根结点，是其父结点的左子树的根结点，则将该结点则将该结点i的右子结点以及沿右子链不断地搜索所的右子结点以及沿右子链不断地搜索所有的右子结点，将所有这些右子结点与有的右子结点，将所有这些右子结点与i结点的父结结点的父结点之间加虚线相连，点之间加虚线相连，如图如图6-20(a)所示所示。

⑵⑵ 去连线去连线去掉二叉树中所有父结点与其右子结点去掉二叉树中所有父结点与其右子结点之间的连线，之间的连线，如图如图6-20(b)所示所示⑶⑶ 规整化规整化将图中各结点按层次排列且将所有的虚将图中各结点按层次排列且将所有的虚线变成实线，线变成实线，如图如图6-20(c)所示数据结构严蔚敏图图6-20 二叉树向树的转换过程二叉树向树的转换过程(C) 还原后的树还原后的树FGRABCDE(b) 去连线后去连线后 (a) 加虚线后加虚线后 FGRACDBECFGRADBE数据结构严蔚敏3 森林转换成二叉树森林转换成二叉树 当一般的树转换成二叉树后，二叉树的右子树必为当一般的树转换成二叉树后，二叉树的右子树必为空空若把森林中的第二棵树若把森林中的第二棵树( (转换成二叉树后转换成二叉树后) )的根结点的根结点作为第一棵树作为第一棵树(二叉树二叉树)的根结点的兄弟结点，则可导出的根结点的兄弟结点，则可导出森林转换成二叉树的转换算法如下：森林转换成二叉树的转换算法如下： 设设F={T1, T2,⋯ ⋯,Tn}是森林，则按以下规则可转换成是森林，则按以下规则可转换成一棵二叉树一棵二叉树B=(root，，LB，，RB)①① 若若n=0，则，则B是空树是空树。

②② 若若n>0，则二叉树，则二叉树B的根是森林的根是森林T1的根的根root(T1)，，B的左子树的左子树LB是是B(T11,T12, ⋯ ⋯,T1m) ，其中，其中T11,T12, ⋯ ⋯,T1m是是T1的子树的子树(转换后转换后)，而其右子树，而其右子树RB是从森林是从森林F’={T2, T3,⋯ ⋯,Tn}转换而成的二叉树转换而成的二叉树数据结构严蔚敏转换步骤转换步骤： ①① 将将F={T1, T2,⋯ ⋯,Tn} 中的每棵树转换成二叉树中的每棵树转换成二叉树②② 按给出的森林中树的次序，从最后一棵二叉树开按给出的森林中树的次序，从最后一棵二叉树开始，每棵二叉树作为前一棵二叉树的根结点的右子始，每棵二叉树作为前一棵二叉树的根结点的右子树，依次类推，则第一棵树的根结点就是转换后生树，依次类推，则第一棵树的根结点就是转换后生成的二叉树的根结点，成的二叉树的根结点，如图如图6-21所示所示ACBDGMLHK(a) 森林森林图图6-21 森林转换成二叉树的过程森林转换成二叉树的过程(b) 森林中每棵树森林中每棵树 对应的二叉树对应的二叉树ABCDGLKHM(c) 森林对应的二叉树森林对应的二叉树ABCDGLKHM数据结构严蔚敏4 二叉树转换成森林二叉树转换成森林 若若B=(root，，LB，，RB)是一棵二叉树，则可以将其是一棵二叉树，则可以将其转换成由若干棵树构成的森林：转换成由若干棵树构成的森林：F={T1, T2,⋯ ⋯,Tn} 。

转换算法转换算法：：①① 若若B是空树，则是空树，则F为空为空②② 若若B非空，则非空，则F中第一棵树中第一棵树T1的根的根root(T1)就是二就是二叉树的根叉树的根root，， T1中根结点的子森林中根结点的子森林F1是由树是由树B的左的左子树子树LB转换而成的森林转换而成的森林；；F中除中除T1外其余树组成的外其余树组成的的森林的森林F’={T2, T3,⋯ ⋯,Tn} 是由是由B右子树右子树RB转换得到的转换得到的森林森林 上述转换规则是递归的上述转换规则是递归的，，可以写出其递归算法以可以写出其递归算法以下给出具体的还原步骤下给出具体的还原步骤数据结构严蔚敏①① 去连线去连线将二叉树将二叉树B的根结点与其右子结点以及的根结点与其右子结点以及沿右子结点链方向的所有右子结点的连线全部去掉，沿右子结点链方向的所有右子结点的连线全部去掉，得到若干棵孤立的二叉树，每一棵就是原来森林得到若干棵孤立的二叉树，每一棵就是原来森林F中中的树依次对应的二叉树，的树依次对应的二叉树，如图如图6-22(b)所示所示②② 二叉树的还原二叉树的还原将各棵孤立的二叉树按二叉树还将各棵孤立的二叉树按二叉树还原为树的方法还原成一般的树，原为树的方法还原成一般的树，如图如图6- 22(c)所示所示。

图图6-22 二叉树还原成森林的过程二叉树还原成森林的过程ACBDMGLHK(c) 还原成森林还原成森林(a) 二叉树二叉树ABCDGLKHM(b) 去连线后去连线后ABCDMGLKH数据结构严蔚敏6.5.3 树和森林的遍历树和森林的遍历1 树的遍历树的遍历 由树结构的定义可知，树的遍历有二种方法由树结构的定义可知，树的遍历有二种方法⑴⑴ 先序遍历先序遍历：先访问根结点，然后：先访问根结点，然后依次先序遍历依次先序遍历完完每棵子树每棵子树如图如图6-23的树，先序遍历的次序是：的树，先序遍历的次序是：ABCDEFGIJHK⑵⑵ 后序遍历后序遍历：先：先依次后序遍历完依次后序遍历完每棵子树，然后访每棵子树，然后访问根结点问根结点如图如图6-23的树，后序遍历的次序是：的树，后序遍历的次序是：CDBFGIJHEKA数据结构严蔚敏说明说明：◆◆ 树的树的先序遍历先序遍历实质上与将树转换成二叉树实质上与将树转换成二叉树后对二叉树的后对二叉树的先序遍历先序遍历相同◆◆ 树的树的后序遍历后序遍历实质上与将树转换成二叉树实质上与将树转换成二叉树后对二叉树的后对二叉树的中序遍历中序遍历相同。

相同ABDCKGJIFHE图图6-23 树树数据结构严蔚敏2 森林的遍历森林的遍历 设设F={T1, T2,⋯ ⋯,Tn}是森林，对是森林，对F的遍历有二种方法的遍历有二种方法⑴⑴ 先序遍历先序遍历：按：按先序遍历先序遍历树的方式树的方式依次依次遍历遍历F中的中的每棵树⑵⑵ 中序遍历中序遍历：按：按后序遍历后序遍历树的方式树的方式依次依次遍历遍历F中的中的每棵树数据结构严蔚敏6.6 赫夫曼树及其应用赫夫曼树及其应用 赫夫曼赫夫曼(Huffman)树又称最优树，是一类带权路径树又称最优树，是一类带权路径长度最短的树，有着广泛的应用长度最短的树，有着广泛的应用数据结构严蔚敏6.6.1 最优二叉树最优二叉树(Huffman树树)1 基本概念基本概念① ① 结点路径结点路径：从树中一个结点到另一个结点的之间：从树中一个结点到另一个结点的之间的分支构成这两个结点之间的路径的分支构成这两个结点之间的路径② ② 路径长度路径长度：结点路径上的分支数目称为路径长度：结点路径上的分支数目称为路径长度③ ③ 树的路径长度树的路径长度：从树根到每一个结点的路径长度：从树根到每一个结点的路径长度之和之和。

例图例图6-23的树的树A到到F ：结点路径：结点路径 AEF ；路径长；路径长度度( (即边的数目即边的数目) ) 2 ；树的路径长度：；树的路径长度：3 3 1+5 2+2 3=19 数据结构严蔚敏④④ 结点的带权路径长度结点的带权路径长度：从该结点的到树的根结点：从该结点的到树的根结点之间的路径长度与结点的权之间的路径长度与结点的权( (值值) )的乘积的乘积权权( (值值) )：各种：各种开销开销、、代价代价、、频度频度等的抽象称呼等的抽象称呼⑤⑤ 树的带权路径长度树的带权路径长度：树中：树中所有叶子结点所有叶子结点的带权路的带权路径长度之和，记做：径长度之和，记做： WPL=w1 l1+w2 l2+⋯ ⋯+wn ln=∑wi li (i=1,2,⋯ ⋯,n)其中：其中：n为叶子结点的个数为叶子结点的个数；；wi为第为第i个结点的权值个结点的权值；； li为第为第i个结点的路径长度个结点的路径长度⑥⑥ Huffman树树：具有：具有n个叶子结点个叶子结点(每个结点的权值每个结点的权值为为wi) 的二叉树不止一棵，但在所有的这些二叉树中，的二叉树不止一棵，但在所有的这些二叉树中，必定存在一棵必定存在一棵WPL值最小值最小的树，称这棵树为的树，称这棵树为Huffman树树(或称最优树或称最优树) 。

数据结构严蔚敏 在许多判定问题时，利用在许多判定问题时，利用Huffman树可以得到最佳树可以得到最佳判断算法判断算法 如图如图6-24是权值分别为是权值分别为2、、3、、6、、7，具有，具有4个叶子结个叶子结点的二叉树，它们的带权路径长度分别为点的二叉树，它们的带权路径长度分别为：：(a) WPL=2 2+3 2+6 2+7 2=36 ；；(b) WPL=2 1+3 2+6 3+7 3=47 ；；(c) WPL=7 1+6 2+2 3+3 3=34 其中其中(c)的的 WPL值最小，可以证明是值最小，可以证明是Huffman树数据结构严蔚敏236736726723(a)(b)(c)图图6-24 具有相同叶子结点，不同带权路径长度的二叉树具有相同叶子结点，不同带权路径长度的二叉树2 Huffman树的构造树的构造①① 根据根据n个权值个权值{w1, w2, ⋯ ⋯,wn}，构造成，构造成n棵二叉树的棵二叉树的集合集合F={T1, T2, ⋯ ⋯,Tn}，其中每棵二叉树只有一个权值，其中每棵二叉树只有一个权值为为wi的根结点，没有左、右子树；的根结点，没有左、右子树；数据结构严蔚敏② ② 在在F中中选取两棵根结点权值最小选取两棵根结点权值最小的树作为左的树作为左、、右右子树构造一棵新的二叉树，且新的二叉树根结点权子树构造一棵新的二叉树，且新的二叉树根结点权值为其左值为其左、、右子树根结点的权值之和；右子树根结点的权值之和；③ ③ 在在F中删除这两棵树，同时将新得到的树加入中删除这两棵树，同时将新得到的树加入F中；中；④④ 重复重复②②、、③③，直到，直到F只含一颗树为止。

只含一颗树为止 构造构造Huffman树时树时，，为了规范为了规范，，规定规定F={T1,T2, ⋯ ⋯,Tn}中权值小的二叉树作为新构造的二叉树的左子树中权值小的二叉树作为新构造的二叉树的左子树，，权值大的二叉树作为新构造的二叉树的右子树权值大的二叉树作为新构造的二叉树的右子树；在取值；在取值相等时，相等时，深度小的二叉树作为新构造的二叉树的左子树深度小的二叉树作为新构造的二叉树的左子树，，深度大的二叉树作为新构造的二叉树的右子树深度大的二叉树作为新构造的二叉树的右子树 数据结构严蔚敏 图图6-25是权值集合是权值集合W={8, 3, 4, 6, 5, 5}构造构造Huffman树的过程树的过程所构造的所构造的Huffman树的树的WPL是是：： WPL=6 2+3 3+4 3+8 2+5 3+5 3 =79345568第一步5568第二步34768第三步34755108第四步5510634713第六步1111100000855101863471331图图6-25 Huffman树的构造过程树的构造过程第五步8551018634713数据结构严蔚敏6.6.2 赫夫曼编码及其算法赫夫曼编码及其算法1 Huffman编码编码 在电报收发等数据通讯中在电报收发等数据通讯中，，常需要将传送的文字转常需要将传送的文字转换成由二进制字符换成由二进制字符0、、1组成的字符串来传输组成的字符串来传输。

为了使收为了使收发的速度提高发的速度提高，，就要求电文就要求电文编码要尽可能地短编码要尽可能地短此外，要设计要设计长短不等长短不等的编码，还必须保证的编码，还必须保证任意字符的编码都任意字符的编码都不是另一个字符编码的前缀不是另一个字符编码的前缀，这种编码称为，这种编码称为前缀编码前缀编码 Huffman树可以用来构造编码长度不等且译码不产树可以用来构造编码长度不等且译码不产生二义性的编码生二义性的编码 设电文中的字符集设电文中的字符集C={c1,c2, ⋯ ⋯,ci, ⋯ ⋯,cn}，各个字符出，各个字符出现的次数或频度集现的次数或频度集W={w1,w2, ⋯ ⋯,wi, ⋯ ⋯,wn}数据结构严蔚敏Huffman编码方法编码方法 以以字符集字符集C作为叶子结点作为叶子结点，，次数或频度集次数或频度集W作为结作为结点的权值点的权值来构造来构造 Huffman树树规定Huffman树中左分支树中左分支代表代表“0”，右分支代表，右分支代表“1” 从根结点到每个叶子结点所经历的路径分支上的从根结点到每个叶子结点所经历的路径分支上的“0”或或“1”所组成的字符串所组成的字符串，，为该结点所对应的编码为该结点所对应的编码，，称之为称之为Huffman编码编码。

由于每个字符都是叶子结点，不可能出现在根结点由于每个字符都是叶子结点，不可能出现在根结点到其它字符结点的路径上，所以一个字符的到其它字符结点的路径上，所以一个字符的Huffman编编码不可能是另一个字符的码不可能是另一个字符的Huffman编码的前缀编码的前缀数据结构严蔚敏 若字符集若字符集C={a, b, c, d, e, f}所对应的权值集合为所对应的权值集合为W={8, 3, 4, 6, 5, 5}，如图，如图6-25所示所示，则字符，则字符a,b, c,d, e,f所所对应的对应的Huffman编码分别是编码分别是：：10，，010，，011，，00 ，，110，，1112 Huffman编码算法实现编码算法实现(1) 数据结构设计数据结构设计 Huffman树中没有度为树中没有度为1的结点棵有的结点棵有n个叶子结点的个叶子结点的Huffman树共有树共有2n-1个结点个结点，则可存储在大小为，则可存储在大小为2n-1的的一维数组中实现编码的结点结构如图一维数组中实现编码的结点结构如图6-26所示所示原因原因：：◆◆ 求编码需从叶子结点出发走一条从叶子到根的路求编码需从叶子结点出发走一条从叶子到根的路径；径；数据结构严蔚敏◆◆ 译码需从根结点出发走一条到叶子结点的路径。

译码需从根结点出发走一条到叶子结点的路径 结点类型定义结点类型定义：：#define MAX_NODE 200 /* Max_Node>2n-1 */ typedef struct{ unsigned int Weight ; /* 权值域权值域 */unsinged int Parent , Lchild , Rchild ;} HTNode ;Weight Parent Lchild RchildWeight：权值域； Parent：双亲结点下标Lchild, Rchild：分别标识左、右子树的下标图图6-26 Huffman编码的结点结构编码的结点结构数据结构严蔚敏(2) Huffman树的生成树的生成算法实现算法实现void Create_Huffman(unsigned n, HTNode HT[ ], unsigned m) /* 创建一棵叶子结点数为创建一棵叶子结点数为n的的Huffman树树 */{ unsigned int w ; int k , j ;for (k=1 ; k

数据结构严蔚敏(3) Huffman编码算法编码算法 根据出现频度根据出现频度( (权值权值) )Weight，，对叶子结点的对叶子结点的Huffman编码有两种方式编码有两种方式：：① ① 从叶子结点到根逆向处理，求得每个叶子结点对从叶子结点到根逆向处理，求得每个叶子结点对应字符的应字符的Huffman编码② ② 从根结点开始遍历整棵二叉树，求得每个叶子结从根结点开始遍历整棵二叉树，求得每个叶子结点对应字符的点对应字符的Huffman编码 由由Huffman树的生成知，树的生成知，n个叶子结点的树共有个叶子结点的树共有2n-1个结点，叶子结点存储在数组个结点，叶子结点存储在数组HT中的下标值为中的下标值为1∽∽n①① 编码是叶子结点的编码，只需对数组编码是叶子结点的编码，只需对数组HT[1…n]的的n个权值进行编码；个权值进行编码；②② 每个字符的编码不同，但编码的最大长度是每个字符的编码不同，但编码的最大长度是n数据结构严蔚敏 求编码时先设一个通用的指向字符的指针变量，求求编码时先设一个通用的指向字符的指针变量，求得编码后再复制得编码后再复制算法实现算法实现void Huff_coding(unsigned n , Hnode HT[] , unsigned m) /* m应为应为n+1,编码的最大长度编码的最大长度n加加1 */{ int k , sp ,fp ;char *cd , *HC[m] ;cd=(char *)malloc(m*sizeof(char)) ;/* 动态分配求编码的工作空间动态分配求编码的工作空间 */cd[n]=‘\0’ /* 编码的结束标志编码的结束标志 */for (k=1 ; k

已知一棵树的树边集合为表示树边已知一棵树的树边集合为 { (e,i), (b,e), (b,d), (a,b), (g,j), (c,g), (c,f), (h,l), (c,h), (a,c) } ，用树型表示法，用树型表示法表示该树，并回答下列问题：表示该树，并回答下列问题： ①① 哪个是根结点哪个是根结点? 哪些是叶子结点哪些是叶子结点? 哪个是哪个是g的双的双亲亲? 哪些是哪些是g的祖先的祖先? 哪些是哪些是g的孩子的孩子? 那些是那些是e的子的子孙孙? 哪些是哪些是e的兄弟的兄弟? 哪些是哪些是f的兄弟的兄弟? ②② b和和n的层次各是多少的层次各是多少? 树的深度是多少树的深度是多少? 以结以结点点c为根的子树的深度是多少为根的子树的深度是多少?数据结构严蔚敏⑵⑵ 一棵深度为一棵深度为h的满的满k叉树有如下性质：叉树有如下性质： 第第h层上的层上的结点都是叶子结点，其余各层上每个结点都有结点都是叶子结点，其余各层上每个结点都有k棵非空棵非空子树 如果按层次顺序如果按层次顺序(同层自左至右同层自左至右)从从1开始对全部开始对全部结点编号，问：结点编号，问：① ① 各层的结点数是多少各层的结点数是多少? ?② ② 编号为编号为i的结点的双亲结点的结点的双亲结点(若存在若存在)的编号是多的编号是多少少?③ ③ 编号为编号为i的结点的第的结点的第j个孩子结点个孩子结点(若存在若存在)的编号的编号是多少是多少?④ ④ 编号为编号为i的结点的有右兄弟的条件是什么的结点的有右兄弟的条件是什么? 其右其右兄弟的编号是多少兄弟的编号是多少? 数据结构严蔚敏⑶ ⑶ 设有如图设有如图6-27所示的二叉树。

所示的二叉树①① 分别用顺序存储方法和链接存储方法画出该二分别用顺序存储方法和链接存储方法画出该二叉树的存储结构叉树的存储结构②② 写出该二叉树的先序、中序、后序遍历序列写出该二叉树的先序、中序、后序遍历序列⑷ ⑷ 已知一棵二叉树的先序遍历序列和中序遍历序列已知一棵二叉树的先序遍历序列和中序遍历序列分别为分别为ABDGHCEFI和和GDHBAECIF，请画出这棵二叉，请画出这棵二叉树，然后给出该树的后序遍历序列树，然后给出该树的后序遍历序列⑸ ⑸ 设一棵二叉树的中序遍历序列设一棵二叉树的中序遍历序列和后序遍历序列分别为和后序遍历序列分别为BDCEAFHG和和DECBHGFA ，请画出这棵二叉树，，请画出这棵二叉树，然后给出该树的先序序列然后给出该树的先序序列图图6-27 二叉树二叉树adebfgchkmn数据结构严蔚敏⑹ ⑹ 已知一棵二叉树的中序遍历序列和后序遍历序列已知一棵二叉树的中序遍历序列和后序遍历序列分别为分别为dgbaekchif和和gdbkeihfca，请画出这棵二叉树对，请画出这棵二叉树对应的中序线索树和后序线索树应的中序线索树和后序线索树 ⑺ ⑺ 以二叉链表为存储结构，请分别写出求二叉树的以二叉链表为存储结构，请分别写出求二叉树的结点总数及叶子结点总数的算法。

结点总数及叶子结点总数的算法⑻ ⑻ 设设图图6-27所示的二叉树是森林所示的二叉树是森林F所对应的二叉树，所对应的二叉树，请画出森林请画出森林F⑼⑼ 设有一棵树，如图设有一棵树，如图6-28所示① ① 请分别用双亲表示法请分别用双亲表示法、、孩子表示法孩子表示法、、孩子兄弟孩子兄弟表示法给出该树的存储结构表示法给出该树的存储结构② ② 请给出该树的先序遍历序列和后序遍历序列请给出该树的先序遍历序列和后序遍历序列③ ③ 请将这棵树转换成二叉树请将这棵树转换成二叉树数据结构严蔚敏⑽ ⑽ 设给定权值集合设给定权值集合w={3,5,7,8,11,12} ，请构造关于，请构造关于w的一棵的一棵huffman树，并求其加权路径长度树，并求其加权路径长度WPL ⑾ ⑾ 假设用于通信的电文是由字符集假设用于通信的电文是由字符集{a, b, c, d, e, f, g, h}中的字符构成中的字符构成，， 这这8个字符在电文中出现的概率分别个字符在电文中出现的概率分别为为{0.07, 0.19, 0.02, 0.06, 0.32, 0.03, 0.21, 0.10} ① ① 请画出对应的请画出对应的huffman树树( (按左子树根结点的权按左子树根结点的权小于等于右子树根结点的权的次序构造小于等于右子树根结点的权的次序构造) )。

② ② 求出每个字符的求出每个字符的huffman编码adebfgmh kcn图图6-28 一般的树一般的树数据结构严蔚敏第第7章章 图图 图图(Graph)是一种比线性表和树更为复杂的数据结是一种比线性表和树更为复杂的数据结构 线性结构线性结构：：是研究数据元素之间的一对一关系是研究数据元素之间的一对一关系在这种结构中，除第一个和最后一个元素外，任何一个在这种结构中，除第一个和最后一个元素外，任何一个元素都有唯一的一个直接前驱和直接后继元素都有唯一的一个直接前驱和直接后继 树结构树结构：：是研究数据元素之间的一对多的关系是研究数据元素之间的一对多的关系在这种结构中，每个元素对下在这种结构中，每个元素对下(层层)可以有可以有0个或多个元个或多个元素相联系，对上素相联系，对上(层层)只有唯一的一个元素相关，数据元只有唯一的一个元素相关，数据元素之间有明显的层次关系素之间有明显的层次关系数据结构严蔚敏 图结构图结构：：是研究数据元素之间的多对多的关系是研究数据元素之间的多对多的关系在这种结构中，任意两个元素之间可能存在关系即结在这种结构中，任意两个元素之间可能存在关系。

即结点之间的关系可以是任意的，图中任意元素之间都可能点之间的关系可以是任意的，图中任意元素之间都可能相关 图的应用极为广泛，已渗入到诸如语言学、逻辑学、图的应用极为广泛，已渗入到诸如语言学、逻辑学、物理、化学、电讯、计算机科学以及数学的其它分支物理、化学、电讯、计算机科学以及数学的其它分支数据结构严蔚敏7.1 图的基本概念图的基本概念7.1.1 图的定义和术语图的定义和术语 一个图一个图(G)定义为一个偶对定义为一个偶对(V,E) ，记为，记为G=(V,E) 其中：其中： V是是顶点顶点(Vertex)的非空有限集合，记为的非空有限集合，记为V(G)；；E是无序集是无序集V&V的一个子集，记为的一个子集，记为E(G) ，其元素是图的，其元素是图的弧弧(Arc) 将顶点集合为空的图称为空图其形式化定义为：将顶点集合为空的图称为空图其形式化定义为：G=(V ，，E)V={v|v data object}E={| v,w V∧∧p(v,w)}P(v,w)表示从顶点表示从顶点v到顶点到顶点w有一条直接通路有一条直接通路数据结构严蔚敏 弧弧(Arc) ：：表示两个顶点表示两个顶点v和和w之间存在一个关系，之间存在一个关系，用顶点偶对用顶点偶对表示。

通常根据图的顶点偶对将图分表示通常根据图的顶点偶对将图分为有向图和无向图为有向图和无向图 有向图有向图(Digraph)：： 若图若图G的关系集合的关系集合E(G)中，顶中，顶点偶对点偶对的的v和和w之间是之间是有序有序的，称图的，称图G是有向图是有向图 在有向图中，若在有向图中，若  E(G) ，表示从顶点，表示从顶点v到顶点到顶点w有一条有一条弧弧 其中：其中：v称为称为弧尾弧尾(tail)或或始点始点(initial node)，，w称为称为弧头弧头(head)或或终点终点(terminal node) 无向图无向图(Undigraph)：： 若图若图G的关系集合的关系集合E(G)中，中，顶点偶对顶点偶对的的v和和w之间是之间是无序无序的，称图的，称图G是无向图是无向图 数据结构严蔚敏 在无向图中，若在无向图中，若  E(G) ，有，有 E(G) ，，即即E(G)是对称，则用无序对是对称，则用无序对(v,w) 表示表示v和和w之间的一条之间的一条边边(Edge)，因此，因此(v,w) 和和(w,v)代表的是同一条边。

代表的是同一条边例例1：设有有向图：设有有向图G1和无向图和无向图G2，形式化定义分别是：，形式化定义分别是：G1=(V1 ，，E1)V1={a,b,c,d,e}E1={,, ,, ,,,}G2=(V2 ，，E2)V2={a,b,c,d}E2={(a,b), (a,c), (a,d), (b,d), (b,c), (c,d)}它们所对应的图如图它们所对应的图如图7-1所示数据结构严蔚敏 完全无向图完全无向图：：对于无向图，若图中顶点数为对于无向图，若图中顶点数为n ，，用用e表示边的数目，则表示边的数目，则e  [0，，n(n-1)/2] 具有n(n-1)/2条条边的无向图称为完全无向图边的无向图称为完全无向图完全无向图另外的定义是：完全无向图另外的定义是： 对于无向图对于无向图G=(V，，E)，若，若 vi，，vj  V ，当，当vi≠vj时，时，有有(vi ,vj) E，即，即图中任意两个不同的顶点间都有一条无图中任意两个不同的顶点间都有一条无向边向边，这样的无向图称为，这样的无向图称为完全无向图完全无向图。

abcd(b) 无向图无向图G2 图图7-1 图的示例图的示例(a) 有向图有向图G1 acbde数据结构严蔚敏 完全有向图完全有向图：：对于有向图，若图中顶点数为对于有向图，若图中顶点数为n ，，用用e表示弧的数目，则表示弧的数目，则e [0，，n(n-1)] 具有n(n-1)条边条边的有向图称为完全有向图的有向图称为完全有向图完全有向图另外的定义是：完全有向图另外的定义是： 对于有向图对于有向图G=(V，，E)，若，若 vi，，vj V ，当，当vi ≠vj时，时，有有 E∧∧ E ，即，即图中任意两个不同的顶图中任意两个不同的顶点间都有一条弧点间都有一条弧，这样的有向图称为，这样的有向图称为完全有向图完全有向图 有很少边或弧的图（有很少边或弧的图（e

顶点的邻接顶点的邻接(Adjacent)：：对于无向图对于无向图G=(V，，E)，若边，若边(v,w) E，则称顶点，则称顶点v和和w 互为互为邻接点邻接点，即，即v和和w相邻接边相邻接边(v,w)依附依附(incident)与顶点与顶点v和和w 对于有向图对于有向图G=(V ，，E)，若有向弧，若有向弧 E，则称，则称顶点顶点v “邻接到邻接到”顶点顶点w，顶点，顶点w “邻接自邻接自”顶点顶点v ，弧，弧 与顶点与顶点v和和w “相关联相关联” 顶点的度、入度、出度顶点的度、入度、出度：：对于无向图对于无向图G=(V，，E)，，  vi V，图，图G中中依附依附于于vi的边的数目称为顶点的边的数目称为顶点vi的的度度(degree)，记为，记为TD(vi)数据结构严蔚敏 显然，在无向图中，所有顶点度的和是图中边的显然，在无向图中，所有顶点度的和是图中边的2倍 即即 ∑TD(vi)=2e i=1, 2, …, n ，，e为图的边数为图的边数 对有向图对有向图G=(V，，E)，若，若 vi  V ，图，图G中中以以vi作为起作为起点点的有向边的有向边(弧弧)的数目称为顶点的数目称为顶点vi的的出度出度(Outdegree)，，记为记为OD(vi) ；；以以vi作为终点作为终点的有向边的有向边(弧弧)的数目称为顶的数目称为顶点点vi的的入度入度(Indegree)，记为，记为ID(vi) 。

顶点顶点vi的的出度出度与与入入度度之和称为之和称为vi的的度度，记为，记为TD(vi) 即TD(vi)=OD(vi)+ID(vi) 路径路径(Path)、路径长度、回路、路径长度、回路(Cycle) ：：对无对无向图向图G=(V，，E)，若从顶点，若从顶点vi经过若干条边能到达经过若干条边能到达vj，称，称顶点顶点vi和和vj是是连通连通的，又称顶点的，又称顶点vi到到vj有有路径路径 对有向图对有向图G=(V，，E)，从顶点，从顶点vi到到vj有有有向路径有向路径，指，指的是从顶点的是从顶点vi经过若干条有向边经过若干条有向边(弧弧)能到达能到达vj数据结构严蔚敏 或或路径路径是图是图G中连接两顶点之间所经过的顶点序列中连接两顶点之间所经过的顶点序列即即 Path=vi0vi1…vim ，，vij V且且(vij-1, vij) E j=1,2, …,m或或 Path=vi0vi1 …vim ，，vij V且且 E j=1,2, …,m 路径上边或有向边路径上边或有向边(弧弧)的数目称为该的数目称为该路径路径的的长度长度。

在一条路径中，若在一条路径中，若没有重复相同没有重复相同的顶点，该路径称的顶点，该路径称为为简单路径简单路径；第一个顶点和最后一个顶点相同的路径称；第一个顶点和最后一个顶点相同的路径称为为回路回路(环环)；在一个回路中，若除第一个与最后一个顶；在一个回路中，若除第一个与最后一个顶点外，其余顶点不重复出现的回路称为点外，其余顶点不重复出现的回路称为简单回路简单回路(简单环简单环)数据结构严蔚敏 连通图、图的连通分量连通图、图的连通分量：：对无向图对无向图G=(V，，E)，，若若 vi ，，vj  V，，vi和和vj都是连通的，则称图都是连通的，则称图G是是连通图连通图，，否则称为否则称为非连通图非连通图若G是非连通图，则是非连通图，则极大的连通子极大的连通子图图称为称为G的的连通分量连通分量 对有向图对有向图G=(V，，E)，若，若 vi ，，vj  V，都有，都有以以vi为起为起点点，， vj 为终点为终点以及以以及以vj为起点，为起点，vi为终点的有向路径，为终点的有向路径，称图称图G是是强连通图强连通图，否则称为，否则称为非强连通图非强连通图。

若若G是非强是非强连通图，则连通图，则极大的强连通子图极大的强连通子图称为称为G的的强连通分量强连通分量 “极大极大”的含义：指的是对子图再增加图的含义：指的是对子图再增加图G中的其它中的其它顶点，子图就不再连通顶点，子图就不再连通数据结构严蔚敏 生成树、生成森林生成树、生成森林：：一个连通图一个连通图(无向图无向图)的生成的生成树是一个极小连通子图，它树是一个极小连通子图，它含有图中全部含有图中全部n个顶点个顶点和只和只有足以构成一棵树的有足以构成一棵树的n-1条边条边，称为图的，称为图的生成树生成树，如图，如图7-2所示 关于无向图的生成树的几个结论：关于无向图的生成树的几个结论： ◆◆ 一棵有一棵有n个顶点的生成树有且仅有个顶点的生成树有且仅有n-1条边；条边； ◆◆ 如果一个图有如果一个图有n个顶点和小于个顶点和小于n-1条边，则是非连条边，则是非连通图；通图；adbc图图7-2 图图G2的一棵生成树的一棵生成树◆◆ 如果多于如果多于n-1条边，则一定条边，则一定有环；有环； ◆◆ 有有n-1条边的图不一定是生条边的图不一定是生成树数据结构严蔚敏 有向图的有向图的生成森林生成森林是这样一个子图，由若干棵是这样一个子图，由若干棵有向有向树树组成，含有图中全部顶点。

组成，含有图中全部顶点有向树有向树是只有一个顶点的入度为是只有一个顶点的入度为0 ，其余顶点的入度均，其余顶点的入度均为为1的有向图，如图的有向图，如图7-3所示 网网：：每个边每个边(或弧或弧)都附加一个权值的图，称为都附加一个权值的图，称为带权带权图图带权的连通图带权的连通图(包括弱连通的有向图包括弱连通的有向图)称为称为网或网络网或网络网络是工程上常用的一个概念，用来表示一个工程或某网络是工程上常用的一个概念，用来表示一个工程或某种流程，如图种流程，如图7-4所示图图7-3 有向图及其生成森林有向图及其生成森林abcdedce(a) 有向图有向图(b) 生成森林生成森林acbcb354126abcde3图图7-4 带权有向图带权有向图数据结构严蔚敏7.1.2 图的抽象数据类型定义图的抽象数据类型定义 图是一种数据结构图是一种数据结构，，加上一组基本操作就构成了图加上一组基本操作就构成了图的抽象数据类型的抽象数据类型图的抽象数据类型定义如下：图的抽象数据类型定义如下：ADT Graph{数据对象数据对象V：具有相同特性的数据元素的集合：具有相同特性的数据元素的集合，，称为称为顶点集顶点集。

数据关系数据关系R：：R={VR}VR={|| v,w V∧∧p(v,w) ，，表示表示 从从v到到w的弧，的弧，P(v,w)定义了弧定义了弧的信息的信息 }数据结构严蔚敏基本操作基本操作P：： Create_Graph() ：： 图的创建操作图的创建操作初始条件：无初始条件：无 操作结果：生成一个没有顶点的空图操作结果：生成一个没有顶点的空图GGetVex(G, v) ：： 求图中的顶点求图中的顶点v的值初始条件：图初始条件：图G存在，存在，v是图中的一个顶点是图中的一个顶点操作结果：生成一个没有顶点的空图操作结果：生成一个没有顶点的空图G … …… … DFStraver(G,V)：从：从v出发对图出发对图G深度优先遍历深度优先遍历 初始条件：图初始条件：图G存在 操作结果：对图操作结果：对图G深度优先遍历，每个顶点访问深度优先遍历，每个顶点访问且只访问一次且只访问一次数据结构严蔚敏⋯ ⋯ ⋯ ⋯BFStraver(G,V)：从：从v出发对图出发对图G广度优先遍历。

广度优先遍历 初始条件：图初始条件：图G存在 操作结果：对图操作结果：对图G广度优先遍历，每个顶点访问广度优先遍历，每个顶点访问且只访问一次且只访问一次} ADT Graph 详见详见p156~157数据结构严蔚敏7.2 图的存储结构图的存储结构 图的存储结构比较复杂，其复杂性主要表现在：图的存储结构比较复杂，其复杂性主要表现在： ◆ ◆ 任意顶点之间可能存在联系，无法以数据元素任意顶点之间可能存在联系，无法以数据元素在存储区中的物理位置来表示元素之间的关系在存储区中的物理位置来表示元素之间的关系 ◆ ◆ 图中顶点的度不一样，有的可能相差很大，若图中顶点的度不一样，有的可能相差很大，若按度数最大的顶点设计结构，则会浪费很多存储单按度数最大的顶点设计结构，则会浪费很多存储单元，反之按每个顶点自己的度设计不同的结构，又元，反之按每个顶点自己的度设计不同的结构，又会影响操作会影响操作 图的常用的存储结构有：图的常用的存储结构有：邻接矩阵邻接矩阵、、邻接链表邻接链表、、十十字链表字链表、、邻接多重表邻接多重表和和边表边表数据结构严蔚敏7.2.1 邻接矩阵邻接矩阵(数组数组)表示法表示法 基本思想基本思想：：对于有对于有n个顶点的图，用一维数组个顶点的图，用一维数组vexs[n]存储顶点信息，用二维数组存储顶点信息，用二维数组A[n][n]存储顶点之间存储顶点之间关系的信息。

该二维数组称为关系的信息该二维数组称为邻接矩阵邻接矩阵在邻接矩阵中，在邻接矩阵中，以顶点在以顶点在vexs数组中的下标代表顶点，邻接矩阵中的元数组中的下标代表顶点，邻接矩阵中的元素素A[i][j]存放的是顶点存放的是顶点i到顶点到顶点j之间关系的信息之间关系的信息数据结构严蔚敏1 无向图的数组表示无向图的数组表示(1) 无权图的邻接矩阵无权图的邻接矩阵 无向无权图无向无权图G=(V，，E)有有n(n≧≧1)个顶点，其邻接矩个顶点，其邻接矩阵是阵是n阶对称方阵，如图阶对称方阵，如图7-5所示其元素的定义如下：所示其元素的定义如下：1 若若(vi , vj) E，即，即vi , vj邻接邻接0 若若(vi , vj) E，即，即vi , vj不邻接不邻接A[i][j]=(a) 无向图无向图 abcd图图7-5 无向无权图的数组存储无向无权图的数组存储(b) 顶点矩阵顶点矩阵vexsabcd0 1 1 11 0 1 11 1 0 11 1 1 0(c) 邻接矩阵邻接矩阵数据结构严蔚敏(2) 带权图的邻接矩阵带权图的邻接矩阵 无向带权图无向带权图G=(V，，E) 的邻接矩阵如图的邻接矩阵如图7-6所示。

其所示其元素的定义如下：元素的定义如下：(a) 带权无向图带权无向图 (b) 顶点矩阵顶点矩阵图图7-6 无向带权图的数组存储无向带权图的数组存储(c) 邻接矩阵邻接矩阵354126abcde3vexsabcde∞ 6 2 ∞ ∞6 ∞ 3 4 32 3 ∞ 1 ∞∞ 4 3 ∞ 5∞ 3 ∞ 5 ∞Wij 若若(vi , vj) E，即，即vi , vj邻接，权值为邻接，权值为wij∞ ∞ 若若(vi , vj) E，即，即vi , vj不邻接时不邻接时A[i][j]=数据结构严蔚敏(3) 无向图邻接矩阵的特性无向图邻接矩阵的特性 ◆ ◆ 邻接矩阵是邻接矩阵是对称方阵对称方阵；； ◆◆ 对于顶点对于顶点vi，其，其度数度数是第是第i行的非行的非0元素的个数；元素的个数； ◆◆ 无向图的无向图的边数边数是上是上(或下或下)三角形矩阵中非三角形矩阵中非0元素元素个数2 有向图的数组表示有向图的数组表示(1) 无权图的邻接矩阵无权图的邻接矩阵 若有向无权图若有向无权图G=(V，，E)有有n(n≧≧1)个顶点，则其邻个顶点，则其邻接矩阵是接矩阵是n阶对称方阵阶对称方阵，如图，如图7-7所示。

元素定义如下：所示元素定义如下：1 若若 E，从，从vi到到vj有弧有弧A[i][j]=0 若若 E 从从vi到到vj 没有弧没有弧数据结构严蔚敏(a) 有向图有向图acbde图图7-7 有向无权图的数组存储有向无权图的数组存储(b) 顶点矩阵顶点矩阵vexsabcde(c) 邻接矩阵邻接矩阵0 1 1 0 10 0 0 0 00 0 0 1 11 1 0 0 00 0 0 1 0(2) 带权图的邻接矩阵带权图的邻接矩阵 有向带权图有向带权图G=(V，，E)的邻接矩阵如图的邻接矩阵如图7-8所示其元素的定义如下：元素的定义如下：wij 若若 E，即，即vi , vj邻接，权值为邻接，权值为wij∞ ∞ 若若 E，即，即vi , vj不邻接时不邻接时A[i][j]=数据结构严蔚敏图图7-8 带权有向图的数组存储带权有向图的数组存储(b) 顶点矩阵顶点矩阵vexsabcde(c) 邻接矩阵邻接矩阵∞ 6 2 ∞ ∞∞ ∞ ∞ ∞ 3∞ 3 ∞ 1 ∞∞ 4 ∞ ∞ 5∞ ∞ ∞ ∞ ∞(a) 带权有向图带权有向图 354126abcde3⑶ ⑶ 有向图邻接矩阵的特性有向图邻接矩阵的特性◆ ◆ 对于顶点对于顶点vi，第，第i行的非行的非0元素的个数是其元素的个数是其出度出度OD(vi)；第；第i列的非列的非0元素的个数是其元素的个数是其入度入度ID(vi) 。

◆◆ 邻接矩阵中非邻接矩阵中非0元素的个数就是图的弧的数目元素的个数就是图的弧的数目数据结构严蔚敏3 图的邻接矩阵的操作图的邻接矩阵的操作 图的邻接矩阵的实现比较容易，定义两个数组分别图的邻接矩阵的实现比较容易，定义两个数组分别存储存储顶点信息顶点信息(数据元素数据元素)和和边或弧的信息边或弧的信息(数据元素之间数据元素之间的关系的关系) 其存储结构形式定义存储结构形式定义如下：如下：#define INFINITY MAX_VAL /* 最大值最大值∞ */ /* 根据图的权值类型，分别定义为最大整数或实数根据图的权值类型，分别定义为最大整数或实数 */#define MAX_VEX 30 /* 最大顶点数目最大顶点数目 */typedef enum {DG, AG, WDG,WAG} GraphKind ; /* {有向图，无向图，带权有向图，带权无向图有向图，无向图，带权有向图，带权无向图} */数据结构严蔚敏typedef struct ArcType{ VexType vex1, vex2 ; /* 弧或边所依附的两个顶点弧或边所依附的两个顶点 */ArcValType ArcVal ; /* 弧或边的权值弧或边的权值 */ArcInfoType ArcInfo ; /* 弧或边的其它信息弧或边的其它信息 */}ArcType ; /* 弧或边的结构定义弧或边的结构定义 */typedef struct{ GraphKind kind ; /* 图的种类标志图的种类标志 */int vexnum , arcnum ; /* 图的当前顶点数和弧数图的当前顶点数和弧数 */VexType vexs[MAX_VEX] ; /* 顶点向量顶点向量 */AdjType adj[MAX_VEX][MAX_VEX];}MGraph ; /* 图的结构定义图的结构定义 */数据结构严蔚敏 利用上述定义的数据结构，可以方便地实现图的各利用上述定义的数据结构，可以方便地实现图的各种操作。

种操作1) 图的创建图的创建AdjGraph *Create_Graph(MGraph * G){ printf(“请输入图的种类标志：请输入图的种类标志：”) ;scanf(“%d”, &G->kind) ;G->vexnum=0 ; /* 初始化顶点个数初始化顶点个数 */return(G) ; }数据结构严蔚敏(2) 图的顶点定位图的顶点定位 图的顶点定位操作实际上是确定一个顶点在图的顶点定位操作实际上是确定一个顶点在vexs数数组中的位置组中的位置(下标下标) ，其过程完全等同于在顺序存储的线，其过程完全等同于在顺序存储的线性表中查找一个数据元素性表中查找一个数据元素算法实现算法实现：：int LocateVex(MGraph *G , VexType *vp) { int k ; for (k=0 ; kvexnum ; k++) if (G->vexs[k]==*vp) return(k) ; return(-1) ; /* 图中无此顶点图中无此顶点 */ }数据结构严蔚敏(3) 向图中增加顶点向图中增加顶点 向图中增加一个顶点的操作，类似在顺序存储的线向图中增加一个顶点的操作，类似在顺序存储的线性表的末尾增加一个数据元素。

性表的末尾增加一个数据元素算法实现算法实现：：int AddVertex(MGraph *G , VexType *vp) { int k , j ;if (G->vexnum>=MAX_VEX){ printf(“Vertex Overflow !\n”) ; return(-1) ; }if (LocateVex(G , vp)!=-1){ printf(“Vertex has existed !\n”) ; return(-1) ; }k=G->vexnum ; G->vexs[G->vexnum++]=*vp ;数据结构严蔚敏if (G->kind==DG||G->kind==AG) for (j=0 ; jvexnum ; j++)G->adj[j][k].ArcVal=G->adj[k][j].ArcVal=0 ; /* 是不带权的有向图或无向图是不带权的有向图或无向图 */elsefor (j=0 ; jvexnum ; j++) { G->adj[j][k].ArcVal=INFINITY ; G->adj[k][j].ArcVal=INFINITY ; /* 是带权的有向图或无向图是带权的有向图或无向图 */}return(k) ;}数据结构严蔚敏(4) 向图中增加一条弧向图中增加一条弧 根据给定的弧或边所依附的顶点，修改邻接矩阵中根据给定的弧或边所依附的顶点，修改邻接矩阵中所对应的数组元素。

所对应的数组元素算法实现算法实现：： int AddArc(MGraph *G , ArcType *arc) { int k , j ;k=LocateVex(G , &arc->vex1) ;j=LocateVex(G , &arc->vex1) ;if (k==-1||j==-1) { printf(“Arc’s Vertex do not existed !\n”) ;return(-1) ;}数据结构严蔚敏if (G->kind==DG||G->kind==WDG) { G->adj[k][j].ArcVal=arc->ArcVal;G->adj[k][j].ArcInfo=arc->ArcInfo ; /* 是有向图或带权的有向图是有向图或带权的有向图*/}else{ G->adj[k][j].ArcVal=arc->ArcVal ;G->adj[j][k].ArcVal=arc->ArcVal ;G->adj[k][j].ArcInfo=arc->ArcInfo ;G->adj[j][k].ArcInfo=arc->ArcInfo ; /* 是无向图或带权的无向图是无向图或带权的无向图,需对称赋值需对称赋值 */}return(1) ; }数据结构严蔚敏7.2.2 邻接链表法邻接链表法 基本思想：基本思想：对图的每个顶点建立一个单链表，存储对图的每个顶点建立一个单链表，存储该顶点所有邻接顶点及其相关信息。

每一个单链表设一该顶点所有邻接顶点及其相关信息每一个单链表设一个表头结点个表头结点 第第i个单链表表示依附于顶点个单链表表示依附于顶点Vi的边的边(对有向图是以对有向图是以顶点顶点Vi为头或尾的弧为头或尾的弧)数据结构严蔚敏1 结点结构与邻接链表示例结点结构与邻接链表示例 链表中的结点称为链表中的结点称为表结点表结点，每个结点由三个域组成，，每个结点由三个域组成，如图如图7-9(a)所示其中邻接点域所示其中邻接点域(adjvex)指示与顶点指示与顶点Vi邻邻接的顶点在图中的位置接的顶点在图中的位置(顶点编号顶点编号)，链域，链域(nextarc)指向指向下一个与顶点下一个与顶点Vi邻接的表结点，数据域邻接的表结点，数据域(info)存储和边或存储和边或弧相关的信息，如权值等对于无权图，如果没有与边弧相关的信息，如权值等对于无权图，如果没有与边相关的其他信息，可省略此域相关的其他信息，可省略此域 每个链表设一个表头结点每个链表设一个表头结点(称为称为顶点结点顶点结点)，由两个，由两个域组成，如图域组成，如图7-9(b)所示链域所示链域(firstarc)指向链表中的指向链表中的第一个结点，数据域第一个结点，数据域(data) 存储顶点名或其他信息。

存储顶点名或其他信息adjvex info nextarc表结点表结点：：data firstarc顶点结点顶点结点：：图图7-9 邻接链表结点结构邻接链表结点结构数据结构严蔚敏 在图的邻接链表表示中，所有在图的邻接链表表示中，所有顶点结点顶点结点用一个向量用一个向量 以顺序结构形式存储，可以随机访问任意顶点的链表，以顺序结构形式存储，可以随机访问任意顶点的链表，该向量称为该向量称为表头向量表头向量，向量的下标指示顶点的序号向量的下标指示顶点的序号 用邻接链表存储图时，对无向图，其邻接链表是唯用邻接链表存储图时，对无向图，其邻接链表是唯一的，如图一的，如图7-10所示；对有向图，其邻接链表有两种形所示；对有向图，其邻接链表有两种形式，如图式，如图7-11所示图图7-10 无向图及其邻接链表无向图及其邻接链表v1v2v3v4v501234MAX_VEX-1v1 v2v3 v4┇┇ ┇ ┇ v5 213 ⋀02 ⋀0314 ⋀204 ⋀23 ⋀数据结构严蔚敏(a) 有向图有向图v1v2v3v4v513 ⋀014 ⋀2 ⋀3 ⋀01234MAX_VEX-1v1 2 v2 0 ⋀v3 3v4 1┇┇ ┇ ┇ ┇ ┇v5 1 (b) 正邻接链表，出度直观正邻接链表，出度直观2 ⋀02 ⋀2 ⋀01234MAX_VEX-1v1 1v2 2v3 1v4 2┇┇ ┇ ┇ ┇ ┇v5 1 3 ⋀04 ⋀(c) 逆邻接链表，入度直观逆邻接链表，入度直观图图7-11 有向图及其邻接链表有向图及其邻接链表数据结构严蔚敏2 邻接表法的特点邻接表法的特点 ◆◆ 表头向量中每个分量就是一个单链表的头结点，表头向量中每个分量就是一个单链表的头结点，分量个数就是图中的顶点数目；分量个数就是图中的顶点数目； ◆◆ 在边或弧稀疏的条件下，用邻接表表示比用邻接在边或弧稀疏的条件下，用邻接表表示比用邻接矩阵表示节省存储空间；矩阵表示节省存储空间； ◆◆ 在无向图，顶点在无向图，顶点Vi的度是第的度是第i个链表的结点数；个链表的结点数；◆◆ 对对有向图有向图可以建立可以建立正邻接表正邻接表或或逆邻接表逆邻接表。

正邻接正邻接表是以顶点表是以顶点Vi为出度为出度(即为弧的起点即为弧的起点)而建立的邻接而建立的邻接表；逆邻接表是以顶点表；逆邻接表是以顶点Vi为入度为入度(即为弧的终点即为弧的终点)而而建立的邻接表；建立的邻接表；◆◆ 在有向图中，第在有向图中，第i个链表中的结点数是顶点个链表中的结点数是顶点Vi的的出出 (或入或入)度；求入度；求入 (或出或出)度，须遍历整个邻接表；度，须遍历整个邻接表；数据结构严蔚敏◆◆ 在邻接表上容易找出任一顶点的第一个邻接点和在邻接表上容易找出任一顶点的第一个邻接点和下一个邻接点；下一个邻接点；3 结点及其类型定义结点及其类型定义#define MAX_VEX 30 /* 最大顶点数最大顶点数 */typedef int InfoType;typedef enum {DG, AG, WDG,WAG} GraphKind ;typedef struct LinkNode{ int adjvex ; // 邻接点在头结点数组中的位置邻接点在头结点数组中的位置(下标下标)InfoType info ; // 与边或弧相关的信息与边或弧相关的信息, 如权值如权值struct LinkNode *nextarc ; // 指向下一个表结点指向下一个表结点}LinkNode ; /* 表结点类型定义表结点类型定义 */数据结构严蔚敏typedef struct VexNode{ VexType data; // 顶点信息顶点信息int indegree ; // 顶点的度顶点的度, 有向图是入度或出度或没有有向图是入度或出度或没有 LinkNode *firstarc ; // 指向第一个表结点指向第一个表结点}VexNode ; /* 顶点结点类型定义顶点结点类型定义 */typedef struct ArcType{ VexType vex1, vex2 ; /* 弧或边所依附的两个顶点弧或边所依附的两个顶点 */InfoType info ; // 与边或弧相关的信息与边或弧相关的信息, 如权值如权值}ArcType ; /* 弧或边的结构定义弧或边的结构定义 */数据结构严蔚敏typedef struct{ GraphKind kind ; /* 图的种类标志图的种类标志 */int vexnum ;VexNode AdjList[MAX_VEX] ;}ALGraph ; /* 图的结构定义图的结构定义 */数据结构严蔚敏 利用上述的存储结构描述，可方便地实现图的基本利用上述的存储结构描述，可方便地实现图的基本操作。

操作1) 图的创建图的创建ALGraph *Create_Graph(ALGraph * G){ printf(“请输入图的种类标志：请输入图的种类标志：”) ;scanf(“%d”, &G->kind) ;G->vexnum=0 ; /* 初始化顶点个数初始化顶点个数 */return(G) ; }数据结构严蔚敏(2) 图的顶点定位图的顶点定位 图的顶点定位实际上是确定一个顶点在图的顶点定位实际上是确定一个顶点在AdjList数组数组中的某个元素的中的某个元素的data域内容算法实现算法实现：：int LocateVex(ALGraph *G , VexType *vp) { int k ;for (k=0 ; kvexnum ; k++)if (G->AdjList[k].data==*vp) return(k) ;return(-1) ; /* 图中无此顶点图中无此顶点 */}数据结构严蔚敏(3) 向图中增加顶点向图中增加顶点 向图中增加一个顶点的操作，在向图中增加一个顶点的操作，在AdjList数组的末尾数组的末尾增加一个数据元素。

增加一个数据元素算法实现算法实现：：int AddVertex(ALGraph *G , VexType *vp) { int k , j ;if (G->vexnum>=MAX_VEX){ printf(“Vertex Overflow !\n”) ; return(-1) ; }if (LocateVex(G , vp)!=-1){ printf(“Vertex has existed !\n”) ; return(-1) ; }G->AdjList[G->vexnum].data=*vp ;数据结构严蔚敏G->AdjList[G->vexnum].degree=0 ;G->AdjList[G->vexnum].firstarc=NULL ;k=++G->vexnum ; return(k) ; }(4) 向图中增加一条弧向图中增加一条弧 根据给定的弧或边所依附的顶点，修改单链表：无根据给定的弧或边所依附的顶点，修改单链表：无向图修改两个单链表；有向图修改一个单链表向图修改两个单链表；有向图修改一个单链表算法实现算法实现：：int AddArc(ALGraph *G , ArcType *arc) { int k , j ;LinkNode *p ,*q ;数据结构严蔚敏k=LocateVex(G , &arc->vex1) ;j=LocateVex(G , &arc->vex2) ;if (k==-1||j==-1) { printf(“Arc’s Vertex do not existed !\n”) ; return(-1) ; }p=(LinkNode *)malloc(sizeof(LinkNode)) ;p->adjvex=arc->vex1 ; p->info=arc->info ;p->nextarc=NULL ; /* 边的起始表结点赋值边的起始表结点赋值 */q=(LinkNode *)malloc(sizeof(LinkNode)) ;q->adjvex=arc->vex2 ; q->info=arc->info ;q->nextarc=NULL ; /* 边的末尾表结点赋值边的末尾表结点赋值 */数据结构严蔚敏if (G->kind==AG||G->kind==WAG) { q->nextarc=G->adjlist[k].firstarc ;G->adjlist[k].firstarc=q ;p->nextarc=G->adjlist[j].firstarc ;G->adjlist[j].firstarc=p ;} /* 是无向图是无向图, 用头插入法插入到两个单链表用头插入法插入到两个单链表 */else /* 建立有向图的邻接链表建立有向图的邻接链表, 用头插入法用头插入法 */{ q->nextarc=G->adjlist[k].firstarc ;G->adjlist[k].firstarc=q ; /* 建立正邻接链表用建立正邻接链表用 *///q->nextarc=G->adjlist[j].firstarc ;//G->adjlist[j].firstarc=q ; /* 建立逆邻接链表用建立逆邻接链表用 */}return(1);}数据结构严蔚敏7.2.3 十字链表法十字链表法 十字链表十字链表(Orthogonal List)是有向图的另一种链是有向图的另一种链式存储结构，是将有向图的正邻接表和逆邻接表结合起式存储结构，是将有向图的正邻接表和逆邻接表结合起来得到的一种链表。

来得到的一种链表 在这种结构中，每条弧的弧头结点和弧尾结点都存在这种结构中，每条弧的弧头结点和弧尾结点都存放在链表中，并将放在链表中，并将弧结点弧结点分别组织到分别组织到以弧尾结点为头以弧尾结点为头(顶点顶点)结点结点和和以弧头结点为头以弧头结点为头(顶点顶点)结点结点的链表中这的链表中这种结构的结点逻辑结构如图种结构的结点逻辑结构如图7-12所示弧结点弧结点tailvex headvex info hlink tlink顶点结点顶点结点Data firstin firstout图图7-12 十字链表结点结构十字链表结点结构数据结构严蔚敏◆◆ data域：存储和顶点相关的信息；域：存储和顶点相关的信息；◆◆ 指针域指针域firstin：指向：指向以该顶点为弧头以该顶点为弧头的第一条弧的第一条弧所对应的弧结点；所对应的弧结点；◆◆ 指针域指针域firstout：指向：指向以该顶点为弧尾以该顶点为弧尾的第一条弧的第一条弧所对应的弧结点；所对应的弧结点；◆◆ 尾域尾域tailvex：指示弧尾顶点在图中的位置；：指示弧尾顶点在图中的位置；◆◆ 头域头域headvex：指示弧头顶点在图中的位置；：指示弧头顶点在图中的位置；◆◆ 指针域指针域hlink：指向弧头相同的下一条弧；：指向弧头相同的下一条弧；◆◆ 指针域指针域tlink：指向弧尾相同的下一条弧；：指向弧尾相同的下一条弧；◆◆ Info域：指向该弧的相关信息；域：指向该弧的相关信息；数据结构严蔚敏结点类型定义结点类型定义#define INFINITY MAX_VAL /* 最大值最大值∞ */#define MAX_VEX 30 // 最大顶点数最大顶点数 typedef struct ArcNode{ int tailvex , headvex ; // 尾结点和头结点在图中的位置尾结点和头结点在图中的位置InfoType info ; // 与弧相关的信息与弧相关的信息, 如权值如权值struct ArcNode *hlink , *tlink ; }ArcNode ; /* 弧结点类型定义弧结点类型定义 */typedef struct VexNode{ VexType data; // 顶点信息顶点信息ArcNode *firstin , *firstout ;}VexNode ; /* 顶点结点类型定义顶点结点类型定义 */数据结构严蔚敏typedef struct{ int vexnum ;VexNode xlist[MAX_VEX] ;}OLGraph ; /* 图的类型定义图的类型定义 */ 图图7-13所示是一个有向图及其十字链表所示是一个有向图及其十字链表(略去了表结略去了表结点的点的info域域)。

从这种存储结构图可以看出，从一个顶点结点的从这种存储结构图可以看出，从一个顶点结点的firstout出发，沿表结点的出发，沿表结点的tlink指针构成了正邻接表的链指针构成了正邻接表的链表结构，而从一个顶点结点的表结构，而从一个顶点结点的firstin出发，沿表结点的出发，沿表结点的hlink指针构成了逆邻接表的链表结构指针构成了逆邻接表的链表结构数据结构严蔚敏V0V1V2V30 10 2 ∧2 02 3 ∧∧3 0 ∧3 1 ∧3 2 ∧∧0213V0V1 ∧V2V3图图7-13 有向图的十字链表结构有向图的十字链表结构数据结构严蔚敏7.2.4 邻接多重表邻接多重表 邻接多重表邻接多重表(Adjacency Multilist)是无向图的另是无向图的另一种链式存储结构一种链式存储结构 邻接表是无向图的一种有效的存储结构，在无向图邻接表是无向图的一种有效的存储结构，在无向图的邻接表中，一条边的邻接表中，一条边(v,w)的两个表结点分别初选在以的两个表结点分别初选在以v和和w为头结点的链表中，很容易求得顶点和边的信息，为头结点的链表中，很容易求得顶点和边的信息，但在涉及到边的操作会带来不便。

但在涉及到边的操作会带来不便 邻接多重表的结构和十字链表类似，邻接多重表的结构和十字链表类似，每条边用一个每条边用一个结点表示结点表示；邻接多重表中的顶点结点结构与邻接表中的；邻接多重表中的顶点结点结构与邻接表中的完全相同，而表结点包括六个域如图完全相同，而表结点包括六个域如图7-14所示data firstedge顶点结点顶点结点图图7-14 邻接多重表的结点结构邻接多重表的结点结构表结点表结点mark ivex jvex info ilink jlink数据结构严蔚敏◆◆ Data域：存储和顶点相关的信息；域：存储和顶点相关的信息；◆◆ 指针域指针域firstedge：指向依附于该顶点的第一条边：指向依附于该顶点的第一条边所对应的表结点；所对应的表结点；◆◆ 标志域标志域mark：用以标识该条边是否被访问过；：用以标识该条边是否被访问过；◆◆ ivex和和jvex域：分别保存该边所依附的两个顶点在域：分别保存该边所依附的两个顶点在图中的位置；图中的位置；◆◆ info域：保存该边的相关信息；域：保存该边的相关信息；◆◆ 指针域指针域ilink：指向下一条依附于顶点：指向下一条依附于顶点ivex的边；的边；◆◆ 指针域指针域jlink：指向下一条依附于顶点：指向下一条依附于顶点jvex的边；的边；数据结构严蔚敏结点类型定义结点类型定义#define INFINITY MAX_VAL /* 最大值最大值∞ */#define MAX_VEX 30 /* 最大顶点数最大顶点数 */typedef emnu {unvisited , visited} Visitting ;typedef struct EdgeNode{ Visitting mark ; // 访问标记访问标记int ivex , jvex ; // 该边依附的两个结点在图中的位置该边依附的两个结点在图中的位置InfoType info ; // 与边相关的信息与边相关的信息, 如权值如权值struct EdgeNode *ilink , *jlink ; // 分别指向依附于这两个顶点的下一条边分别指向依附于这两个顶点的下一条边}EdgeNode ; /* 弧边结点类型定义弧边结点类型定义 */数据结构严蔚敏typedef struct VexNode{ VexType data; // 顶点信息顶点信息ArcNode *firsedge ; // 指向依附于该顶点的第一条边指向依附于该顶点的第一条边}VexNode ; /* 顶点结点类型定义顶点结点类型定义 */typedef struct{ int vexnum ;VexNode mullist[MAX_VEX] ;}AMGraph ; 图图7-15所示是一个无向图及其邻接多重表。

所示是一个无向图及其邻接多重表数据结构严蔚敏邻接多重表与邻接表的区别邻接多重表与邻接表的区别：： 后者的同一条边用两个表结点表示，而前者只用一后者的同一条边用两个表结点表示，而前者只用一个表结点表示个表结点表示；；除标志域外，邻接多重表与邻接表表达除标志域外，邻接多重表与邻接表表达的信息是相同的，因此，操作的实现也基本相似的信息是相同的，因此，操作的实现也基本相似图图7-15 无向图及其多重邻接链表无向图及其多重邻接链表v1v2v3v4v1v2v3v40123 0 1 0 2∧ 2 1∧ 2 3 0∧ 3∧数据结构严蔚敏7.2.5 图的边表存储结构图的边表存储结构 在某些应用中，有时主要考察图中各个边的权值以在某些应用中，有时主要考察图中各个边的权值以及所依附的两个顶点，即及所依附的两个顶点，即图的结构主要由边来表示图的结构主要由边来表示，称，称为为边表存储结构边表存储结构 在边表结构中，边采用顺序存储，每个边元素由三在边表结构中，边采用顺序存储，每个边元素由三部分组成部分组成：边所依附的：边所依附的两个顶点和边的权值两个顶点和边的权值；；图的顶点图的顶点用另一个顺序结构的顶点表存储。

如图用另一个顺序结构的顶点表存储如图7-16所示边表存储结构的形式描述如下边表存储结构的形式描述如下：#define INFINITY MAX_VAL /* 最大值最大值∞ */#define MAX_VEX 30 /* 最大顶点数最大顶点数 */#define MAX_EDGE 100 /* 最大边数最大边数 */数据结构严蔚敏typedef struct ENode{ int ivex , jvex ; /* 边所依附的两个顶点边所依附的两个顶点 */WeightType weight ; /* 边的权值边的权值 */}ENode ; /* 边表元素类型定义边表元素类型定义 */typedef struct { int vexnum , edgenum ; /* 顶点数和边数顶点数和边数 */VexType vexlist[MAX_VEX] ; /* 顶点表顶点表 */ENode edgelist[MAX_EDGE] ; /* 边表边表 */ }ELGraph ; 数据结构严蔚敏图图7-16 无向图的边表表示无向图的边表表示v0v2v4v3v1674239 8顶点表顶点表v0v1v2v3v401234边边 表表1 3 21 4 92 3 82 4 33 4 40 2 70 1 6数据结构严蔚敏7.3 图的遍历图的遍历 图的遍历图的遍历(Travering Graph)：：从图的某一顶点从图的某一顶点出发，访遍图中的其余顶点，且每个顶点仅被访问一次。

出发，访遍图中的其余顶点，且每个顶点仅被访问一次图的遍历算法是各种图的操作的基础图的遍历算法是各种图的操作的基础 ◆ ◆ 复杂性：复杂性：图的任意顶点可能和其余的顶点相邻图的任意顶点可能和其余的顶点相邻接，可能在访问了某个顶点后，沿某条路径搜索后接，可能在访问了某个顶点后，沿某条路径搜索后又回到原顶点又回到原顶点 ◆ ◆ 解决办法：解决办法：在遍历过程中记下已被访问过的顶在遍历过程中记下已被访问过的顶点设置一个辅助向量点设置一个辅助向量Visited[1…n](n为顶点数为顶点数)，，其初值为其初值为0，一旦访问了顶点，一旦访问了顶点vi后，使后，使Visited[i]为为1或或为访问的次序号为访问的次序号 图的遍历算法有图的遍历算法有深度优先搜索算法深度优先搜索算法和和广度优先搜索广度优先搜索算法算法采用的数据结构是采用的数据结构是( (正正) )邻接链表邻接链表数据结构严蔚敏7.3.1 深度优先搜索算法深度优先搜索算法 深度优先搜索深度优先搜索(Depth First Search--DFS)遍历遍历类似类似树的先序遍历树的先序遍历，是，是树的先序遍历的推广树的先序遍历的推广。

1 算法思想算法思想设初始状态时图中的所有顶点未被访问，则：设初始状态时图中的所有顶点未被访问，则：⑴⑴ ：：从图中某个顶点从图中某个顶点vi出发出发，访问，访问vi；然后找到；然后找到vi的的一个邻接顶点一个邻接顶点vi1 ；；⑵⑵：从：从vi1出发，深度优先搜索访问和出发，深度优先搜索访问和vi1相相邻接且未邻接且未被访问的所有顶点；被访问的所有顶点；⑶⑶：转：转⑴⑴ ，直到和，直到和vi相相邻接的所有顶点都被访问为邻接的所有顶点都被访问为止止 数据结构严蔚敏图图7-17 无向图深度优先搜索遍历无向图深度优先搜索遍历(a) 无向图无向图Gv1v2v3v4v5(b) G的邻接链表的邻接链表01234MAX_VEX-1v1 v2v3 v4┇┇ ┇ ┇ v5 21 ⋀20 ⋀01 ⋀4 ⋀3 ⋀⑷⑷ ：继续选取图中未被访问顶点：继续选取图中未被访问顶点vj作为起始顶点，作为起始顶点，转转(1)，直到图中所有顶点都被访问为止直到图中所有顶点都被访问为止 图图7-17是无向图的深度优先搜索遍历示例是无向图的深度优先搜索遍历示例(红色箭头红色箭头)。

某种某种DFS次序是次序是：：v1→ v3 → v2 → v4 → v5数据结构严蔚敏2 算法实现算法实现 由算法思想知，这是一个递归过程因此，先设计由算法思想知，这是一个递归过程因此，先设计一个从某个顶点一个从某个顶点( (编号编号) )为为v0开始开始深度优先深度优先搜索的函数搜索的函数，，便于调用便于调用 在遍历整个图时，可以对图中的每一个未访问的顶在遍历整个图时，可以对图中的每一个未访问的顶点执行所定义的函数点执行所定义的函数typedef emnu {FALSE , TRUE} BOOLEAN ;BOOLEAN Visited[MAX_VEX] ;数据结构严蔚敏void DFS(ALGraph *G , int v){ LinkNode *p ;Visited[v]=TRUE ; Visit[v] ; /* 置访问标志置访问标志，，访问顶点访问顶点v */ p=G->AdjList[v].firstarc; /* 链表的第一个结点链表的第一个结点 */while (p!=NULL){ if (!Visited[p->adjvex]) DFS(G, p->adjvex) ; /* 从从v的未访问过的邻接顶点出发的未访问过的邻接顶点出发深度优先深度优先搜索搜索 */p=p->nextarc ;} }数据结构严蔚敏void DFS_traverse_Grapg(ALGraph *G){ int v ;for (v=0 ; vvexnum ; v++)Visited[v]=FALSE ; /* 访问标志初始化访问标志初始化 */ p=G->AdjList[v].firstarc ;for (v=0 ; vvexnum ; v++)if (!Visited[v]) DFS(G , v);}3 算法分析算法分析 遍历时，对图的每个顶点至多调用一次遍历时，对图的每个顶点至多调用一次DFS函数。

函数其实质就是对每个顶点查找邻接顶点的过程，取决于存其实质就是对每个顶点查找邻接顶点的过程，取决于存储结构当图有储结构当图有e条边，其时间复杂度为条边，其时间复杂度为O(e)，总时间复，总时间复杂度为杂度为O(n+e) 数据结构严蔚敏7.3.2 广度优先搜索算法广度优先搜索算法 广度优先搜索广度优先搜索(Breadth First Search--BFS)遍遍历类似历类似树的按层次遍历树的按层次遍历的过程的过程1 算法思想算法思想 设初始状态时图中的所有顶点未被访问，则：设初始状态时图中的所有顶点未被访问，则：⑴⑴ ：：从图中某个顶点从图中某个顶点vi出发出发，访问，访问vi；；⑵⑵：访问：访问vi的所有相的所有相邻接且未被访问的所有顶点邻接且未被访问的所有顶点vi1，，vi2，，…，，vim；；⑶⑶：以：以vi1，，vi2，， …，，vim的次序的次序，以，以vij(1≦≦j≦≦m)依依此作为此作为vi ，转，转⑴⑴；； 数据结构严蔚敏⑷⑷ ：：继续选取图中继续选取图中未被访问未被访问顶点顶点vk作为起始顶点作为起始顶点，，转转⑴⑴，直到图中所有顶点都被访问为止。

直到图中所有顶点都被访问为止图图7-18是有向图的广度优先搜索遍历示例是有向图的广度优先搜索遍历示例(红色箭头红色箭头)上述图的上述图的BFS次序是次序是：：v1→ v2 → v4 → v3 → v5(b) G’的正邻接链表的正邻接链表13 ⋀014 ⋀2 ⋀3 ⋀01234MAX_VEX-1v1 2 v2 0 ⋀v3 3v4 1┇┇ ┇ ┇ ┇ ┇v5 1 图图7-18 有向图广度优先搜索遍历有向图广度优先搜索遍历(a) 有向图有向图G’v1v2v3v4v5数据结构严蔚敏2 算法实现算法实现 为了标记图中顶点是否被访问过，同样需要一个访为了标记图中顶点是否被访问过，同样需要一个访问标记数组；其次，为了依此访问与问标记数组；其次，为了依此访问与vi相邻接的各个顶相邻接的各个顶点点，需要附加一个队列来保存访问，需要附加一个队列来保存访问vi的相邻接的的相邻接的顶点typedef emnu {FALSE , TRUE} BOOLEAN ;BOOLEAN Visited[MAX_VEX] ;typedef struct Queue{ int elem[MAX_VEX] ;int front , rear ;}Queue ; /* 定义一个队列保存将要访问顶点定义一个队列保存将要访问顶点 */数据结构严蔚敏void BFS_traverse_Grapg(ALGraph *G){ int k ,v , w ;LinkNode *p ; Queue *Q ;Q=(Queue *)malloc(sizeof(Queue)) ;Q->front=Q->rear=0 ; /* 建立空队列并初始化建立空队列并初始化 */for (k=0 ; kvexnum ; k++)Visited[k]=FALSE ; /* 访问标志初始化访问标志初始化 */for (k=0 ; kvexnum ; k++){ v=G->AdjList[k].data ; /* 单链表的头顶点单链表的头顶点 */if (!Visited[v]) /* v尚未访问尚未访问 */ { Q->elem[++Q->rear]=v ; /* v入对入对 */ while (Q->front!=Q->rear)数据结构严蔚敏 { w=Q->elem[++Q->front] ; Visited[w]=TRUE ; /* 置访问标志置访问标志 */ Visit(w) ; /* 访问队首元素访问队首元素 */ p=G->AdjList[w].firstarc ; while (p!=NULL) { if (!Visited[p->adjvex]) Q->elem[++Q->rear]=p->adjvex ; p=p->nextarc ; } } /* end while */} /* end if */} /* end for */}数据结构严蔚敏 用用广度优先搜索算法广度优先搜索算法遍历图与遍历图与深度优先搜索算法深度优先搜索算法遍遍历图的历图的唯一区别唯一区别是是邻接点搜索次序不同邻接点搜索次序不同，因此，，因此，广度优广度优先搜索算法先搜索算法遍历图的总时间复杂度为遍历图的总时间复杂度为O(n+e) 。

图的遍历可以系统地访问图中的每个顶点，因此，图的遍历可以系统地访问图中的每个顶点，因此，图的遍历算法是图的最基本图的遍历算法是图的最基本、、最重要的算法，许多有关最重要的算法，许多有关图的操作都是在图的遍历基础之上加以变化来实现的图的操作都是在图的遍历基础之上加以变化来实现的数据结构严蔚敏7.4 图的连通性问题图的连通性问题 本节所讨论的内容是图的遍历算法的具体应用本节所讨论的内容是图的遍历算法的具体应用7.4.1 无向图的连通分量与生成树无向图的连通分量与生成树1 无向图的连通分量和生成树无向图的连通分量和生成树 对于无向图，对其进行遍历时：对于无向图，对其进行遍历时：◆◆ 若是若是连通图连通图：仅需从图中：仅需从图中任一顶点出发任一顶点出发，就能访，就能访问图中的所有顶点；问图中的所有顶点；◆◆ 若是若是非连通图非连通图：需从图中：需从图中多个顶点出发多个顶点出发每次从一个新顶点出发所访问的顶点集序列一个新顶点出发所访问的顶点集序列恰好是恰好是各个连各个连通分量的顶点集；通分量的顶点集；数据结构严蔚敏(a) 无向图无向图Gv1v2v3v4v5(b) G的邻接链表的邻接链表01234MAX_VEX-1v1 v2v3 v4┇┇ ┇ ┇ v5 21 ⋀20 ⋀01 ⋀4 ⋀3 ⋀图图7-19 无向图及深度优先生成森林无向图及深度优先生成森林(c) 深度优先生成森林深度优先生成森林v1v2v3v4v5 如图如图7-19所示的无向图是非连通图，按图中给定的所示的无向图是非连通图，按图中给定的邻接表进行深度优先搜索遍历，邻接表进行深度优先搜索遍历，2次调用次调用DFS所得到的所得到的顶点访问序列集是：顶点访问序列集是： { v1 ,v3 ,v2}和和{ v4 ,v5 }数据结构严蔚敏 ⑴ ⑴ 若若G=(V,E)是无向连通图是无向连通图，， 顶点集和边集分别顶点集和边集分别是是V(G) ，，E(G) 。

若从若从G中中任意点出发遍历时，任意点出发遍历时， E(G)被被分成两个互不相交的集合：分成两个互不相交的集合：T(G) ：遍历过程中所：遍历过程中所经过的边经过的边的集合；的集合；B(G) ：遍历过程中：遍历过程中未经过的边未经过的边的集合；的集合； 显然：显然： E(G)=T(G)∪∪B(G) ，，T(G)∩B(G)=Ø 显然，显然，图图G’=(V, T(G))是是G的极小连通子图的极小连通子图，且，且G’是一棵树是一棵树G’称为图称为图G的一棵生成树的一棵生成树 从任意点出发从任意点出发按按DFS算法算法得到生成树得到生成树G’称为称为深度优深度优先生成树先生成树；；按按BFS算法算法得到的得到的G’称为称为广度优先生成树广度优先生成树数据结构严蔚敏 ⑵⑵ 若若G=(V,E)是无向非连通图是无向非连通图，，对图进行遍历时得对图进行遍历时得到若干个连通分量的顶点集到若干个连通分量的顶点集：：V1(G) ,V2(G) ,…,Vn(G)和和相应所经过的边集相应所经过的边集：：T T1(G) ,T2(G) , …,Tn(G) 则对应的顶点集和边集的二元组：则对应的顶点集和边集的二元组：Gi=(Vi(G),Ti(G))(1≦≦i≦≦n)是对应分量的生成树是对应分量的生成树，，所有这些所有这些生成树构成了生成树构成了原来非连通图的生成森林原来非连通图的生成森林。

说明说明：：当给定无向图要求画出其对应的生成树或生成当给定无向图要求画出其对应的生成树或生成森林时，森林时，必须先给出相应的邻接表，然后才能根据邻接必须先给出相应的邻接表，然后才能根据邻接表画出其对应的生成树或生成森林表画出其对应的生成树或生成森林数据结构严蔚敏2 图的生成树和生成森林算法图的生成树和生成森林算法 对图的深度优先搜索遍历对图的深度优先搜索遍历DFS(或或BFS)算法稍作修算法稍作修改改，，就可得到构造图的就可得到构造图的DFS生成树算法生成树算法 在算法中，树的存储结构采用孩子在算法中，树的存储结构采用孩子——兄弟表示法兄弟表示法首先建立从某个顶点首先建立从某个顶点V出发出发，建立一个树结点，然后再，建立一个树结点，然后再分别以分别以V的邻接点为起始点，建立相应的子生成树，并的邻接点为起始点，建立相应的子生成树，并将其作为将其作为V 结点的子树链接到结点的子树链接到V结点上结点上显然，算法是显然，算法是一个递归算法一个递归算法算法实现算法实现：：数据结构严蔚敏(1) DFStree算法算法typedef struct CSNode{ ElemType data ;struct CSNode *firstchild , *nextsibling ;}CSNode ;CSNode *DFStree(ALGraph *G , int v){ CSNode *T , *ptr , *q ;LinkNode *p ; int w ;Visited[v]=TRUE ; T=(CSNode *)malloc(sizeof(CSNode)) ;T->data=G->AdjList[v].data ;T->firstchild=T->nextsibling=NULL ; // 建立根结点建立根结点数据结构严蔚敏q=NULL ; p=G->AdjList[v].firstarc ;while (p!=NULL){ w=p->adjvex ;if (!Visited[w]) { ptr=DFStree(G,w) ; /* 子树根结点子树根结点 */ if (q==NULL) T->firstchild=ptr ; else q->nextsibling=ptr ; q=ptr ; } p=p->nextarc ;}return(T) ; } 数据结构严蔚敏(2) BFStree算法算法typedef struct Queue{ int elem[MAX_VEX] ;int front , rear ;}Queue ; /* 定义一个队列保存将要访问顶点定义一个队列保存将要访问顶点 */CSNode *BFStree(ALGraph *G ,int v) { CSNode *T , *ptr , *q ;LinkNode *p ; Queue *Q ;int w , k ; Q=(Queue *)malloc(sizeof(Queue)) ;Q->front=Q->rear=0 ; /*建立空队列并初始化建立空队列并初始化*/Visited[v]=TRUE ;数据结构严蔚敏T=(CSNode *)malloc(sizeof(CSNode)) ;T->data=G->AdjList[v].data ;T->firstchild=T->nextsibling=NULL ; // 建立根结点建立根结点Q->elem[++Q->rear]=v ; /* v入队入队 */while (Q->front!=Q->rear){ w=Q->elem[++Q->front] ; q=NULL ;p=G->AdjList[w].firstarc ;while (p!=NULL) { k=p->adjvex ; if (!Visited[k]) { Visited[k]=TRUE ;数据结构严蔚敏 ptr=(CSNode *)malloc(sizeof(CSNode)) ; ptr->data=G->AdjList[k].data ; ptr->firstchild=T->nextsibling=NULL ; if (q==NULL) T->firstchild=ptr ; else q->nextsibling=ptr ; q=ptr ; Q->elem[++Q->rear]=k ; /* k入对入对 */ } /* end if */ p=p->nextarc ;} /* end while p */} /* end whil Q */return(T) ;} /*求图求图G广度优先生成树算法广度优先生成树算法BFStree*/ 数据结构严蔚敏(3) 图的生成森林算法图的生成森林算法CSNode *DFSForest(ALGraph *G){ CSNode *T , *ptr , *q ; int w ;for (w=0; wvexnum; w++) Visited[w]=FALSE;T=NULL ;for (w=0 ; wvexnum ; w++) if (!Visited[w]){ ptr=DFStree(G, w) ; if (T==NULL) T=ptr ; else q->nextsibling=ptr ; q=ptr ; }return(T) ;}数据结构严蔚敏7.4.2 有向图的强连通分量有向图的强连通分量 对于有向图，在其每一个对于有向图，在其每一个强连通分量中强连通分量中，，任何两个任何两个顶点都是可达的顶点都是可达的。

 V G，与，与V可相互到达的所有顶点可相互到达的所有顶点就是包含就是包含V的强连通分量的所有顶点的强连通分量的所有顶点 设从设从V可到达可到达 (以以V为起点的所有有向路径的终点为起点的所有有向路径的终点)的顶点集合为的顶点集合为T1(G)，而到达，而到达V (以以V为终点的所有有向为终点的所有有向路径的起点路径的起点)的顶点集合为的顶点集合为T2(G)，则包含，则包含V的强连通分的强连通分量的顶点集合是量的顶点集合是：： T1(G)∩T2(G) 求有向图求有向图G的强连通分量的基本步骤是的强连通分量的基本步骤是：：⑴ ⑴ 对对G进行深度优先遍历进行深度优先遍历，，生成生成G的深度优先生成的深度优先生成森林森林T⑵⑵ 对森林对森林T的顶点按中序遍历顺序进行编号的顶点按中序遍历顺序进行编号数据结构严蔚敏⑶⑶ 改变改变G中每一条弧的方向中每一条弧的方向，构成一个新的有向图，构成一个新的有向图G’⑷⑷ 按按⑵⑵中标出的顶点编号，从编号最大的顶点开始中标出的顶点编号，从编号最大的顶点开始对对G’进行深度优先搜索，得到一棵深度优先生成树进行深度优先搜索，得到一棵深度优先生成树。

若一次完整的搜索过程没有遍历若一次完整的搜索过程没有遍历G’的所有顶点，则的所有顶点，则从未访问的顶点中选择一个编号最大的顶点，由它从未访问的顶点中选择一个编号最大的顶点，由它开始再进行深度优先搜索，并得到另一棵深度优先开始再进行深度优先搜索，并得到另一棵深度优先生成树在该步骤中，每一次深度优先搜索所得到生成树在该步骤中，每一次深度优先搜索所得到的生成树中的顶点就是的生成树中的顶点就是G的一个强连通分量的所有顶的一个强连通分量的所有顶点 ⑸⑸ 重复步骤重复步骤⑷⑷ ，直到，直到G’中的所有顶点都被访问中的所有顶点都被访问 如图如图7-20(a)是求一棵有向树的强连通分量过程是求一棵有向树的强连通分量过程数据结构严蔚敏dacfeb(a) 有向图有向图G654321dacfeb(b) 执行步骤执行步骤(1)和和(2)acdfeb(c) 执行步骤执行步骤(3)adcbef( (d) 执行步骤执行步骤(4)和和(5)图图7-20 利用深度优先搜索求有向图的强连通分量利用深度优先搜索求有向图的强连通分量 在算法实现时，建立一个数组在算法实现时，建立一个数组in_order[n]存放深度存放深度优先生成森林的中序遍历序列。

对每个顶点优先生成森林的中序遍历序列对每个顶点v，在调用，在调用DFS函数结束时函数结束时，，将顶点依次存放在将顶点依次存放在数组数组in_order[n]中中图采用十字链表作为存储结构最合适图采用十字链表作为存储结构最合适算法实现算法实现：：int in_order[MAX_VEX] ;数据结构严蔚敏void DFS(OLGraph *G , int v) // 按弧的正向搜索按弧的正向搜索{ ArcNode *p ;Count=0 ;Visited[v]=TRUE ;for (p=G->xlist[v].firstout ; p!=NULL ; p=p->tlink)if (!Visited[p->headvex]) DFS(G , p->headvex) ;in_order[count++]=v ;} 数据结构严蔚敏void Rev_DFS(OLGraph *G , int v) { ArcNode *p ;Visited[v]=TRUE ;printf(“%d” , v) ; /* 输出顶点输出顶点 */for (p=G->xlist[v].firstin ; p!=NULL ; p=p->hlink)if (!Visited[p->tailvex]) Rev_DFS(G , p->tailvex) ;} /* 对图对图G按弧的逆向进行搜索按弧的逆向进行搜索 */void Connected_DG(OLGraph *G){ int k=1, v, j ; for (v=0; vvexnum; v++) Visited[v]=FALSE ;数据结构严蔚敏for (v=0; vvexnum; v++) /* 对图对图G正向遍历正向遍历 */if (!Visited[v]) DFS(G,v) ; for (v=0; vvexnum; v++) Visited[v]=FALSE ;for (j=G->vexnum-1; j>=0; j--) /* 对图对图G逆向遍历逆向遍历 */{ v=in_order[j] ;if (!Visited[v]) { printf(“\n第第%d个连通分量顶点个连通分量顶点: ”, k++) ; Rev_DFS(G, v) ; }}}数据结构严蔚敏7.5 最小生成树最小生成树 如果如果连通图连通图是一个带权图，则其生成树中的边也带是一个带权图，则其生成树中的边也带权，生成树中权，生成树中所有边的权值之和所有边的权值之和称为称为生成树的代价生成树的代价。

最小生成树最小生成树(Minimum Spanning Tree) ：：带权连带权连通图中代价最小的生成树称为最小生成树通图中代价最小的生成树称为最小生成树 最小生成树在实际中具有重要用途，如设计通信网最小生成树在实际中具有重要用途，如设计通信网设图的顶点表示城市，边表示两个城市之间的通信线路，设图的顶点表示城市，边表示两个城市之间的通信线路，边的权值表示建造通信线路的费用边的权值表示建造通信线路的费用n个城市之间最多个城市之间最多可以建可以建n (n-1)/2条线路条线路，如何选择其中的，如何选择其中的n-1条，使总的条，使总的建造费用最低建造费用最低? ? 构造最小生成树的算法有许多，基本原则是：构造最小生成树的算法有许多，基本原则是：数据结构严蔚敏 构造最小生成树的算法有许多，基本原则是：构造最小生成树的算法有许多，基本原则是：◆◆ 尽可能选取权值最小的边，但不能构成回路；尽可能选取权值最小的边，但不能构成回路；◆◆ 选择选择n-1条边构成最小生成树条边构成最小生成树以上的基本原则是基于以上的基本原则是基于MST的如下性质：的如下性质： 设设G=(V，，E)是一个带权连通图，是一个带权连通图，U是顶点集是顶点集V的一的一个非空子集。

若个非空子集若u∈∈U ，，v∈∈V-U，且，且(u, v)是是U中顶点到中顶点到V-U中顶点之间权值最小的边，则必存在一棵包含边中顶点之间权值最小的边，则必存在一棵包含边(u, v)的最小生成树的最小生成树数据结构严蔚敏证明证明：： 用反证法证明用反证法证明 设图设图G的任何一棵最小生成树都不包含边的任何一棵最小生成树都不包含边(u,v)设T是是G的一棵生成树的一棵生成树，则，则T是连通的是连通的，从，从u到到v必有一条路必有一条路径径(u,…,v)，当将，当将边边(u,v)加入到加入到T中时就构成了回路中时就构成了回路则路径路径(u, …,v)中必有一条边中必有一条边(u’,v’) ，满足，满足u’∈∈U ，，v’∈∈V-U 删去边边(u’,v’) 便可消除回路便可消除回路，同时得到另一棵生成，同时得到另一棵生成树树T’ 由于由于(u,v)是是U中顶点到中顶点到V-U中顶点之间权值中顶点之间权值最小的最小的边，故边，故(u,v)的权值不会高于的权值不会高于(u’,v’)的权值的权值，，T’的代价也的代价也不会高于不会高于T，， T’是是包含包含(u,v) 的一棵最小生成树的一棵最小生成树，，与假与假设矛盾设矛盾。

数据结构严蔚敏7.5.1 普里姆普里姆(Prim)算法算法 从连通网从连通网N=(U，，E)中找最小生成树中找最小生成树T=(U，，TE) 1 1 算法思想算法思想⑴⑴ 若从顶点若从顶点v0出发构造出发构造，，U={v0}，，TE={}；；⑵⑵ 先找权值最小的边先找权值最小的边(u，，v)，其中，其中u∈∈U且且v∈∈V-U，，并且子图不构成环，则并且子图不构成环，则U= U∪∪{v}，，TE=TE∪∪{(u，，v)} ；；⑶⑶ 重复重复⑵⑵ ，直到，直到U=V为止为止则则TE中必有中必有n-1条边条边，， T=(U，，TE)就是最小生成树就是最小生成树 如图如图7-21所提示数据结构严蔚敏v1v3v2v4v54857121136(a)v2v45(b)(c)v53v2v45(d)v14v53v2v45v36(e)v14v53v2v45图图7-21 按按prime算法从算法从v2出发构造最小生成树的过程出发构造最小生成树的过程数据结构严蔚敏2 2 算法实现说明算法实现说明 设用邻接设用邻接矩阵矩阵(二维数组二维数组)表示图表示图，两个顶点之间不，两个顶点之间不存在边的权值为机内允许的存在边的权值为机内允许的最大值最大值。

为便于算法实现，设置一个一为便于算法实现，设置一个一维数组维数组closedge[n]，，用来保存用来保存V- U中各顶点到中各顶点到U中顶点具有权值最小的边中顶点具有权值最小的边数组元素的类型定义是数组元素的类型定义是：：struct { int adjvex ; /* 边所依附于边所依附于U中的顶点中的顶点 */int lowcost ; /* 该边的权值该边的权值 */}closedge[MAX_EDGE] ;数据结构严蔚敏例如：例如： closedge[j].adjvex=k，表明边，表明边(vj, vk)是是V-U中顶中顶点点vj到到U中权值最小的边中权值最小的边，而，而顶点顶点vk是该边所依附的是该边所依附的U中中的顶点 closedge[j].lowcost存放该边的权值存放该边的权值 假设从顶点假设从顶点vs开始构造最小生成树开始构造最小生成树初始时令初始时令：：Closedge[s].lowcost=0 ：表明顶点：表明顶点vs首先加入到首先加入到U中；中；Closedge[k].adjvex=s ，，Closedge[k].lowcost=cost(k, s) 表示表示V-U中的各顶点到中的各顶点到U中权值最小的边中权值最小的边(k≠s) ，，cost(k, s)表示表示边边(vk, vs) 权值权值。

数据结构严蔚敏3 3 算法步骤算法步骤⑴⑴ 从从closedge中选择一条权值中选择一条权值(不为不为0)最小的边最小的边(vk, vj) ，然后做：，然后做：①① 置置closedge[k].lowcost为为0 ，表示，表示vk已加入到已加入到U中中②② 根据新加入根据新加入vk的更新的更新closedge中每个元素中每个元素：：  vi∈∈V-U ，若，若cost(i, k)≦≦colsedge[i].lowcost，，表明在表明在U中新加入顶点中新加入顶点vk后后，， (vi, vk)成为成为vi到到U中中权值最小的边权值最小的边，置：，置：Closedge[i].lowcost=cost(i, k)Closedge[i].adjvex=k ⑵⑵ 重复重复⑴⑴n-1次就得到次就得到最小生成树最小生成树 如表如表7-1所提示数据结构严蔚敏 在在Prime算法中，图采用邻接矩阵存储，所构造的算法中，图采用邻接矩阵存储，所构造的最小生成树用一维数组存储其最小生成树用一维数组存储其n-1条边，每条边的存储条边，每条边的存储结构描述：结构描述：typedef struct MSTEdge{ int vex1, vex2 ; /* 边所依附的图中两个顶点边所依附的图中两个顶点 */WeightType weight ; /* 边的权值边的权值 */}MSTEdge ;算法实现算法实现#define INFINITY MAX_VAL /* 最大值最大值 */ MSTEdge *Prim_MST(AdjGraph *G , int u) /* 从第从第u个顶点开始构造图个顶点开始构造图G的最小生成树的最小生成树 */{ MSTEdge TE[] ; // 存放最小生成树存放最小生成树n-1条边的数组指针条边的数组指针数据结构严蔚敏int j , k , v , min ;for (j=0; jvexnum; j++){ closedge[j].adjvex=u ; closedge[j].lowcost=G->adj[j][u] ;} /* 初始化数组初始化数组closedge[n] */ closedge[u].lowcost=0 ; /* 初始时置初始时置U={u} */ TE=(MSTEdge *)malloc((G->vexnum-1)*sizeof(MSTEdge)) ;for (j=0; jvexnum-1; j++){ min= INFINITY ;for (v=0; vvexnum; v++) if (closedge[v].lowcost!=0&& closedge[v].Lowcostvexnum; v++) if (G->adj[v][k]adj[v][k] ; closedge[v].adjvex=k ; } /* 修改数组修改数组closedge[n]的各个元素的值的各个元素的值 */}return(TE) ;} /* 求最小生成树的求最小生成树的Prime算法算法 */ 数据结构严蔚敏 iclosedge01234UV-UKadjvexlwcostv28v2 7v25v212{v2}{v1, v3, v4, v5}3adjvexlwcostv44v27v20v43{v2, v4}{v1, v3, v5}4adjvexlwcostv44v56v20v40{v2, v4 , v5} {v1, v3}0adjvexlwcostv40v56v20v40{v2, v4 , v5 , v1}{v3}2adjvexlwcostv40v50v20v40{v2, v4, v5 , v1 , v3}{}表表7-1 构造过程中辅组数组构造过程中辅组数组closedge中各分量的值的变化情况中各分量的值的变化情况数据结构严蔚敏算法分析算法分析：：设带权连通图有设带权连通图有n个顶点，则算法的主要执个顶点，则算法的主要执行是二重循环：行是二重循环： 求求closedge中权值最小的边，频度为中权值最小的边，频度为n-1；； 修改修改closedge数组，频度为数组，频度为n 。

因此因此，整个算法的时，整个算法的时间复杂度是间复杂度是O(n2)，与边的数目无关，与边的数目无关数据结构严蔚敏7.5.2 克鲁斯卡尔克鲁斯卡尔(Kruskal)算法算法1 算法思想算法思想 设设G=(V, E)是具有是具有n个顶点的连通网个顶点的连通网，，T=(U, TE)是是其最小生成树其最小生成树初值：初值：U=V，，TE={} 对对G中的边按权值大小从小到大依次选取中的边按权值大小从小到大依次选取⑴⑴ 选取权值最小的边选取权值最小的边(vi，，vj)，若，若边边(vi，，vj)加入到加入到TE后形成回路后形成回路，则舍弃该边，则舍弃该边( (边边(vi，，vj) ；否则，将；否则，将该边并入到该边并入到TE中中，，即即TE=TE∪∪{(vi，，vj)} ⑵⑵ 重复重复⑴⑴ ，直到，直到TE中包含有中包含有n-1条边为止条边为止 如图如图7-22所提示数据结构严蔚敏v1v3v2v4v54857121136(a)(b)3v5v4v36(e)v14v53v2v45图图7-22 按按kruskal算法构造最小生成树的过程算法构造最小生成树的过程(c)v143v5v4(d)v25v143v5v4数据结构严蔚敏2 算法实现说明算法实现说明 Kruskal算法实现的关键是算法实现的关键是：当一条边加入：当一条边加入到到TE的集合后的集合后，如何判断是否构成回路，如何判断是否构成回路? ? 简单的解决方法是简单的解决方法是：定义一个一维数组：定义一个一维数组Vset[n] ，，存放图存放图T中每个顶点所在的连通分量的编号。

中每个顶点所在的连通分量的编号◆◆ 初值初值：：Vset[i]=i，表示每个顶点各自组成一个连通，表示每个顶点各自组成一个连通分量，连通分量的编号简单地使用顶点在图中的位置分量，连通分量的编号简单地使用顶点在图中的位置( (编号编号) )◆ ◆ 当往当往T中增加一条边中增加一条边(vi，，vj) 时时，先检查，先检查Vset[i]和和Vset[j]值：值：☆☆ 若若Vset[i]=Vset[j]：表明：表明vi和和vj处在同一个连通分处在同一个连通分量中量中，，加入此边会形成回路加入此边会形成回路；；数据结构严蔚敏☆☆ 若若Vset[i]≠Vset[j]，则，则加入此边不会形成回路加入此边不会形成回路，，将此边加入到生成树的边集中将此边加入到生成树的边集中◆◆ 加入一条新边后，将两个不同的连通分量合并加入一条新边后，将两个不同的连通分量合并：：将一个将一个连通分量的编号换成另连通分量的编号换成另一个一个连通分量的编号连通分量的编号算法实现算法实现MSTEdge *Kruskal_MST(ELGraph *G) /* 用用Kruskal算法构造图算法构造图G的最小生成树的最小生成树 */{ MSTEdge TE[] ; int j, k, v, s1, s2, Vset[] ;WeightType w ;Vset=(int *)malloc(G->vexnum*sizeof(int)) ;数据结构严蔚敏for (j=0; jvexnum; j++)Vset[j]=j ; /* 初始化数组初始化数组Vset[n] */ sort(G->edgelist) ; /* 对表按权值从小到大排序对表按权值从小到大排序 */j=0 ; k=0 ;while (kvexnum-1&&j< G->edgenum){ s1=Vset[G->edgelist[j].vex1] ;s2=Vset[G->edgelist[j].vex2] ;/* 若边的两个顶点的连通分量编号不同若边的两个顶点的连通分量编号不同, 边加入到边加入到TE中中 */if (s1!=s2) { TE[k].vex1=G->edgelist[j].vex1 ; TE[k].vex2=G->edgelist[j].vex2 ; TE[k].weight=G->edgelist[j].weight ; 数据结构严蔚敏 k++ ; for (v=0; vvexnum; v++) if (Vset[v]==s2) Vset[v]=s1 ; }j++ ;}free(Vset) ; return(TE) ;} /* 求最小生成树的求最小生成树的Kruskal算法算法 */数据结构严蔚敏算法分析算法分析：：设带权连通图有设带权连通图有n个顶点，个顶点，e条边，则算法条边，则算法的主要执行是：的主要执行是：◆◆ Vset数组初始化数组初始化：时间复杂度是：时间复杂度是O(n) ；；◆◆ 边表按权值排序边表按权值排序：若采用堆排序或快速排序，时：若采用堆排序或快速排序，时间复杂度是间复杂度是O(e㏒㏒e) ；；◆◆ while循环：最大执行频度是循环：最大执行频度是O(n)，其中包含修改，其中包含修改Vset数组，共执行数组，共执行n-1次，时间复杂度是次，时间复杂度是O(n2) ；； 整个算法的时间复杂度是整个算法的时间复杂度是O(e㏒㏒e+n2) 。

数据结构严蔚敏7.6 有向无环图及其应用有向无环图及其应用 有向无环图有向无环图(Directed Acycling Graph)：是图：是图中没有回路中没有回路( (环环) )的有向图是一类具有代表性的图，主的有向图是一类具有代表性的图，主要用于研究工程项目的工序问题要用于研究工程项目的工序问题、、工程时间进度问题等工程时间进度问题等 一个一个工程工程(project)都可分为若干个称为都可分为若干个称为活动活动(active)的的子工程子工程(或工序或工序)，，各个子工程受到一定的条件约束各个子工程受到一定的条件约束：：某个子工程必须开始于另一个子工程完成之后；整个工某个子工程必须开始于另一个子工程完成之后；整个工程有一个开始点程有一个开始点( (起点起点) )和一个终点人们关心：和一个终点人们关心：◆◆ 工程能否顺利完成工程能否顺利完成? ?影响工程的关键活动是什么影响工程的关键活动是什么? ?◆◆ 估算整个工程完成所必须的最短时间是多少估算整个工程完成所必须的最短时间是多少? ?数据结构严蔚敏 对工程的活动加以抽象：图中顶点表示活动，有向对工程的活动加以抽象：图中顶点表示活动，有向边表示活动之间的优先关系，这样的有向图称为边表示活动之间的优先关系，这样的有向图称为顶点表顶点表示活动的网示活动的网(Activity On Vertex Network ，，AOV网网) 。

数据结构严蔚敏7.6.1 拓扑排序拓扑排序1 定义定义 拓扑排序拓扑排序(Topological Sort) ：由某个集合上的：由某个集合上的一个偏序得到该集合上的一个全序的操作一个偏序得到该集合上的一个全序的操作◆◆ 集合上的关系集合上的关系：集合：集合A上的关系是从上的关系是从A到到A的关系的关系(A A) ◆◆ 关系的自反性关系的自反性：若：若 a a∈∈A有有(a，，a)∈∈R，称集合，称集合A上的关系上的关系R是是自反的自反的◆◆ 关系的对称性关系的对称性：如果对于：如果对于a，，b b∈∈A ，只要，只要有有(a，，b)∈∈R就有就有(b，，a)∈∈R ，称集合，称集合A上的关系上的关系R是是对称的对称的数据结构严蔚敏◆◆ 关系的对称性与反对称性关系的对称性与反对称性：如果对于：如果对于a，，b b∈∈A ，，只要只要有有(a，，b)∈∈R就有就有(b，，a)∈∈R ，称集合，称集合A上的关上的关系系R是是对称的对称的如果对于如果对于a，，b b∈∈A ，仅当，仅当a=ba=b时有时有(a，，b)∈∈R和和(b，，a)∈∈R ，称集合，称集合A上的关系上的关系R是是反反对称对称的的。

◆◆ 关系的传递性关系的传递性：若：若a，，b，，c∈∈A，若，若(a，，b)∈∈R，，并并且且(b，，c)∈∈R ，则，则(a，，c)∈∈R ，称集合，称集合A上的关系上的关系R是是传递的传递的◆◆ 偏序偏序：若集合：若集合A上的关系上的关系R是是自反的自反的，，反反对称的对称的和和传递的传递的，则称，则称R是集合是集合A上的上的偏序关系偏序关系◆◆ 全序全序：设：设R是集合是集合A上的上的偏序关系偏序关系，， a a，，b∈∈A，，必有必有aRb或或bRa，， 则称则称R是集合是集合A上的上的全序关系全序关系 数据结构严蔚敏 即偏序是指集合中仅有部分元素之间可以比较，即偏序是指集合中仅有部分元素之间可以比较，而全序是指集合中任意两个元素之间都可以比较而全序是指集合中任意两个元素之间都可以比较 在在AOV网中网中，若有有向边，若有有向边，则，则i是是j的直接前驱的直接前驱，，j是是i的直接后继的直接后继；；推而广之推而广之，若从顶点，若从顶点i到顶点到顶点j有有向路有有向路径径，则，则i是是j的前驱的前驱，，j是是i的后继的后继。

在在AOV网中网中，，不能有环不能有环，否则，某项活动能否进行，否则，某项活动能否进行是以自身的完成作为前提条件是以自身的完成作为前提条件 检查方法：对有向图的顶点进行检查方法：对有向图的顶点进行拓扑排序拓扑排序，若所有，若所有顶点都在其顶点都在其拓扑有序序列中拓扑有序序列中，则，则无环无环 有向图的有向图的拓扑排序拓扑排序：：构造构造AOV网中网中顶点的一个顶点的一个拓扑线性序列拓扑线性序列(v’1,v’2, ⋯ ⋯,v’n)，使得该线性序列不仅保持，使得该线性序列不仅保持原来有向图中顶点之间的优先关系，而且对原图中没有原来有向图中顶点之间的优先关系，而且对原图中没有优先关系的顶点之间也建立一种优先关系的顶点之间也建立一种( (人为的人为的) )优先关系优先关系数据结构严蔚敏手工实现手工实现 如图如图7-23是一个有向图的拓扑排序过程是一个有向图的拓扑排序过程，其，其拓扑序拓扑序列是列是：： (v1,v6,v4,v3,v2,v5)2 拓扑排序拓扑排序算法算法算法思想算法思想①① 在在AOV网中选择一个没有前驱的顶点且输出网中选择一个没有前驱的顶点且输出；； ②② 在在AOV网中删除该顶点以及从该顶点出发的网中删除该顶点以及从该顶点出发的(以以该顶点为尾的弧该顶点为尾的弧)所有有向弧所有有向弧(边边) ；；③③ 重复重复①①、、②②，直到图中全部顶点都已输出，直到图中全部顶点都已输出( (图中图中无环无环) )或图中不存在无前驱的顶点或图中不存在无前驱的顶点( (图中必有环图中必有环) )。

数据结构严蔚敏3 算法实现说明算法实现说明◆ ◆ 采用正邻接链作为采用正邻接链作为AOV网的存储结构；网的存储结构；◆◆ 设立堆栈，用来暂存入度为设立堆栈，用来暂存入度为0的顶点；的顶点；◆◆ 删除顶点以它为尾的弧：弧头顶点的入度减删除顶点以它为尾的弧：弧头顶点的入度减1算法实现算法实现v1v2v3v4v5v6(a) 有向图有向图(b) 输出输出v1后后v4v2v3v5v6图图7-23 有向图的拓扑排序过程有向图的拓扑排序过程(c) 输出输出v6后后v4v2v3v5(d) 输出输出v4后后v2v3v5(e) 输出输出v3后后v2v5数据结构严蔚敏(1) 统计各顶点入度的函数统计各顶点入度的函数void count_indegree(ALGraph *G){ int k ; LinkNode *p ;for (k=0; kvexnum; k++)G->adjlist[k].indegree=0 ; /* 顶点入度初始化顶点入度初始化 */for (k=0; kvexnum; k++){ p=G->adjlist[k].firstarc ;while (p!=NULL) /* 顶点入度统计顶点入度统计 */ { G->adjlist[p->adjvex].indegree++ ; p=p->nextarc ; }}}数据结构严蔚敏(2) 拓扑排序算法拓扑排序算法int Topologic_Sort(ALGraph *G, int topol[]) /* 顶点的拓扑序列保存在一维数组顶点的拓扑序列保存在一维数组topol中中 */{ int k, no, vex_no, top=0, count=0, boolean=1 ; int stack[MAX_VEX] ; /* 用作堆栈用作堆栈 */LinkNode *p ;count_indegree(G) ; /* 统计各顶点的入度统计各顶点的入度 */for (k=0; kvexnum; k++)if (G->adjlist[k].indegree==0)stack[++top]=G->adjlist[k].data ; do{ if (top==0) boolean=0 ;数据结构严蔚敏else { no=stack[top--] ; /* 栈顶元素出栈栈顶元素出栈 */ topl[++count]=no ; /* 记录顶点序列记录顶点序列 */ p=G->adjlist[no].firstarc ; while (p!=NULL) /*删除以顶点为尾的弧删除以顶点为尾的弧*/ { vex_no=p->adjvex ; G->adjlist[vex_no].indegree-- ; if (G->adjlist[vex_no].indegree==0) stack[++top]=vex_no ; p=p->nextarc ; } }}while(boolean==0) ;数据结构严蔚敏if (countvexnum) return(-1) ;else return(1) ;}算法分析算法分析：：设设AOV网有网有n个顶点，个顶点，e条边，则算法的主条边，则算法的主要执行是：要执行是：◆◆ 统计各顶点的入度：时间复杂度是统计各顶点的入度：时间复杂度是O(n+e) ；；◆◆ 入度为入度为0的顶点入栈：时间复杂度是的顶点入栈：时间复杂度是O(n) ；；◆◆ 排序过程：顶点入栈和出栈操作执行排序过程：顶点入栈和出栈操作执行n次，入度减次，入度减1的操作共执行的操作共执行e次，时间复杂度是次，时间复杂度是O(n+e) ；； 因此，整个算法的时间复杂度是因此，整个算法的时间复杂度是O(n+e) 。

数据结构严蔚敏7.6.2 关键路径关键路径(Critical Path) 与与AOV网相对应的是网相对应的是AOE(Activity On Edge) ，是，是边表示活动的有向无环图，边表示活动的有向无环图，如图如图7-24所示所示图中顶点表图中顶点表示事件示事件(Event)，每个事件表示在其前的所有活动已经完，每个事件表示在其前的所有活动已经完成，其后的活动可以开始成，其后的活动可以开始；弧表示活动；弧表示活动，弧上的权值表，弧上的权值表示相应活动所需的时间或费用示相应活动所需的时间或费用v0v6v5v4v3v2v1v7v8a1=3a2=10a3=9a4=13a5=12a6=7a7=8a9=6a10=11a12=5a8=4a11=2图图7-24 一个一个AOE网网数据结构严蔚敏1 与与AOE有关的研究问题有关的研究问题◆◆ 完成整个工程至少需要多少时间完成整个工程至少需要多少时间? ?◆◆ 哪些活动是影响工程进度哪些活动是影响工程进度( (费用费用) )的关键的关键? ? 工程完成最短时间工程完成最短时间：从起点到终点的最长路径长度：从起点到终点的最长路径长度(路径上各活动持续时间之和路径上各活动持续时间之和) 。

长度最长的路径称为长度最长的路径称为关关键路径键路径，，关键路径关键路径上的活动称为上的活动称为关键活动关键活动关键活动是关键活动是影响整个工程的关键影响整个工程的关键 设设v0是起点，从是起点，从v0到到vi的的最长路径长度最长路径长度称为事件称为事件vi的的最早发生时间最早发生时间，即是以，即是以vi为尾的所有活动的最早发生时为尾的所有活动的最早发生时间 若活动若活动ai是弧是弧，持续时间是，持续时间是dut()，设：，设：◆ ◆ e(i)：表示活动：表示活动ai的最早开始时间；的最早开始时间；数据结构严蔚敏◆◆ l(i)：在不影响进度的前提下，表示活动：在不影响进度的前提下，表示活动ai的最晚的最晚开始时间开始时间；； 则则l(i)-e(i)表示活动表示活动ai的时间余量，若的时间余量，若l(i)-e(i)=0，表示活动，表示活动ai是关键活动是关键活动◆◆ ve(i)：表示事件：表示事件vi的最早发生时间，即从起点到顶的最早发生时间，即从起点到顶点点vi的最长路径长度的最长路径长度；； ◆◆ vl(i)：表示事件：表示事件vi的最晚发生时间的最晚发生时间。

则有以下关系则有以下关系：：e(i)=ve(j)l(i)= vl(k)-dut()7-10 j=0，表示，表示vj是起点是起点Max{ve(i)+dut()|是网中的弧是网中的弧}ve(j)=7-2数据结构严蔚敏 含义是含义是：：源点事件的最早发生时间设为源点事件的最早发生时间设为0；除源点；除源点外外，只有，只有进入顶点进入顶点vj的所有弧所代表的活动全部结束后的所有弧所代表的活动全部结束后，，事件事件vj才能发生才能发生即只有vj的所有前驱事件的所有前驱事件vi的最早发生的最早发生时间时间ve(i)计算出来后，才能计算计算出来后，才能计算ve(j) 方法是方法是：：对所有事件进行拓扑排序，然后依次按对所有事件进行拓扑排序，然后依次按拓扑顺序计算每个事件的最早发生时间拓扑顺序计算每个事件的最早发生时间ve(n-1) j=n-1，表示，表示vj是终点是终点Min{vl(k)-dut()|是网中的弧是网中的弧}vl(j)=7-3 含义是含义是：：只有只有vj的所有后继事件的所有后继事件vk的最晚发生时间的最晚发生时间vl(k)计算出来后，才能计算计算出来后，才能计算vl(j) 。

方法是方法是：：按拓扑排序的逆顺序，依次计算每个事件按拓扑排序的逆顺序，依次计算每个事件的最晚发生时间的最晚发生时间数据结构严蔚敏2 求求AOE中关键路径和关键活动中关键路径和关键活动⑴ ⑴ 算法思想算法思想① ① 利用拓扑排序求出利用拓扑排序求出AOE网的一个拓扑序列网的一个拓扑序列；； ②② 从拓扑排序的序列的第一个顶点从拓扑排序的序列的第一个顶点(源点源点)开始，开始，按按拓扑顺序拓扑顺序依次依次计算计算每个每个事件的最早发生时间事件的最早发生时间ve(i) ；； ③③ 从拓扑排序的序列的最后一个顶点从拓扑排序的序列的最后一个顶点(汇点汇点)开始，开始，按逆拓扑顺序按逆拓扑顺序依次依次计算计算每个每个事件的最晚发生时间事件的最晚发生时间vl(i) ；； 对于图对于图7-24的的AOE网，处理过程如下：网，处理过程如下：◆◆ 拓扑排序的序列是：拓扑排序的序列是： (v0, v1, v2, v3 , v4, v5 , v6 , v7 , v8)数据结构严蔚敏顶点顶点v0v1v2v3v4v5v6v7v8ve(i)031012 22 17 20 2833vl(i)091023 22 17 31 2833表表7-2 图图7-24的的ve(i)和和vl(i)的值的值◆◆ 根据计算根据计算ve(i)的公式的公式(7-2)和计算和计算vl(i)的公式的公式(7-3) ，计算各个事件的，计算各个事件的ve(i)和和vl(i)值，如表值，如表7-2所示。

所示◆◆ 根据关键路径的定义，知该根据关键路径的定义，知该AOE网的关键路径是：网的关键路径是： (v0, v2, v4, v7 , v8) 和和(v0, v2, v5 , v7 , v8) ◆◆ 关键路径活动是：关键路径活动是：，，，，，，，，，， 数据结构严蔚敏⑵ ⑵ 算法实现算法实现void critical_path(ALGraph *G){ int j, k, m ; LinkNode *p ;if (Topologic_Sort(G)==-1)printf(“\nAOE网中存在回路，错误网中存在回路，错误!!\n\n”) ;else{ for ( j=0; jvexnum; j++) ve[j]=0 ; /* 事件最早发生时间初始化事件最早发生时间初始化 */for (m=0 ; mvexnum; m++) { j=topol[m] ; p=G->adjlist[j].firstarc ; for (; p!=NULL; p=p->nextarc )数据结构严蔚敏 { k=p->adjvex ; if (ve[j]+p->weight>ve[k]) ve[k]=ve[j]+p->weight ; } } /* 计算每个事件的最早发生时间计算每个事件的最早发生时间ve值值 */for ( j=0; jvexnum; j++) vl[j]=ve[j] ; /* 事件最晚发生时间初始化事件最晚发生时间初始化 */for (m=G->vexnum-1; m>=0; m--) { j=topol[m] ; p=G->adjlist[j].firstarc ; for (; p!=NULL; p=p->nextarc ) { k=p->adjvex ; if (vl[k]-p->weightweight ;数据结构严蔚敏 } } /* 计算每个事件的最晚发生时间计算每个事件的最晚发生时间vl值值 */for (m=0 ; mvexnum; m++) { p=G->adjlist[m].firstarc ; for (; p!=NULL; p=p->nextarc ) { k=p->adjvex ; if ( (ve[m]+p->weight)==vl[k]) printf(“<%d, %d>, m, j”) ; } } /* 输出所有的关键活动输出所有的关键活动 */} /* end of else */ }数据结构严蔚敏⑶ ⑶ 算法分析算法分析 设设AOE网有网有n个事件，个事件，e个活动，则算法的主要执行个活动，则算法的主要执行是：是：◆◆ 进行拓扑排序：时间复杂度是进行拓扑排序：时间复杂度是O(n+e) ；；◆◆ 求每个事件的求每个事件的ve值和值和vl值：时间复杂度是值：时间复杂度是O(n+e) ；；◆◆ 根据根据ve值和值和vl值找关键活动：时间复杂度是值找关键活动：时间复杂度是O(n+e) ；； 因此，整个算法的时间复杂度是因此，整个算法的时间复杂度是O(n+e) 。

数据结构严蔚敏7.7 最短路径最短路径 若用带权图表示交通网若用带权图表示交通网，图中顶点表示地点，边代，图中顶点表示地点，边代表两地之间有直接道路，边上的权值表示路程表两地之间有直接道路，边上的权值表示路程(或所花费或所花费用或时间用或时间) 从一个地方到另一个地方的路径长度表示从一个地方到另一个地方的路径长度表示该路径上各边的权值之和该路径上各边的权值之和问题问题：：◆◆ 两地之间是否有通路两地之间是否有通路?◆◆ 在在有多条通路有多条通路的情况下的情况下，，哪条哪条最短最短? 考虑到交通网的有向性，直接讨论的是考虑到交通网的有向性，直接讨论的是带权有向图带权有向图的最短路径问题的最短路径问题，但解决问题的算法也适用于无向图，但解决问题的算法也适用于无向图 将一个路径的起始顶点称为源点将一个路径的起始顶点称为源点，最后一个，最后一个顶点称顶点称为终点数据结构严蔚敏7.7.1 单源点最短路径单源点最短路径 对于给定的有向图对于给定的有向图G=(V，，E)及单个源点及单个源点Vs，求，求Vs到到G的其余各顶点的最短路径。

的其余各顶点的最短路径 针对单源点的最短路径问题针对单源点的最短路径问题，，Dijkstra提出了一种提出了一种按路径长度递增次序按路径长度递增次序产生最短路径的算法，即产生最短路径的算法，即迪杰斯特迪杰斯特拉拉(Dijkstra)算法1 基本思想基本思想 从图从图的给定的给定源点到其它各个顶点之间客观上应存在源点到其它各个顶点之间客观上应存在一条最短路径，在这组最短路径中，按其长度的递增次一条最短路径，在这组最短路径中，按其长度的递增次序，依次求出到不同顶点的最短路径和路径长度序，依次求出到不同顶点的最短路径和路径长度数据结构严蔚敏 即按长度递增的次序生成各顶点的最短路径，即先即按长度递增的次序生成各顶点的最短路径，即先求出长度最小的一条最短路径，然后求出长度第二小的求出长度最小的一条最短路径，然后求出长度第二小的最短路径，依此类推，直到求出长度最长的最短路径最短路径，依此类推，直到求出长度最长的最短路径2 算法思想说明算法思想说明 设设给定给定源点为源点为Vs，，S为已求得最短路径的终点集，为已求得最短路径的终点集，开始时令开始时令S={Vs} 。

当求得第一条最短路径当求得第一条最短路径(Vs ，，Vi)后后，，S为为{Vs，，Vi} 根据以下结论可求下一条最短路径根据以下结论可求下一条最短路径 设下一条最短路径终点为设下一条最短路径终点为Vj ，则，则Vj只有：只有：◆◆ 源点到终点有直接的弧源点到终点有直接的弧；；◆◆ 从从Vs 出发到出发到Vj 的这条最短路径所经过的的这条最短路径所经过的所有中间所有中间顶点顶点必定在必定在S中中即只有这条最短路径的即只有这条最短路径的最后一条弧最后一条弧才是从才是从S内某个顶点连接到内某个顶点连接到S外的顶点外的顶点Vj 数据结构严蔚敏 若定义一个数组若定义一个数组dist[n]，其每个，其每个dist[i]分量保存从分量保存从Vs 出发出发中间只经过集合中间只经过集合S中中的的顶点顶点而而到达到达Vi的所有路径的所有路径中长度最小的路径长度值中长度最小的路径长度值，则，则下一条最短路径的终点下一条最短路径的终点Vj必定是不在必定是不在S中且值最小的顶点中且值最小的顶点，即，即：： dist[i]=Min{ dist[k]| Vk∈∈V-S } 利用上述公式就可以依次找出下一条利用上述公式就可以依次找出下一条最短路径。

最短路径3 算法步骤算法步骤①① 令令S={Vs} ，用带权的邻接矩阵表示有向图，对图，用带权的邻接矩阵表示有向图，对图中每个顶点中每个顶点Vi按以下原则置初值：按以下原则置初值：Wsi i≠s且且∈∈E，， wsi为弧上的权值为弧上的权值∞ ∞ i≠s且且不属于不属于Edist[i]=0 0 i =s数据结构严蔚敏② ② 选择一个顶点选择一个顶点Vj ，使得，使得：：dist[j]=Min{ dist[k]| Vk∈∈V-S }Vj就是求得的下一条最短路径终点就是求得的下一条最短路径终点，，将将Vj 并入到并入到S中，中，即即S=S∪∪{Vj} ③ ③ 对对V-S中的每个顶点中的每个顶点Vk ，，修改修改dist[k]，方法是，方法是：：若若dist[j]+Wjk

◆◆ 设数组设数组pre[n]保存从保存从Vs到其它顶点的到其它顶点的最短路径最短路径若若pre[i]=k，表示从，表示从Vs 到到Vi的的最短路径中，最短路径中，Vi的的前一前一个个顶点顶点是是Vk，即最短路径序列是，即最短路径序列是(Vs , …, Vk , Vi) ◆◆ 设数组设数组final[n]，标识一个顶点是否已加入，标识一个顶点是否已加入S中算法实现的关键算法实现的关键 待求点的最短路径长度本身就是待求的，又如何找待求点的最短路径长度本身就是待求的，又如何找出其中的最短呢？出其中的最短呢？数据结构严蔚敏BOOLEAN final[MAX_VEX] ;int pre[MAX_VEX] , dist[MAX_VEX] ;void Dijkstra_path (AdjGraph *G, int v) /* 从图从图G中的顶点中的顶点v出发到其余各顶点的最短路径出发到其余各顶点的最短路径 */{ int j, k, m, min ; for ( j=0; jvexnum; j++){ pre[j]=v ; final[j]=FALSE ;dist[j]=G->adj[v][j] ;} /* 各数组的初始化各数组的初始化 */dist[v]=0 ; final[v]=TRUE ; /* 设置设置S={v} */for ( j=0; jvexnum-1; j++) /* 其余其余n-1个顶点个顶点 */{ m=0 ;数据结构严蔚敏while (final[m]) m++; /* 找不在找不在S中的顶点中的顶点vk */min=INFINITY ; for ( k=0; kvexnum; k++) { if (!final[k]&&dist[m]vexnum; j++) { if (!final[j]&&(dist[m]+G->adj[m][j]adj[m][j] ; pre[j]=m ; } } /* 修改修改dist和和pre数组的值数组的值 */ 数据结构严蔚敏} /* 找到最短路径找到最短路径 */}5 算法分析算法分析 Dijkstra算法的主要执行是：算法的主要执行是：◆◆ 数组变量的初始化：时间复杂度是数组变量的初始化：时间复杂度是O(n) ；；◆◆ 求最短路径的二重循环：时间复杂度是求最短路径的二重循环：时间复杂度是O(n2) ；； 因此，整个算法的时间复杂度是因此，整个算法的时间复杂度是O(n2) 。

对图对图7-25的带权有向图，用的带权有向图，用Dijkstra算法求从顶点算法求从顶点0到其余各顶点的最短路径，数组到其余各顶点的最短路径，数组dist和和pre的各分量的变的各分量的变化如表化如表7-3所示数据结构严蔚敏0123452030606515201080403570图图7-25 带权有向图及其带权有向图及其邻接邻接矩阵矩阵∞ 20 60 ∞ 10 65∞ ∞ 30 70 ∞ ∞∞ ∞ ∞ 40 ∞ ∞∞ ∞ ∞ ∞ 35 ∞∞ ∞ ∞ ∞ ∞ 20∞ ∞ 15 80 ∞ ∞数据结构严蔚敏 顶点顶点步骤步骤12345S初态初态Distpre200600∞0100650{0}1Distpre200600∞0100304{0, 4}2Distpre200501901100304{0, 4, 1}3Distpre200455901100304{0, 4, 1, 5}4Distpre200455852100304{0, 4, 1, 5, 2}5Distpre200455852100304{0, 4, 1, 5, 2, 3}表表7-3 求最短路径时数组求最短路径时数组dist和和pre的各分量的变化情况的各分量的变化情况数据结构严蔚敏7.7.2 每一对顶点间的最短路径每一对顶点间的最短路径 用用Dijkstra算法也可以求得算法也可以求得有向图有向图G=(V，，E)中每一中每一对顶点间的最短路径。

方法是对顶点间的最短路径方法是：每次以一个不同的顶点：每次以一个不同的顶点为源点重复为源点重复Dijkstra算法便可求得算法便可求得每一对顶点间的最短每一对顶点间的最短路径路径，时间复杂度是，时间复杂度是O(n3) 弗罗伊德弗罗伊德(Floyd)提出了另一个算法提出了另一个算法，其时间复杂度，其时间复杂度仍是仍是O(n3) ，， 但算法形式更为简明，步骤更为简单，数但算法形式更为简明，步骤更为简单，数据结构仍然是基于图的据结构仍然是基于图的邻接邻接矩阵矩阵数据结构严蔚敏② ② 将图中一个顶点将图中一个顶点Vk 加入到加入到S中中，修改，修改A[i][j]的值的值，，修改方法是修改方法是：：A[i][j]=Min{A[i][j] , (A[i][k]+A[k][j]) }1 算法思想算法思想 设顶点集设顶点集S(初值为空初值为空)，用数组，用数组A的每个元素的每个元素A[i][j]保存从保存从Vi只经过只经过S中的顶点中的顶点到达到达Vj的最短路径长度，其的最短路径长度，其思想是：思想是：① ① 初始时令初始时令S={ } ，， A[i][j]的赋的赋初值方式是初值方式是：：Wij i≠j且且∈∈E，， wij为弧上的权值为弧上的权值∞ ∞ i≠j且且不属于不属于EA[i][j]=0 0 i =j时时数据结构严蔚敏原因原因：： 从从Vj只经过只经过S中的顶点中的顶点(Vk)到达到达Vj的路径长的路径长度可能比原来不经过度可能比原来不经过Vk的路径更短。

的路径更短③ ③ 重复重复②②，直到，直到G的所有顶点都加入到的所有顶点都加入到S中为止中为止2 算法实现算法实现◆◆ 定义定义二维数组二维数组Path[n][n](n为图的顶点数为图的顶点数) ，，元素元素Path[i][j]保存从保存从Vi到到Vj的最短路径所经过的顶点的最短路径所经过的顶点◆◆ 若若Path[i][j]=k：从：从Vi到到Vj 经过经过Vk ，最短路径序列，最短路径序列是是(Vi , …, Vk , …, Vj) ，则路径子序列，则路径子序列：：(Vi , …, Vk)和和(Vk , …, Vj)一定是一定是从从Vi到到Vk和和从从Vk到到Vj 的的最短路径最短路径从而可以根据从而可以根据Path[i][k]和和Path[k][j]的值再找到该路的值再找到该路径上所经过的其它顶点径上所经过的其它顶点，，…依此类推依此类推数据结构严蔚敏◆◆ 初始化为初始化为Path[i][j]=-1，表示，表示从从Vi到到Vj 不经过任不经过任何何(S中的中的中间中间)顶点顶点当某个顶点当某个顶点Vk加入到加入到S中后使中后使A[i][j]变小时变小时，令，令Path[i][j]=k。

表表7-4给出了利用给出了利用Floyd算法求算法求图图7-26的带权有向图的带权有向图的任意一对顶点间的任意一对顶点间最短路径的过程最短路径的过程图图7-26 带权有向图及其带权有向图及其邻接邻接矩阵矩阵 0 2 8∞ 0 4 5 ∞ 0V1482V2V05数据结构严蔚敏 根据上述过程中根据上述过程中Path[i][j]数组数组，，得出：得出：V0到到V1 ：：最短路径是最短路径是{ 0, 1 } ，路径长度是，路径长度是2 ；；V0到到V2 ：：最短路径是最短路径是{ 0, 1, 2 } ，路径长度是，路径长度是6 ；；V1到到V0 ：：最短路径是最短路径是{ 1, 2, 0 } ，路径长度是，路径长度是9 ；；表表7-4 用用Floyd算法求任意一对顶点间算法求任意一对顶点间最短路径最短路径 0 2 8∞ 0 45 ∞ 0 0 2 8∞ 0 4 5 7 0 0 2 6∞ 0 4 5 7 0 0 2 6 9 0 4 5 7 0A -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 -1 -1 1 -1 -1 -1 -1 0 -1 -1 -1 1 2 -1 -1 -1 0 -1PathS{ }{ 0 }{ 0, 1 }{ 0, 1, 2 }步骤步骤初态初态k=0K=1K=2数据结构严蔚敏V1到到V2 ：：最短路径是最短路径是{ 1, 2 } ，路径长度是，路径长度是4 ；；V2到到V0 ：：最短路径是最短路径是{ 2, 0 } ，路径长度是，路径长度是5 ；；V2到到V1 ：：最短路径是最短路径是{ 2, 0, 1 } ，路径长度是，路径长度是7 ；；算法实现算法实现int A[MAX_VEX][MAX_VEX] ;int Path[MAX_VEX][MAX_VEX] ;void Floyd_path (AdjGraph *G){ int j, k, m ; for ( j=0; jvexnum; j++)for ( k=0; kvexnum; k++){ A[j][k]=G->adj[j][k] ; Path[j][k]=-1 ; } /* 各数组的初始化各数组的初始化 */数据结构严蔚敏for ( m=0; mvexnum; m++)for ( j=0; jvexnum; j++)for ( k=0; kvexnum; k++) if ((A[j][m]+A[m][k])vexnum; j++)for ( k=0; kvexnum; k++)if (j!=k) { printf(“%d到到%d的最短路径为的最短路径为:\n”, j, k) ; printf(“%d ”,j) ; prn_pass(j, k) ; printf(“%d ”, k) ;数据结构严蔚敏 printf(“最短路径长度为最短路径长度为: %d\n”,A[j][k]) ; }} /* end of Floyd */void prn_pass(int j , int k){ if (Path[j][k]!=-1){ prn_pass(j, Path[j][k]) ;printf(“, %d” , Path[j][k]) ;prn_pass(Path[j][k], k) ;}}数据结构严蔚敏习习 题题 七七⑴⑴ 分析并回答下列问题：分析并回答下列问题：①① 图中顶点的度之和与边数之和的关系图中顶点的度之和与边数之和的关系? ②② 有向图中顶点的入度之和与出度之和的关系有向图中顶点的入度之和与出度之和的关系? ③③ 具有具有n个顶点的无向图，至少应有多少条边才能个顶点的无向图，至少应有多少条边才能确保是一个连通图确保是一个连通图? 若采用邻接矩阵表示，则该矩若采用邻接矩阵表示，则该矩阵的大小是多少阵的大小是多少?④④ 具有具有n个顶点的有向图，至少应有多少条弧才能个顶点的有向图，至少应有多少条弧才能确保是强连通图的确保是强连通图的? 为什么为什么? ⑵⑵ 设一有向图设一有向图G=(V,E)，其中，其中V={a,b,c,d,e} ，， E={, , , , , ,, , }数据结构严蔚敏① ① 请画出该有向图，并求各顶点的入度和出度。

请画出该有向图，并求各顶点的入度和出度② ② 分别画出有向图的正分别画出有向图的正邻接链表和逆邻接链表邻接链表和逆邻接链表⑶⑶ 对图对图7-27所示的带权无向图所示的带权无向图 ①① 写出相应的邻接矩阵表示写出相应的邻接矩阵表示 ②② 写出相应的边表表示写出相应的边表表示 ③③ 求出各顶点的度求出各顶点的度⑷⑷ 已知有向图的逆邻接链表如图已知有向图的逆邻接链表如图7-28所示 ①① 画出该有向图画出该有向图 ②② 写出相应的邻接矩阵表示写出相应的邻接矩阵表示 ③③ 写出从顶点写出从顶点a开始的深度优先和广度优先遍历开始的深度优先和广度优先遍历序列 ④④ 画出从顶点画出从顶点a开始的深度优先和广度优先生成开始的深度优先和广度优先生成树数据结构严蔚敏1452639682755349图图7-27 带权无向图带权无向图图图7-28 有向图的逆邻接链表有向图的逆邻接链表4 ⋀0204 ⋀13 ⋀22 ⋀4 ⋀3MAX_VEX-101234v1v2v3v4v5┇ ┇┇ ┇图图7-29 带权有向图带权有向图V2V4V5V6V110101543061015520V3图图7-30 带权有向图带权有向图adecfb354423956数据结构严蔚敏⑸ ⑸ 一个带权连通图的最小生成树是否唯一一个带权连通图的最小生成树是否唯一? ?在什么情在什么情况下可能不唯一况下可能不唯一? ?⑹ ⑹ 对于图对于图7-27所示的带权无向图。

所示的带权无向图① ① 按照按照Prime算法给出从顶点算法给出从顶点2开始构造最小生成开始构造最小生成树的过程树的过程② ② 按照按照Kruskal算法给出最小生成树的过程算法给出最小生成树的过程⑺ ⑺ 已知带权有向图已知带权有向图如如图图7-29所示，请利用所示，请利用Dijkstra算算法从顶点法从顶点V4出发到其余顶点的最短路径及长度出发到其余顶点的最短路径及长度，，给出相给出相应的求解步骤应的求解步骤⑻ ⑻ 已知带权有向图已知带权有向图如如图图7-30所示，请利用所示，请利用Floyd算法算法求出每对顶点之间的最短路径及路径长度求出每对顶点之间的最短路径及路径长度⑼ ⑼ 一个一个AOV网用邻接矩阵表示网用邻接矩阵表示，如图，如图7-31用拓扑排序求该排序求该AOV网的一个拓扑序列网的一个拓扑序列，，给出相应的步骤给出相应的步骤数据结构严蔚敏⑽ ⑽ 拓扑排序的结果不是唯一的，请给出如图拓扑排序的结果不是唯一的，请给出如图7-32所所示的有向图的所有可能的拓扑序列示的有向图的所有可能的拓扑序列⑾ ⑾ 请在深度优先搜索算法的基础上设计一个对有向请在深度优先搜索算法的基础上设计一个对有向无环图进行拓扑排序的算法。

无环图进行拓扑排序的算法⑿ ⑿ 设计一个算法利用图的遍历方法输出一个无向图设计一个算法利用图的遍历方法输出一个无向图G中从顶点中从顶点Vi到到Vj的长度为的长度为S的简单路径，设图采用邻接的简单路径，设图采用邻接链表作为存储结构链表作为存储结构⒀ ⒀ 假设一个工程的进度计划用假设一个工程的进度计划用AOE网表示网表示，如图，如图7-33所示① ① 求出每个事件的最早发生时间和最晚发生时间求出每个事件的最早发生时间和最晚发生时间② ② 该工程完工至少需要多少时间该工程完工至少需要多少时间? ?③ ③ 求出所有关键路径和关键活动求出所有关键路径和关键活动数据结构严蔚敏图图7-33 一个一个AOE网网v0v5v4v7v3v2v1v6v8a1=5a2=6a3=3a8=5a4=12a5=3a10=4a9=1a12=5a11=4a6=3a7=3a13=2v9a14=20 1 1 0 0 0 00 0 0 1 1 1 00 0 0 0 1 0 10 0 0 0 0 0 00 0 0 0 0 0 10 0 0 0 0 0 10 0 0 0 0 0 0V0V1V2V3V4V5V6图图7-31 一个一个AOV网的邻接矩阵网的邻接矩阵图图7-32 有向图有向图V3V7V6V5V4V2V1V9V8数据结构严蔚敏第第8章章 动态存储管理动态存储管理 8.1 概述概述 程序执行过程中，程序执行过程中，(数据数据)结构中的每一个数据元素结构中的每一个数据元素都对应一定的存储空间，数据元素的访问都是通过对应都对应一定的存储空间，数据元素的访问都是通过对应的存储单元来进行的。

存储空间的分配与管理是由操作的存储单元来进行的存储空间的分配与管理是由操作系统或编译程序负责实现的，是一个复杂而又重要的问系统或编译程序负责实现的，是一个复杂而又重要的问题，现代的存储管理往往采用动态存储管理思想题，现代的存储管理往往采用动态存储管理思想 动态存储管理动态存储管理：如何根据：如何根据“存储请求存储请求”分配分配内存空间？如何内存空间？如何回收回收被释放的被释放的(或不再使用的或不再使用的)内内存空间？存空间？ 数据结构严蔚敏 对于允许进行动态存储分配的程序设计语言，操作对于允许进行动态存储分配的程序设计语言，操作系统在内存中划出一块地址连续的大区域系统在内存中划出一块地址连续的大区域(称为称为堆堆) ，由，由设计者在程序中利用语言提供的内存动态分配函数设计者在程序中利用语言提供的内存动态分配函数(如如C的的malloc() ，，calloc()，，free()函数，函数，C++的的new，，delete函数等函数等)来实现对来实现对堆堆的使用1 两个基本概念两个基本概念◆◆ 占用块占用块：已分配给用户使用的一块地址连续的内：已分配给用户使用的一块地址连续的内存区域；存区域；◆◆ 空闲块空闲块：未曾分配的地址连续的内存区域；：未曾分配的地址连续的内存区域；2 用户请求分配内存用户请求分配内存，，系统的处理方式系统的处理方式 当有用户程序进入系统请求分配内存时，系统有两当有用户程序进入系统请求分配内存时，系统有两种处理方式：种处理方式：数据结构严蔚敏⑴⑴ 系统从高地址空闲块中进行分配，直到分配无法系统从高地址空闲块中进行分配，直到分配无法进行时，才回收所有用户不再使用的空闲块，重新进行时，才回收所有用户不再使用的空闲块，重新组织一个大的空闲块来再分配；组织一个大的空闲块来再分配；⑵⑵ 用户程序一旦运行结束，便将它所占内存区释放用户程序一旦运行结束，便将它所占内存区释放成为空闲块，同时，每当新用户请求分配内存时，成为空闲块，同时，每当新用户请求分配内存时，系统需要巡视整个内存区中所有空闲块，并从中找系统需要巡视整个内存区中所有空闲块，并从中找出一个出一个“合适合适”的空闲块分配之。

的空闲块分配之 对于对于⑵⑵的情况，系统需建立一张的情况，系统需建立一张“可利用空间表可利用空间表” 程序运行过程中，不断地对堆中的部分区域进行分程序运行过程中，不断地对堆中的部分区域进行分配和释放，堆中会出现占用块和空闲块交错的状态，如配和释放，堆中会出现占用块和空闲块交错的状态，如图图8-1所示数据结构严蔚敏3 动态存储分配的基本问题动态存储分配的基本问题⑴⑴ 当某一时刻用户程序请求分配当某一时刻用户程序请求分配400个字节的存储空间，如何分配个字节的存储空间，如何分配?◆◆ 将块将块A分配给用户程序分配给用户程序?◆◆ 从大块从大块C中划出一部分分配给用中划出一部分分配给用户程序户程序?⑵⑵ 当某一时刻分配当某一时刻分配B块的用户程序运块的用户程序运行结束，行结束，B块要进行回收，如何回收块要进行回收，如何回收? ◆◆ B块直接回收并成为一个独立的块直接回收并成为一个独立的空闲块空闲块? ◆◆ B块回收并和前、后的空闲块块回收并和前、后的空闲块A、、C合并后形成一个更大的空闲块合并后形成一个更大的空闲块?⋮AC⋮B12196H11000H12004H12240H130EFH图图8-1 堆的状态堆的状态数据结构严蔚敏8.2 可利用空间表及分配方法可利用空间表及分配方法 可利用空间表中包含所有可分配的空闲块，当用户可利用空间表中包含所有可分配的空闲块，当用户请求分配时，系统从可利用空间表中删除一个结点分配请求分配时，系统从可利用空间表中删除一个结点分配之；当用户释放其所占内存时，系统即回收并将它插入之；当用户释放其所占内存时，系统即回收并将它插入到可利用空间表中。

因此，可利用空间表亦称做到可利用空间表中因此，可利用空间表亦称做“存储存储池池”数据结构严蔚敏8.2.1 可利用空间表的组织可利用空间表的组织 可用空间表的组织有两种方式：目录表方式和链表可用空间表的组织有两种方式：目录表方式和链表方式，如图方式，如图8-2所示所示 动态存储管理中需要不断地进行动态存储管理中需要不断地进行空闲块的分配和释放，对目录表来说管理复杂，因此，空闲块的分配和释放，对目录表来说管理复杂，因此，可利用空间表通常以链表方式组织可利用空间表通常以链表方式组织 当可利用空间表以链表方式组织时，每个空闲块就当可利用空间表以链表方式组织时，每个空闲块就是链表中的一个结点是链表中的一个结点◆◆ 分配时：从链表中找到一个合适的结点加以分配，分配时：从链表中找到一个合适的结点加以分配，然后将该结点删除之；然后将该结点删除之；◆◆ 回收时：将空闲块插入到链表中回收时：将空闲块插入到链表中 实际的动态存储管理实施时，具体的分配和释放的实际的动态存储管理实施时，具体的分配和释放的策略取决于结点策略取决于结点( (空闲块空闲块) )的结构。

的结构数据结构严蔚敏(a) 堆的状态堆的状态⋮13196H11000H12004H13740H160EFH00000H216EFH326EFH起始地址起始地址 空闲块大小空闲块大小 使用情况使用情况12004H 4498 空闲空闲13740H 10671 空闲空闲216EFH 69632 空闲空闲(b) 目录表方式目录表方式0 4498 0 10671 0 69632 ⋀av(c) 链表方式链表方式图图8-2 动态存储管理过程中的内存状态和空闲表结构动态存储管理过程中的内存状态和空闲表结构数据结构严蔚敏8.2.2 结点结构方式与分配策略结点结构方式与分配策略1 请求分配的块大小相同请求分配的块大小相同 将进行动态存储分配的整个内存区域将进行动态存储分配的整个内存区域(堆堆)按所需大小按所需大小分割成若干大小相同的块，然后用指针链接成一个可利分割成若干大小相同的块，然后用指针链接成一个可利用空间表。

用空间表◆◆ 分配时：从表的首结点分配，然后删除该结点；分配时：从表的首结点分配，然后删除该结点；◆◆ 回收时：将释放的空闲块插入表头回收时：将释放的空闲块插入表头2 请求分配的块大小只有几种规格请求分配的块大小只有几种规格 根据统计概率事先对动态分配的堆建立若干个可利根据统计概率事先对动态分配的堆建立若干个可利用空间链表，同一链表中的结点用空间链表，同一链表中的结点(块块)大小都相同大小都相同数据结构严蔚敏◆◆ 分配时分配时：根据请求的大小：根据请求的大小，将最接近该大小的某，将最接近该大小的某个链表的首结点分配给用户若剩余部分正好差不个链表的首结点分配给用户若剩余部分正好差不多是另一种规格大小，则将剩余部分插入到另一种多是另一种规格大小，则将剩余部分插入到另一种规格的链表中，然后删除该结点规格的链表中，然后删除该结点；；◆◆ 回收时回收时：只要：只要将所释放的空闲块插入到相应大小将所释放的空闲块插入到相应大小的表头存在的问题存在的问题：： 当请求分配的块空间大小比最大规格的结点还大时当请求分配的块空间大小比最大规格的结点还大时，，分配不能进行分配不能进行。

而实际上而实际上内存空间内存空间却却可能存在比所需大可能存在比所需大小还要大的的连续空间，小还要大的的连续空间，应该能够分配应该能够分配数据结构严蔚敏3 3 请求分配的块大小不确定请求分配的块大小不确定 系统开始时，整个堆空间是一个空闲块，链表中只系统开始时，整个堆空间是一个空闲块，链表中只有一个大小为整个堆的结点，随着分配和回收的进行，有一个大小为整个堆的结点，随着分配和回收的进行，链表中的结点大小和个数动态变化链表中的结点大小和个数动态变化 由于链表中结点大小不同，结点中除标志域和链域由于链表中结点大小不同，结点中除标志域和链域之外，尚需有一个结点大小域之外，尚需有一个结点大小域(size)，以保存空闲块的，以保存空闲块的大小，如大小，如图图8-2(b) 问题问题：：若用户请求分配大小为若用户请求分配大小为n(kB)的内存，而链的内存，而链表中有若干大小不小于表中有若干大小不小于n的空闲块时，如何分配的空闲块时，如何分配?有有3种种分配策略分配策略数据结构严蔚敏⑴ ⑴ 首次拟合法首次拟合法(First fit)◆◆ 分配时分配时：：从表头指针开始查找可利用空间表，将从表头指针开始查找可利用空间表，将找到的第一个不小于找到的第一个不小于n的空闲块的部分的空闲块的部分( (所需要大小所需要大小) )分配给用户，剩下部分仍然是一个空闲块结点；分配给用户，剩下部分仍然是一个空闲块结点；◆◆ 回收时回收时：：将释放的空闲块插入在链表的表头。

将释放的空闲块插入在链表的表头特点特点：：分配时随机的；回收时仅需插入到表头分配时随机的；回收时仅需插入到表头⑵⑵ 最佳拟合法最佳拟合法(Best fit)◆◆ 分配时分配时：扫描整个：扫描整个可利用空间链表，找到一个大可利用空间链表，找到一个大小满足要求且最接近小满足要求且最接近n空闲块，将其中的一部分空闲块，将其中的一部分( (所所需要大小需要大小) )分配给用户，剩下部分仍然是一个空闲块分配给用户，剩下部分仍然是一个空闲块结点；结点；数据结构严蔚敏◆◆ 回收时回收时：：只要将释放的空闲块插入到链表的合适只要将释放的空闲块插入到链表的合适位置 为了使分配时不需要扫描整个可利用空间链表，链为了使分配时不需要扫描整个可利用空间链表，链表组织表组织( (块回收时块回收时) )成成按从小到大排序按从小到大排序( (升序升序) ) 优点优点：：适用于请求分配的内存块大小范围较广的系统；适用于请求分配的内存块大小范围较广的系统；缺点缺点：：系统容易产生无法分配的内存碎片；无论分配系统容易产生无法分配的内存碎片；无论分配与回收，都需要查找表，最费时；与回收，都需要查找表，最费时；⑶⑶ 最差拟合法最差拟合法(Worst fit)◆◆ 分配时分配时：扫描整个：扫描整个可利用空间链表，找到一个大可利用空间链表，找到一个大小最大的空闲块，将其中的一部分小最大的空闲块，将其中的一部分( (所需要大小所需要大小) )分配分配给用户，剩下部分仍然是一个空闲块结点；给用户，剩下部分仍然是一个空闲块结点；数据结构严蔚敏◆◆ 回收时回收时：：只要将释放的空闲块插入到链表的合适只要将释放的空闲块插入到链表的合适位置。

位置 为了使分配时不需要扫描整个可利用空间链表，链为了使分配时不需要扫描整个可利用空间链表，链表组织表组织( (块回收时块回收时) )成成按从大到小按从大到小排序排序( (降序降序) ) 特点特点：：适用于请求分配的内存块的大小范围较窄的系适用于请求分配的内存块的大小范围较窄的系统；分配无需查找，回收需要查找适当的位置统；分配无需查找，回收需要查找适当的位置4 4 选择分配策略需考虑的因素选择分配策略需考虑的因素 用户的逻辑要求、请求分配量的大小分布、分配和用户的逻辑要求、请求分配量的大小分布、分配和释放的频率以及效率对系统的重要性释放的频率以及效率对系统的重要性数据结构严蔚敏8.3 边界标识法边界标识法 边界标识法边界标识法(Boundary Tag Method)是操作系统中是操作系统中一种常用的进行动态分配的存储管理方法一种常用的进行动态分配的存储管理方法 系统将所有的空闲块链接成一个双重循环链表，分系统将所有的空闲块链接成一个双重循环链表，分配可采用几种方法配可采用几种方法(前述前述) 系统的特点系统的特点 每个内存区域的头部和底部两个边界上分别设置标每个内存区域的头部和底部两个边界上分别设置标识，以标识该区域为占用块或空闲块，在回收块时易于识，以标识该区域为占用块或空闲块，在回收块时易于判别在物理位置上与其相邻的内存区域是否为空闲块，判别在物理位置上与其相邻的内存区域是否为空闲块，以便于将所有地址连续的空闲存储区合并成一个尽可能以便于将所有地址连续的空闲存储区合并成一个尽可能大的空闲块。

大的空闲块数据结构严蔚敏8.3.1 可利用空闲表结点结构可利用空闲表结点结构Llink tag size rlinkuplink tag spaceheadfoottypedef struct word{ Union{ struct word *llink;struct word *uplink; };int tag;int size;struct word *rlink;OtherType other;}WORD, head, foot, *Space;#define FootLoc(p) p+p->size-1数据结构严蔚敏8.3.2 分配算法分配算法 分配算法比较简单，可采用前述三种方法中的任一分配算法比较简单，可采用前述三种方法中的任一种进行分配设采用首次拟合法，为了使系统更有效地种进行分配设采用首次拟合法，为了使系统更有效地运行，在边界标识法中还做了两条约定：运行，在边界标识法中还做了两条约定：①① 选定适当常量选定适当常量e，设待分配空闲块，设待分配空闲块、请求分配空、请求分配空间的大小分别为间的大小分别为m 、、 n 。

◆ ◆ 当当m-n≤e时：将整个空闲块分配给用户；时：将整个空闲块分配给用户；◆ ◆ 当当m-n>e时：则只分配请求的大小时：则只分配请求的大小n给用户；给用户；作用作用：：尽量减少空闲块链表中出现小碎片尽量减少空闲块链表中出现小碎片(容量容量≤e) ，提，提高分配效率；减少对空闲块链表的维护工作量为了避高分配效率；减少对空闲块链表的维护工作量为了避免修改指针，约定将高地址部分分配给用户免修改指针，约定将高地址部分分配给用户数据结构严蔚敏②② 空闲块链表中的结点数可能很多，为了提高查找空闲块链表中的结点数可能很多，为了提高查找空闲块的速度和防止小容量结点密集，每次查找时从空闲块的速度和防止小容量结点密集，每次查找时从不同的结点开始不同的结点开始————上次刚分配结点的后继结点开始上次刚分配结点的后继结点开始Space AllocBoundTag( Space *pav, int n ){ p = pav ; for ( ; p &&p->sizerlink!=pav; p=p->rlink )if ( !p || p->sizerlink ; if ( p->size–n<=e )数据结构严蔚敏 { if ( pav==p ) pav=NULL ; else { pav->llink=p->link ; p->llink->rlink=pav ; } p->tag=f->tag=1 ; } else { f->tag=1 ; p->size-=n ; f= FootLoc( p ) ; f->tag= 0 ; f->uplink=p ; p=f+1; p->tag=1 ; p->size=n ; }return p ; }}数据结构严蔚敏8.3.3 回收算法回收算法 当用户释放占用块，系统需立即回收以备新的请求当用户释放占用块，系统需立即回收以备新的请求产生时进行再分配。

关键的是使物理地址毗邻的空闲块产生时进行再分配关键的是使物理地址毗邻的空闲块合并成一个尽可能大的结点，则需检查刚释放的占用块合并成一个尽可能大的结点，则需检查刚释放的占用块的左、右紧邻是否为空闲块的左、右紧邻是否为空闲块 假设所释放的块的头地址为假设所释放的块的头地址为p，则与其低地址紧邻，则与其低地址紧邻的块的底部地址为的块的底部地址为p-1；与其高地址紧邻的块的头地址；与其高地址紧邻的块的头地址为为p+p->size，它们中的标志域就表明了两个相邻块的使，它们中的标志域就表明了两个相邻块的使用状况：用状况：◆◆ 若若(p-1)->tag=0 ：则左邻块为空闲块；：则左邻块为空闲块；◆◆ 若若(p+p->size)->tag=0 ：则右邻块为空闲块；：则右邻块为空闲块；回收算法需要考虑的回收算法需要考虑的4种情况：种情况：数据结构严蔚敏⑴⑴ 释放块的左、右邻块均为占用块释放块的左、右邻块均为占用块 将被释放块简单地插入到空闲块链表中即可将被释放块简单地插入到空闲块链表中即可p->tag=0 ; FootLoc(p)->uplink=p ; FootLoc(p)->tag=0 ;if ( !pav ) pav=p->llink=p->rrlink=p ;else { q=pav->llink ; P->rlink=pav ; p->llink=q ; q->rlink=pav->llink=p ;Pav=p ; }数据结构严蔚敏⑵⑵ 释放块的左邻块空闲而右邻块为占用释放块的左邻块空闲而右邻块为占用 和左邻块合并成一个大的空闲块结点，改变左邻块和左邻块合并成一个大的空闲块结点，改变左邻块的的size域及重新设置域及重新设置(合并后合并后)结点的底部。

结点的底部n=p->size ; s=(p-1)->uplink ; s->size+=n;f=p+n–1 ; f->uplink=s ; f->tag=0 ;⑶⑶ 释放块的左邻占用而右邻空闲释放块的左邻占用而右邻空闲 和右邻块合并成一个大的空闲块结点，改变右邻块和右邻块合并成一个大的空闲块结点，改变右邻块的的size域及重新设置域及重新设置(合并后合并后)结点的头部结点的头部t=p+p->size ; p->tag=0 ; q=t->llink ; p->llink=q ; q->rlink=p ; q1=t->rlink ; p->rlink=q1 ; q1->llink=p ; p->size+=t->size ; FootLoc(t)->uplink=p ;数据结构严蔚敏⑷⑷ 释放块的左、右邻释放块的左、右邻块块均为空闲块均为空闲块 和左、右邻块合并成一个大的空闲块结点，改变左和左、右邻块合并成一个大的空闲块结点，改变左邻块的邻块的size域及重新设置域及重新设置(合并后合并后)结点的底部结点的底部n=p->size ; s=(p-1)->uplink ; t=p+p->size ; s->size+=n+t->size ; q=t->llink ; q1=t->rlink ;q->rlink=q1 ; q1->llink=q ; FootLoc(t)->uplink=s;数据结构严蔚敏8.4 伙伴系统伙伴系统 伙伴系统是一种非顺序内存管理方法，不是以顺伙伴系统是一种非顺序内存管理方法，不是以顺序片段来分配内存，是把内存分为两个部分，只要有可序片段来分配内存，是把内存分为两个部分，只要有可能，这两部分就可以合并在一起能，这两部分就可以合并在一起; 且这两部分从来不是且这两部分从来不是自由的，程序可以使用伙伴系统中的一部分或者两部分自由的，程序可以使用伙伴系统中的一部分或者两部分都不使用。

与边界标识法类似，所不同是：无论都不使用与边界标识法类似，所不同是：无论占用块占用块或空闲块或空闲块，其，其大小均为大小均为2的的k次幂次幂数据结构严蔚敏8.4.1 可利用空间表的结构可利用空间表的结构 为了再分配时查找方便起见，我们将所有大小相同为了再分配时查找方便起见，我们将所有大小相同的空闲块建于一张子表中每个子表是一个双重链表，的空闲块建于一张子表中每个子表是一个双重链表，这样的链表可能有这样的链表可能有m+1个，将这个，将这m+1个表头指针用向量个表头指针用向量结构组织成一个表，这就是伙伴系统的可利用空间表结构组织成一个表，这就是伙伴系统的可利用空间表 可利用空间表的数据类型描述如下：可利用空间表的数据类型描述如下：数据结构严蔚敏#define M 16typedef struct WORD_b{ WORD_b * llink; /* 前驱结点前驱结点 */int tag; /* 使用标识使用标识 */int kval; /* 块的大小块的大小,是是2的幂次的幂次 */WORD_b *rlink; /* 后继结点后继结点 */OtherType other;} WORD_b, head; typedef struct HeadNode{ int nodesize;WORD_b * first;}FreeList[M+1];数据结构严蔚敏8.4.2 分配算法分配算法 当程序提出大小为当程序提出大小为n的内存分配请求时，首先的内存分配请求时，首先在可在可利用表中利用表中查找大小与查找大小与n相匹配的子表相匹配的子表.1 算法思想算法思想◆◆ 若存在若存在2k-1

的子表中数据结构严蔚敏2 说明说明 在进行大小为在进行大小为n(2k-i-1

也不合并1 伙伴空闲块的确定伙伴空闲块的确定 设设p是大小为是大小为2k的空闲块的首地址，且的空闲块的首地址，且p MOD 2k+1 =0，则首地址为，则首地址为p和和p+2k的两个空闲块的两个空闲块“互为伙伴互为伙伴”首地址为首地址为p大小为大小为2k的内存块的，其伙伴的首地址为：的内存块的，其伙伴的首地址为： buddy(p,k)=p+2k 若若p MOD 2k+1 =0P-2k 若若p MOD 2k+1 =2k数据结构严蔚敏2 回收算法回收算法 设要回收的空闲块的首地址是设要回收的空闲块的首地址是p，其大小为，其大小为2k的，的，算法思想是：算法思想是：⑴ ⑴ 判断其判断其 “互为伙伴互为伙伴”的两个空闲块是否为空：的两个空闲块是否为空：若不为空，仅将要回收的空闲块直接插入到相应的子若不为空，仅将要回收的空闲块直接插入到相应的子表中；否则转表中；否则转⑵⑵；；⑵⑵ 按以下步骤进行空闲块的合并：按以下步骤进行空闲块的合并：◆◆ 在相应子表中找到其伙伴并删除之；在相应子表中找到其伙伴并删除之；◆◆ 合并两个空闲块；合并两个空闲块；⑶ ⑶ 重复重复⑵⑵，直到合并后的空闲块的伙伴不是空闲块，直到合并后的空闲块的伙伴不是空闲块为止。

为止系统的特点系统的特点：：算法简单；速度快；但容易产生碎片算法简单；速度快；但容易产生碎片数据结构严蔚敏第第9章章 查找查找 数据的组织和查找是大多数应用程序的核心，而数据的组织和查找是大多数应用程序的核心，而查找是所有查找是所有数据处理数据处理中最基本、中最基本、最常用的操作最常用的操作特别当查找的对象是一个庞大数量的数据集合中的元素时，查查找的对象是一个庞大数量的数据集合中的元素时，查找的方法和效率就显得格外重要找的方法和效率就显得格外重要 本章主要讨论顺序表、有序表、树表和哈希表查找本章主要讨论顺序表、有序表、树表和哈希表查找的各种实现方法，以及相应查找方法在等概率情况下的的各种实现方法，以及相应查找方法在等概率情况下的平均查找长度平均查找长度数据结构严蔚敏9.1 查找的概念查找的概念 查找表查找表(Search Table)：：相同类型的数据元素相同类型的数据元素(对对象象)组成的集合，每个元素通常由若干数据项构成组成的集合，每个元素通常由若干数据项构成 关键字关键字(Key，码，码)：：数据元素中某个数据元素中某个(或几个或几个)数据数据项的值，它可以标识一个数据元素。

若关键字能项的值，它可以标识一个数据元素若关键字能唯一唯一标标识一个数据元素，则关键字称为识一个数据元素，则关键字称为主关键字主关键字；将能标识若；将能标识若干个数据元素的关键字称为干个数据元素的关键字称为次关键字次关键字 查找查找/检索检索(Searching)：：根据给定的根据给定的K值，在查值，在查找表中确定一个关键字等于给定值的记录或数据元素找表中确定一个关键字等于给定值的记录或数据元素◆◆ 查找表中查找表中存在存在满足条件的记录：查找成功；结果：满足条件的记录：查找成功；结果：所查到的记录信息或记录在查找表中的位置所查到的记录信息或记录在查找表中的位置◆◆ 查找表中查找表中不存在不存在满足条件的记录：查找失败满足条件的记录：查找失败数据结构严蔚敏查找有两种基本形式：静态查找和动态查找查找有两种基本形式：静态查找和动态查找 静态查找静态查找(Static Search)：：在查找时只对数在查找时只对数据元素进行查询或检索，查找表称为静态查找表据元素进行查询或检索，查找表称为静态查找表 动态查找动态查找(Dynamic Search)：：在实施查找的在实施查找的同时，插入查找表中不存在的记录，或从查找表中删除同时，插入查找表中不存在的记录，或从查找表中删除已存在的某个记录，查找表称为动态查找表。

已存在的某个记录，查找表称为动态查找表 查找的对象是查找表，采用何种查找方法，首先取查找的对象是查找表，采用何种查找方法，首先取决于查找表的组织查找表是记录的集合，而集合中的决于查找表的组织查找表是记录的集合，而集合中的元素之间是一种完全松散的关系，因此，元素之间是一种完全松散的关系，因此，查找表是一种查找表是一种非常灵活的数据结构非常灵活的数据结构，，可以用多种方式来存储可以用多种方式来存储 根据存储结构的不同，查找方法可分为三大类：根据存储结构的不同，查找方法可分为三大类：数据结构严蔚敏①① 顺序表和链表的查找顺序表和链表的查找：将给定的：将给定的K值与查找表中值与查找表中记录的关键字记录的关键字逐个进行比较逐个进行比较，， 找到要查找的记录；找到要查找的记录；②② 散列表的查找散列表的查找：根据给定的：根据给定的K值值直接访问直接访问查找表，查找表， 从而找到要查找的记录；从而找到要查找的记录；③③ 索引查找表的查找索引查找表的查找：首先根据索引确定待查找记：首先根据索引确定待查找记录所在的块录所在的块 ，然后再从块中找到要查找的记录然后再从块中找到要查找的记录。

查找方法评价指标查找方法评价指标 查找过程中主要操作是关键字的比较，查找过程中查找过程中主要操作是关键字的比较，查找过程中关键字的关键字的平均比较次数平均比较次数(平均查找长度平均查找长度ASL：：Average Search Length)作为衡量一个作为衡量一个查找算法效率高低的标准查找算法效率高低的标准ASL定义为：定义为：ASL=∑ Pi Ci n为查找表中记录个数为查找表中记录个数i=1n∑ Pi=1i=1n数据结构严蔚敏其中：其中：Pi ：查找第：查找第i个记录的概率，不失一般性，认为查个记录的概率，不失一般性，认为查找每个记录的概率相等，即找每个记录的概率相等，即P1=P2=…=Pn=1/n ；；Ci：查找第：查找第i个记录需要进行比较的次数个记录需要进行比较的次数 一般地，认为记录的关键字是一些可以进行比较运一般地，认为记录的关键字是一些可以进行比较运算的类型，如整型、字符型、实型等，本章以后各节中算的类型，如整型、字符型、实型等，本章以后各节中讨论所涉及的关键字、数据元素等的类型描述如下：讨论所涉及的关键字、数据元素等的类型描述如下： 典型的关键字类型说明是：典型的关键字类型说明是：typedef float KeyType ; /* 实型实型 */typedef int KeyType ; /* 整型整型 */typedef char KeyType ; /* 字符串型字符串型 */ 数据元素类型的定义是：数据元素类型的定义是：数据结构严蔚敏typedef struct RecType{ KeyType key ; /* 关键字码关键字码 */┇ ┇ /* 其他域其他域 */}RecType ; 对两个关键字的比较约定为如下带参数的宏定义：对两个关键字的比较约定为如下带参数的宏定义：/* 对数值型关键字对数值型关键字 */#define EQ(a, b) ((a)==(b))#define LT(a, b) ((a)<(b))#define LQ(a, b) ((a)<=(b))/* 对字符串型关键字对字符串型关键字 */#define EQ(a, b) (!strcmp((a), (b)) )#define LT(a, b) (strcmp((a), (b))<0 )#define LQ(a, b) (strcmp((a), (b))<=0 )数据结构严蔚敏9. 2 静态查找静态查找 静态查找表的抽象数据类型定义如下：静态查找表的抽象数据类型定义如下：ADT Static_SearchTable{数据对象数据对象D：：D是具有相同特性的数据元素的集合是具有相同特性的数据元素的集合，， 各个数据元素有唯一标识的关键字各个数据元素有唯一标识的关键字。

数据关系数据关系R：数据元素同属于一个集合：数据元素同属于一个集合基本操作基本操作P：： ┇ ┇} ADT Static_SearchTable 详见详见p216 线性表是查找表最简单的一种组织方式线性表是查找表最简单的一种组织方式，本节介绍，本节介绍几种主要的关于顺序存储结构的查找方法几种主要的关于顺序存储结构的查找方法数据结构严蔚敏9.2.1 顺序查找顺序查找(Sequential Search)1 查找思想查找思想 从表的一端开始逐个将记录的关键字和给定从表的一端开始逐个将记录的关键字和给定K值进值进行比较，若某个记录的关键字和给定行比较，若某个记录的关键字和给定K值相等，查找成值相等，查找成功；否则，若扫描完整个表，仍然没有找到相应的记录，功；否则，若扫描完整个表，仍然没有找到相应的记录，则查找失败顺序表的类型定义如下：则查找失败顺序表的类型定义如下：#define MAX_SIZE 100typedef struct SSTable{ RecType elem[MAX_SIZE] ; /* 顺序表顺序表 */int length ; /* 实际元素个数实际元素个数 */}SSTable ;数据结构严蔚敏int Seq_Search(SSTable ST , KeyType key){ int p ; ST. elem[0].key=key ; /* 设置监视哨兵设置监视哨兵,失败返回失败返回0 */for (p=ST.length; !EQ(ST. elem[p].key, key); p--)return(p) ; } 比较次数比较次数：：查找第查找第n个元素：个元素： 1……….查找第查找第i个元素：个元素： n-i+1查找第查找第1个元素：个元素： n查找失败查找失败：： n+1数据结构严蔚敏2 算法分析算法分析 不失一般性，设查找每个记录不失一般性，设查找每个记录成功成功的概率相等，即的概率相等，即Pi=1/n；查找第；查找第i个元素成功的比较次数个元素成功的比较次数Ci=n-i+1 ；；◆◆ 查找成功时的查找成功时的平均查找长度平均查找长度ASL：：ASL=∑ Pi Ci=i=1n∑ (n-i+1)=i=1nn―12n+164 5 13 19 21 37 56 64 75 80 88 92监视哨监视哨查找查找640 1 2 3 4 5 6 7 8 9 10 11ppppp比较次数比较次数=5图图9-1 顺序查找示例顺序查找示例数据结构严蔚敏ASL=∑ Pi Ci=i=1n2n+1∑ (n-i+1)+i=1n2n1=3(n+1)/4◆◆ 包含查找不成功时：查找失败包含查找不成功时：查找失败的比较次数为的比较次数为n+1，若，若成功与不成功成功与不成功的概率相等，对每个记录的查找的概率相等，对每个记录的查找概率为概率为Pi=1/(2n)，则，则平均查找长度平均查找长度ASL：：数据结构严蔚敏9.2.2 折半查找折半查找(Binary Search) 折半查找又称为二分查找，是一种效率较高的查找折半查找又称为二分查找，是一种效率较高的查找方法。

方法 前提条件前提条件：：查找表中的所有记录是按关键字有序查找表中的所有记录是按关键字有序(升序或降序升序或降序) 查找过程中，先确定待查找记录在表中的范围，然查找过程中，先确定待查找记录在表中的范围，然后逐步缩小范围后逐步缩小范围(每次将待查记录所在区间缩小一半每次将待查记录所在区间缩小一半)，，直到找到或找不到记录为止直到找到或找不到记录为止1 查找思想查找思想 用用Low、、High和和Mid表示待查找区间的下界、上界表示待查找区间的下界、上界和中间位置指针，初值为和中间位置指针，初值为Low=1，，High=n数据结构严蔚敏⑴⑴ 取中间位置取中间位置Mid：：Mid= (Low+High)/2  ；；⑵⑵ 比较比较中间位置记录的关键字与给定的中间位置记录的关键字与给定的K值：值：①① 相等相等：： 查找成功；查找成功；②② 大于大于：待查记录在区间的前半段，修改上界指：待查记录在区间的前半段，修改上界指针：针： High=Mid-1，转，转⑴⑴ ；；③③ 小于小于：待查记录在区间的后半段，修改下界指：待查记录在区间的后半段，修改下界指针：针：Low=Mid+1，转，转⑴⑴ ；；直到越界直到越界(Low>High)，查找失败。

查找失败2 算法实现算法实现数据结构严蔚敏int Bin_Search(SSTable ST , KeyType key){ int Low=1，，High=ST.length, Mid ;while (Low

所示数据结构严蔚敏查找查找71 -5 13 17 23 38 46 56 65 78 81 921 2 3 4 5 6 7 8 9 10 11MidHighLow -5 13 17 23 38 46 56 65 78 81 921 2 3 4 5 6 7 8 9 10 11MidHighLow -5 13 17 23 38 46 56 65 78 81 921 2 3 4 5 6 7 8 9 10 11MidHighLow -5 13 17 23 38 46 56 65 78 81 921 2 3 4 5 6 7 8 9 10 11MidHighLow(b) 查找不成功示例查找不成功示例图图9-2 折半查找示例折半查找示例数据结构严蔚敏4 算法分析算法分析①① 查找时每经过一次比较，查找范围就缩小一半，查找时每经过一次比较，查找范围就缩小一半，该过程可用一棵二叉树表示：该过程可用一棵二叉树表示：◆◆ 根结点就是第一次进行比较的中间位置的记录；根结点就是第一次进行比较的中间位置的记录；◆◆ 排在中间位置前面的作为排在中间位置前面的作为左子树左子树的结点；的结点；◆◆ 排在中间位置后面的作为排在中间位置后面的作为右子树右子树的结点；的结点； 对各子树来说都是相同的。

这样所得到的二叉树称对各子树来说都是相同的这样所得到的二叉树称为为判定树判定树(Decision Tree)②② 将二叉判定树的第将二叉判定树的第 ㏒㏒2n +1层上的结点补齐就成层上的结点补齐就成为一棵满为一棵满二叉树，深度不变，二叉树，深度不变，h=  ㏒㏒2(n+1)  数据结构严蔚敏③③ 由由满满二叉树性质知，第二叉树性质知，第i 层上的结点数为层上的结点数为2i-1(i≤h) ，设表中每个记录的查找概率相等，即，设表中每个记录的查找概率相等，即Pi=1/n，查找，查找成功时的成功时的平均查找长度平均查找长度ASL：：ASL=∑ Pi Ci=i=1n∑ j 2j-1=j=1hn―1nn+1㏒㏒2(n+1)-1 当当n很大很大 (n>50)时，时， ASL≈ ㏒㏒2(n+1)-1数据结构严蔚敏9.2.3 分块查找分块查找 分块查找分块查找(Blocking Search)又称索引顺序查找，又称索引顺序查找，是前面两种查找方法的综合是前面两种查找方法的综合1 查找表的组织查找表的组织①① 将查找表分成几块块间有序，即第将查找表分成几块。

块间有序，即第i+1块的所有块的所有记录关键字均大于记录关键字均大于(或小于或小于)第第i块记录关键字；块内无块记录关键字；块内无序② ② 在查找表的基础上附加一个索引表，索引表是按在查找表的基础上附加一个索引表，索引表是按关键字有序的，索引表中记录的构成是：关键字有序的，索引表中记录的构成是：最大关键字最大关键字起始指针起始指针数据结构严蔚敏2 查找思想查找思想 先确定待查记录所在块，再在块内查找先确定待查记录所在块，再在块内查找(顺序查找顺序查找)3 算法实现算法实现typedef struct IndexType{ keyType maxkey ; /* 块中最大的关键字块中最大的关键字 */int startpos ; /* 块的起始位置指针块的起始位置指针 */}Index;数据结构严蔚敏int Block_search(RecType ST[] , Index ind[] , KeyType key , int n , int b) /* 在分块索引表中查找关键字为在分块索引表中查找关键字为key的记录的记录 */ /*表长为表长为n ，块数为，块数为b */{ int i=0 , j , k ;while ((ib) { printf("\nNot found"); return(0); }j=ind[i].startpos ;while ((jn||!EQ(ST[j].key, key) ){ j=0; printf("\nNot found"); }return(j); }4 算法示例算法示例索引表索引表1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 1822 12 13 8 9 20 33 42 44 38 24 48 60 58 74 57 86 53查查3822 48 86 1 7 13图图9-3 分块查找示例分块查找示例数据结构严蔚敏5 算法分析算法分析 设表长为设表长为n个记录，均分为个记录，均分为b块，每块记录数为块，每块记录数为s，则，则b=⌈ ⌈n/s⌉ ⌉。

设记录的查找概率相等，每块的查找概率为设记录的查找概率相等，每块的查找概率为1/b，块中记录的查找概率为，块中记录的查找概率为1/s，则，则平均查找长度平均查找长度ASL：：ASL=Lb+Lw=∑ j+j=1b∑ i=i=1ss―12b+12s+1+数据结构严蔚敏9.2.4 Fibonacci查找查找 Fibonacci查找方法是根据查找方法是根据Fibonacci数列的特点对查数列的特点对查找表进行分割找表进行分割Fibonacci数列的定义是：数列的定义是： F(0)=0，，F(1)=1，，F(j)=F(j-1)+F(j-2) 1 查找思想查找思想 设查找表中的记录数比某个设查找表中的记录数比某个Fibonacci数小数小1，即设，即设n=F(j)-1用Low、、High和和Mid表示待查找区间的下界、表示待查找区间的下界、上界和分割位置，初值为上界和分割位置，初值为Low=1，，High=n⑴⑴ 取分割位置取分割位置Mid：：Mid=F(j-1) ；；⑵⑵ 比较比较分割位置记录的关键字与给定的分割位置记录的关键字与给定的K值：值：数据结构严蔚敏① ① 相等相等：： 查找成功；查找成功；②② 大于大于：待查记录在区间的前半段：待查记录在区间的前半段(区间长度为区间长度为F(j-1)-1)，修改上界指针：，修改上界指针： High=Mid-1，转，转⑴⑴ ；；③③ 小于小于：待查记录在区间的后半段：待查记录在区间的后半段(区间长度为区间长度为F(j-2)-1)，修改下界指针：，修改下界指针：Low=Mid+1，转，转⑴⑴ ；；直到越界直到越界(Low>High)，查找失败。

查找失败2 算法实现算法实现 在算法实现时在算法实现时，为了避免频繁计算，为了避免频繁计算Fibonacci数，可数，可用两个变量用两个变量f1和和f2保存当前相邻的两个保存当前相邻的两个Fibonacci数，这数，这样在以后的计算中可以依次递推计算出样在以后的计算中可以依次递推计算出数据结构严蔚敏int fib(int n){ int i, f , f0=0 , f1=1 ;if (n==0) return(0) ;if (n==1) return(1) ;for (i=2 ; i<=n ; i++ ){ f=f0+f1 ; f0=f1 ; f1=f ; }return(f) ;}int Fib_search(RecType ST[] , KeyType key , int n) /* 在有序表在有序表ST中用中用Fibonacci方法查找关键字为方法查找关键字为key的记录的记录 */{ int Low=1, High, Mid, f1, f2 ;High=n ; f1=fib(n-1) ; f2=fib(n-2) ;while (Low<=High){ Mid=Low+f1-1;数据结构严蔚敏if ( EQ(ST.[Mid].key, key) ) return(Mid) ;else if ( LT(key, ST.[Mid].key) ) { High=Mid-1 ; f2=f1-f2 ; f1=f1-f2 ; } else { Low=Mid+1 ;f1=f1-f2 ; f2=f2-f1 ; } }return(0) ; } 由算法知，由算法知，Fibonacci查找在最坏情况下性能比折半查找在最坏情况下性能比折半查找差，但折半查找要求记录按关键字有序；查找差，但折半查找要求记录按关键字有序；Fibonacci查找的优点是分割时只需进行加、减运算。

查找的优点是分割时只需进行加、减运算数据结构严蔚敏9.3 动态查找动态查找 当查找表以线性表的形式组织时当查找表以线性表的形式组织时，若对查找表进行，若对查找表进行插入插入、、删除或排序操作，就必须移动大量的记录，当记删除或排序操作，就必须移动大量的记录，当记录数很多时，这种移动的代价很大录数很多时，这种移动的代价很大 利用树的形式组织查找表，可以对查找表进行动态利用树的形式组织查找表，可以对查找表进行动态高效的查找高效的查找查找方法比较查找方法比较顺序查找顺序查找折半查找折半查找分块查找分块查找ASL最大最大最小最小两者之间两者之间表结构表结构有序表、无序表有序表、无序表有序表有序表分块有序表分块有序表存储结构存储结构 顺序存储结构顺序存储结构线性链表线性链表顺序存储结构顺序存储结构顺序存储结构顺序存储结构线性链表线性链表数据结构严蔚敏9.3.1 二叉排序树二叉排序树(BST)的定义的定义 二叉排序树二叉排序树(Binary Sort Tree或或Binary Search Tree) 的定义为的定义为：二叉排序树或者是空树，或者是满足下列性：二叉排序树或者是空树，或者是满足下列性质的二叉树。

质的二叉树1) ：若左子树不为空，则左子树上所有结点的值：若左子树不为空，则左子树上所有结点的值(关关键字键字)都小于都小于根结点的值根结点的值；；(2) ：若右子树不为空，则右子树上所有结点的值：若右子树不为空，则右子树上所有结点的值(关关键字键字)都大于都大于根结点的值根结点的值；；(3) ：左：左、、右子树都分别是二叉排序树右子树都分别是二叉排序树 结论结论：：若按中序遍历一棵二叉排序树，所得到的结若按中序遍历一棵二叉排序树，所得到的结点序列是一个递增序列点序列是一个递增序列 BST仍然可以用二叉链表来存储，如图仍然可以用二叉链表来存储，如图9-4所示所示数据结构严蔚敏图图9-4 9-4 二叉排序树二叉排序树二叉排序树二叉排序树1624271241518结点类型定义如下结点类型定义如下：： typedef struct Node{ KeyType key ; /* 关键字域关键字域 */… /* 其它数据域其它数据域 */struct Node *Lchild , *Rchild ;}BSTNode ; 数据结构严蔚敏9.3.2 BST树的查找树的查找1 查找思想查找思想 首先将给定的首先将给定的K值与值与二叉排序树的根结点的二叉排序树的根结点的关键字关键字进行比较：若进行比较：若相等相等：： 则查找成功；则查找成功；①① 给定的给定的K值值小于小于BST的根结点的的根结点的关键字：继续在关键字：继续在该该结点的结点的左子树左子树上进行查找上进行查找；；②② 给定的给定的K值值大于大于BST的根结点的的根结点的关键字：继续在关键字：继续在该该结点的结点的右子树右子树上进行查找上进行查找。

2 算法实现算法实现数据结构严蔚敏⑴⑴ 递归算法递归算法BSTNode *BST_Serach(BSTNode *T , KeyType key){ if (T==NULL) return(NULL) ;else { if (EQ(T->key, key) ) return(T) ;else if ( LT(key, T->key) ) return(BST_Serach(T->Lchild, key)) ; else return(BST_Serach(T->Rchild, key)) ;}}数据结构严蔚敏 ⑵⑵ 非递归算法非递归算法BSTNode *BST_Serach(BSTNode *T , KeyType key){ BSTNode p=T ;while (p!=NULL&& !EQ(p->key, key) ){ if ( LT(key, p->key) ) p=p->Lchild ;else p=p->Rchild ;}if (EQ(p->key, key) ) return(p) ;else return(NULL) ;} 在随机情况下在随机情况下，二叉排序树的，二叉排序树的平均查找长度平均查找长度ASL和和㏒㏒(n)(树的深度树的深度)是等数量级的。

是等数量级的数据结构严蔚敏9.3.3 BST树的插入树的插入 在在BST树中插入一个新结点树中插入一个新结点，要保证插入后仍满足，要保证插入后仍满足BST的性质的性质1 插入思想插入思想 在在BST树中插入一个新结点树中插入一个新结点x时时，若，若BST树为空树为空，则，则令令新结点新结点x为插入后为插入后BST树的根结点树的根结点；；否则否则，将，将结点结点x的的关键字与根结点关键字与根结点T的关键字进行比较：的关键字进行比较： ①① 若相等若相等：： 不需要插入；不需要插入；②② 若若x.keykey：结点：结点x插入到插入到T的的左子树左子树中；中；③③ 若若x.key>T->key：结点：结点x插入到插入到T的的右子树右子树中2 算法实现算法实现数据结构严蔚敏⑴⑴ 递归算法递归算法void Insert_BST (BSTNode *T , KeyType key){ BSTNode *x ;x=(BSTNode *)malloc(sizeof(BSTNode)) ;X->key=key; x->Lchild=x->Rchild=NULL ; if (T==NULL) T=x ;else{ if (EQ(T->key, x->key) ) return ;/* 已有结点已有结点 */else if (LT(x->key, T->key) ) Insert_BST(T->Lchild, key) ; else Insert_BST(T->Rchild, key) ; }}数据结构严蔚敏⑵⑵ 非递归算法非递归算法void Insert_BST (BSTNode *T , KeyType key){ BSTNode *x, *p , *q ;x=(BSTNode *)malloc(sizeof(BSTNode)) ;X->key=key; x->Lchild=x->Rchild=NULL ;if (T==NULL) T=x ;else { p=T ;while (p!=NULL) { if (EQ(p->key, x->key) ) return ; q=p ; /*q作为作为p的父结点的父结点 */数据结构严蔚敏 if (LT(x->key, p->key) ) p=p->Lchild ; else p=p->Rchild ; }if (LT(x->key, q->key) ) q->Lchild=x ;else q->Rchild=x ;}} 由结论知由结论知，，对于一个无序序列可以通过构造一棵对于一个无序序列可以通过构造一棵BST树而变成一个有序序列树而变成一个有序序列。

由算法由算法知知，每次，每次插入的新结点都是插入的新结点都是BST树的叶子结树的叶子结点点，即在插入时不必移动其它结点，仅需修改某个结点，即在插入时不必移动其它结点，仅需修改某个结点的指针数据结构严蔚敏 利用利用BST树的插入操作树的插入操作，可以从空树开始逐个插入，可以从空树开始逐个插入每个结点，从而建立一棵每个结点，从而建立一棵BST树，算法如下：树，算法如下：#define ENDKEY 65535BSTNode *create_BST(){ KeyType key ; BSTNode *T=NULL ;scanf(“%d”, &key) ;while (key!=ENDKEY){ Insert_BST(T, key) ; scanf(“%d”, &key) ;}return(T) ;}数据结构严蔚敏9.3.4 BST树的删除树的删除 1 删除操作过程分析删除操作过程分析 从从BST树上删除一个结点树上删除一个结点，仍然要保证，仍然要保证删除删除后满足后满足BST的性质的性质设被删除结点为设被删除结点为p，其父结点为，其父结点为f ，删除情，删除情况如下况如下：：①① 若若p是叶子结点是叶子结点：： 直接删除直接删除p，如图，如图9-5(b)所示。

所示 ②② 若若p只有一棵子树只有一棵子树(左子树或右子树左子树或右子树)：直接用：直接用p的的左子树左子树(或或右子树右子树)取代取代p的位置而成为的位置而成为f的一棵子树的一棵子树即原来即原来p是是f的的左子树左子树，则，则p的子树成为的子树成为f的的左子树左子树；原；原来来p是是f的的右子树右子树，则，则p的子树成为的子树成为f的的右子树右子树，如图，如图9-5(c)、、 (d)所示 数据结构严蔚敏③ ③ 若若p既有左子树又有右子树既有左子树又有右子树 ：处理方法有以下两：处理方法有以下两种，可以任选其中一种种，可以任选其中一种◆◆ 用用p的直接前驱结点代替的直接前驱结点代替p即从p的的左子树中左子树中选择值最大选择值最大的结点的结点s放在放在p的位置的位置(用结点用结点s的内容替的内容替换结点换结点p内容内容)，然后删除结点，然后删除结点ss是是p的的左子树中左子树中的最右边的结点的最右边的结点且没有且没有右子树右子树，对，对s的删除同的删除同②②，，如图如图9-5(e)所示◆◆ 用用p的直接后继结点代替的直接后继结点代替p即从p的的右子树中右子树中选择值最小选择值最小的结点的结点s放在放在p的位置的位置(用结点用结点s的内容替的内容替换结点换结点p内容内容)，然后删除结点，然后删除结点s。

s是是p的的右子树中右子树中的最左边的结点的最左边的结点且没有且没有左子树左子树，对，对s的删除同的删除同②②，，如图如图9-5(f)所示数据结构严蔚敏图图9-5 BST树的结点删除情况树的结点删除情况(e) 删除结点删除结点12986151314(d) 删除结点删除结点159861314128610151913149(a) BST树树1286101513149(b) 删除结点删除结点1912869151314(c) 删除结点删除结点10数据结构严蔚敏2 算法实现算法实现void Delete_BST (BSTNode *T , KeyType key ) /* 在以在以T为根结点的为根结点的BST树中删除关键字为树中删除关键字为key的结点的结点 */{ BSTNode *p=T , *f=NULL , *q , *s ;while ( p!=NULL&&!EQ(p->key, key) ){ f=p ;if (LT(key, p->key) ) p=p->Lchild ; /* 搜索左子搜索左子树树 */else p=p->Rchild ; /* 搜索右子树搜索右子树 */ }if (p==NULL) return ; /* 没有要删除的结点没有要删除的结点 */数据结构严蔚敏s=p ; /* 找到了要删除的结点为找到了要删除的结点为p */ if (p->Lchild!=NULL&& p->Rchild!=NULL) { f=p ; s=p->Lchild ; /* 从左子树开始找从左子树开始找 */while (s->Rchild!=NULL) { f=s ; s=s->Rchild ; }/* 左、右子树都不空左、右子树都不空，找，找左子树中最右边的结点左子树中最右边的结点 */p->key=s->key ; p->otherinfo=s->otherinfo ; /* 用结点用结点s的内容替换结点的内容替换结点p内容内容 */} /* 将第将第3种情况转换为第种情况转换为第2种情况种情况*/if (s->Lchild!=NULL) /* 若若s有左子树有左子树，右，右子树为空子树为空 */q=s->Lchild ;数据结构严蔚敏else q=s->Rchild ;if (f==NULL) T=q ;else if (f->Lchild==s) f->Lchild=q ; else f->Rchild=q ;free(s) ;}数据结构严蔚敏9.4 平衡二叉树平衡二叉树(AVL) BST是一种查找效率比较高的组织形式是一种查找效率比较高的组织形式，但其平均，但其平均查找长度受树的形态影响较大，形态比较均匀时查找效查找长度受树的形态影响较大，形态比较均匀时查找效率很好，形态明显偏向某一方向时其效率就大大降低。

率很好，形态明显偏向某一方向时其效率就大大降低因此，希望有更好的二叉排序树，其形态总是均衡的，因此，希望有更好的二叉排序树，其形态总是均衡的，查找时能得到最好的效率，这就是平衡二叉排序树查找时能得到最好的效率，这就是平衡二叉排序树 平衡二叉排序树平衡二叉排序树(Balanced Binary Tree或或Height-Balanced Tree)是在是在1962年由年由Adelson-Velskii和和Landis提提出的出的，又称，又称AVL树数据结构严蔚敏9.4.1 平衡平衡二叉树二叉树的定义的定义 平衡二叉树或者是空树，或者是满足下列性质的二平衡二叉树或者是空树，或者是满足下列性质的二叉树⑴⑴：左子树和右子树深度之差的绝对值不大于：左子树和右子树深度之差的绝对值不大于1；；⑵⑵：左子树和右子树也都是平衡二叉树左子树和右子树也都是平衡二叉树 平衡因子平衡因子(Balance Factor) ：二叉树上：二叉树上结点的左子结点的左子树的深度减去其右子树深度树的深度减去其右子树深度称为该结点的平衡因子称为该结点的平衡因子 因此，平衡二叉树上每个结点的平衡因子只可能是因此，平衡二叉树上每个结点的平衡因子只可能是-1、、0和和1，否则，只要有一个结点的平衡因子的绝对值，否则，只要有一个结点的平衡因子的绝对值大于大于1，， 该二叉树就不是平衡二叉树。

该二叉树就不是平衡二叉树 如果一棵二叉树既是二叉排序树又是平衡二叉树，如果一棵二叉树既是二叉排序树又是平衡二叉树，称为称为平衡二叉排序树平衡二叉排序树(Balanced Binary Sort Tree) 数据结构严蔚敏 在平衡二叉排序树上执行查找的过程与二叉排序树在平衡二叉排序树上执行查找的过程与二叉排序树上的查找过程完全一样，则在上的查找过程完全一样，则在AVL树上执行查找时，和树上执行查找时，和给定的给定的K值比较的次数不超过树的深度值比较的次数不超过树的深度 设深度为设深度为h的的平衡二叉排序树所具有的最少结点数平衡二叉排序树所具有的最少结点数为为Nh，则由平衡二叉排序树的性质知，则由平衡二叉排序树的性质知：：图图9-6 平衡平衡二叉树二叉树16241241518结点类型定义如下结点类型定义如下：： typedef struct BNode{ KeyType key ; /* 关键字域关键字域 */int Bfactor ; /* 平衡因子域平衡因子域 */… /* 其它数据域其它数据域 */struct BNode *Lchild , *Rchild ;}BSTNode ; 数据结构严蔚敏N0=0，，N1=1，，N2=2，，… … ，，Nh= Nh-1+Nh-2 该关系和该关系和Fibonacci数列相似数列相似。

根据归纳法可证明，根据归纳法可证明，当当h≥0时时，，Nh=F=Fh+2-1，，……而而这样这样，含有，含有n个结点的个结点的平衡二叉排序树的最大深度为平衡二叉排序树的最大深度为h≈√√5 5㏒㏒φφ( ( (n+1))-2φφh h√√5 5F Fh≈21+√51+√5其中其中φ=φ=φφh h√√5 5则N Nh≈-1 则在平衡二叉排序树上进行查找的则在平衡二叉排序树上进行查找的平均查找长度平均查找长度和和㏒㏒2n是一个数量级的是一个数量级的，平均时间复杂度为，平均时间复杂度为O(㏒㏒2n)数据结构严蔚敏9.4.2 平衡平衡化旋转化旋转 一般的二叉排序树是不平衡的，若能通过某种方法一般的二叉排序树是不平衡的，若能通过某种方法使其使其既保持有序性既保持有序性，，又具有平衡性又具有平衡性，就找到了构造平衡，就找到了构造平衡二叉排序树的方法，该方法称为二叉排序树的方法，该方法称为平衡平衡化旋转化旋转 在对在对AVL树进行插入或删除一个结点后树进行插入或删除一个结点后，通常会影，通常会影响到响到从根结点到插入从根结点到插入( (或删除或删除) )结点的路径上的某些结点结点的路径上的某些结点，，这些结点的子树可能发生变化。

以插入结点为例，影响这些结点的子树可能发生变化以插入结点为例，影响有以下几种可能性有以下几种可能性◆◆ 以某些结点为根的子树的深度发生了变化以某些结点为根的子树的深度发生了变化；； ◆◆ 某些结点的平衡因子发生了变化某些结点的平衡因子发生了变化；；◆◆ 某些结点失去平衡某些结点失去平衡数据结构严蔚敏1 LL型平衡型平衡化旋转化旋转⑴ ⑴ 失衡原因失衡原因 在在结点结点a的的左孩子左孩子的左子树的左子树上进行插入，插入使上进行插入，插入使结结点点a失去失去平衡平衡a插入前的平衡因子是插入前的平衡因子是1，插入，插入后的后的平衡平衡因子是因子是2设b是是a的左孩子，的左孩子，b在插入前的平衡因子在插入前的平衡因子只能只能是是0，插入后的平衡因子是，插入后的平衡因子是1(否则否则b就是就是失衡结点失衡结点)⑵⑵ 平衡化旋转方法平衡化旋转方法 通过顺时针旋转操作实现，如图通过顺时针旋转操作实现，如图9-7所示 沿着插入结点上行到根结点就能找到某些结点，这沿着插入结点上行到根结点就能找到某些结点，这些些结点的平衡因子和子树深度都会发生变化结点的平衡因子和子树深度都会发生变化，这样的结，这样的结点称为点称为失衡结点失衡结点。

数据结构严蔚敏 用用b取代取代a的位置的位置，，a成为成为b的右子树的根结点的右子树的根结点，，b原原来的右子树作为来的右子树作为a的左子树的左子树⑶ ⑶ 插入后各结点的平衡因子分析插入后各结点的平衡因子分析①① 旋转前的平衡因子旋转前的平衡因子设插入后设插入后b的左子树的深度为的左子树的深度为HbL，则其右子树的深度，则其右子树的深度为为HbL-1；； a的左子树的深度为的左子树的深度为HbL+1abbRaRbLxabbRaRbLx图图9-7 LL型平衡型平衡化旋转示意图化旋转示意图a的平衡因子为的平衡因子为2，则，则a的右子树的深度为：的右子树的深度为：HaR=HbL+1-2=HbL-1数据结构严蔚敏② ② 旋转后的平衡因子旋转后的平衡因子 a的右子树没有变，而左子树是的右子树没有变，而左子树是b的右子树的右子树，则平衡，则平衡因子是因子是：：HaL- HaR=(HbL-1)-(HbL-1)=0 即即a是是平衡的，以平衡的，以a为根的子树的深度是为根的子树的深度是HbL b的左子树没有变化，右子树是以的左子树没有变化，右子树是以a为根的子树为根的子树，则，则平衡因子是平衡因子是：： HbL-HbL=0 即即b也是也是平衡的，以平衡的，以b为根的子树的深度是为根的子树的深度是HbL+1，，与插入前与插入前a的子树的深度相同的子树的深度相同，，则该子树的上层各结点则该子树的上层各结点的平衡因子没有变化的平衡因子没有变化，即，即整棵树旋转后是平衡的整棵树旋转后是平衡的。

数据结构严蔚敏⑷⑷ 旋转算法旋转算法void LL_rotate(BBSTNode *a){ BBSTNode *b ;b=a->Lchild ; a->Lchild=b->Rchild ;b->Rchild=a ;a->Bfactor=b->Bfactor=0 ; a=b ;}数据结构严蔚敏2 LR型平衡型平衡化旋转化旋转⑴ ⑴ 失衡原因失衡原因 在在结点结点a的的左孩子左孩子的右子树的右子树上进行插入，插入使上进行插入，插入使结点结点a失去失去平衡平衡a插入前的平衡因子是插入前的平衡因子是1，插入后，插入后a的的平衡因平衡因子是子是2设b是是a的左孩子，的左孩子，c为为b的右孩子的右孩子，， b在插入前在插入前的平衡因子的平衡因子只能是只能是0，插入后，插入后的的平衡因子是平衡因子是-1；；c在插入在插入前的平衡因子前的平衡因子只能是只能是0，，否则否则，，c就是就是失衡结点失衡结点⑵ ⑵ 插入后结点插入后结点c的平衡因子的变化分析的平衡因子的变化分析 ① ① 插入后插入后c的平衡因子是的平衡因子是1：即在：即在c的左子树上插入的左子树上插入。

设设c的左子树的深度为的左子树的深度为HcL，，则右子树的深度为则右子树的深度为HcL-1；；b插入后插入后的的平衡因子是平衡因子是-1，则，则b的左子树的深度为的左子树的深度为HcL，以，以b为根的子树的深度是为根的子树的深度是HcL+2数据结构严蔚敏 因插入后因插入后a的的平衡因子是平衡因子是2 ，则，则a的右子树的深度是的右子树的深度是HcL ② ② 插入后插入后c的平衡因子是的平衡因子是0：：c本身是插入结点本身是插入结点设设c的左子树的深度为的左子树的深度为HcL，，则右子树的深度也是则右子树的深度也是HcL；；因因b插入后插入后的的平衡因子是平衡因子是-1，则，则b的左子树的深度为的左子树的深度为HcL，以，以b为根的子树的深度是为根的子树的深度是HcL+2；；插入后插入后a的的平衡因子平衡因子是是2 ，则，则a的右子树的深度是的右子树的深度是HcL ③ ③ 插入后插入后c的平衡因子是的平衡因子是-1：即在：即在c的右子树上插入的右子树上插入设设c的左子树的深度为的左子树的深度为HcL，，则右子树的深度为则右子树的深度为HcL+1 ，，以以c为根的子树的深度是为根的子树的深度是HcL+2；因；因b插入后插入后的的平衡因子平衡因子是是-1，则，则b的左子树的深度为的左子树的深度为HcL+1，以，以b为根的子树的为根的子树的深度是深度是HcL+3；；则则a的右子树的深度是的右子树的深度是HcL+1。

数据结构严蔚敏⑶⑶ 平衡化旋转方法平衡化旋转方法 先以先以b进行一次进行一次逆时针旋转逆时针旋转(将以将以b为根的子树旋转为根的子树旋转为以为以c为根为根)，，再以再以a进行一次进行一次顺时针旋转顺时针旋转，如图，如图9-8所示将整棵子树将整棵子树旋转旋转为以为以c为根，为根，b是是c的左子树，的左子树，a是是c的右的右子树；子树；c的右子树移到的右子树移到a的左子树位置，的左子树位置， c的左子树移到的左子树移到b的右子树位置的右子树位置图图9-8 LR型平衡型平衡化旋转示意图化旋转示意图abbLaRcLxcRxcacbLaRcLxcRxb数据结构严蔚敏⑷ ⑷ 旋转后各结点旋转后各结点(a,b,c)平衡因子分析平衡因子分析 ①① 旋转前旋转前 (插入后插入后)c的平衡因子是的平衡因子是1：： a的左子树深度为的左子树深度为HcL-1 ，，其右子树没有变化其右子树没有变化，，深深度是度是HcL，则，则a的平衡因子是的平衡因子是-1；；b的左子树没有变化的左子树没有变化，，深度为深度为HcL，，右子树是右子树是c旋转前的左子树旋转前的左子树，，深度为深度为HcL，，则则b的平衡因子是的平衡因子是0；； c的左、右子树分别是以的左、右子树分别是以b和和a为根为根的子树的子树，则，则c的平衡因子是的平衡因子是0 。

②② 旋转前旋转前 (插入后插入后)c的平衡因子是的平衡因子是0：： 旋转后旋转后a，，b，，c的平衡因子都是的平衡因子都是0 ③③ 旋转前旋转前 (插入后插入后)c的平衡因子是的平衡因子是-1：： 旋转后旋转后a，，b，，c的平衡因子分别是的平衡因子分别是0，，-1，，0 综上所述综上所述，即，即整棵树旋转后是平衡的整棵树旋转后是平衡的数据结构严蔚敏⑸ ⑸ 旋转算法旋转算法void LR_rotate(BBSTNode *a){ BBSTNode *b,*c ;b=a->Lchild ; c=b->Rchild ; /* 初始化初始化 */a->Lchild=c->Rchild ; b->Rchild=c->Lchild ;c->Lchild=b ; c->Rchild=a ;if (c->Bfactor==1) { a->Bfactor=-1 ;b->Bfactor=0 ; }else if (c->Bfactor==0) a->Bfactor=b->Bfactor=0 ;else { a->Bfactor=0 ;b->Bfactor=1 ; }}数据结构严蔚敏3 RL型平衡型平衡化旋转化旋转⑴ ⑴ 失衡原因失衡原因 在在结点结点a的的右孩子右孩子的左子树的左子树上进行插入，插入使上进行插入，插入使结点结点a失去失去平衡平衡，，与与LR型正好对称型正好对称。

对于结点对于结点a，插入前的，插入前的平衡因子是平衡因子是-1，插入后，插入后a的的平衡因子是平衡因子是-2设b是是a的右孩的右孩子，子，c为为b的左孩子的左孩子，， b在插入前的平衡因子在插入前的平衡因子只能是只能是0，，插入后插入后的的平衡因子是平衡因子是1；；同样，同样，c在插入前的平衡因子在插入前的平衡因子只只能是能是0，，否则否则，，c就是就是失衡结点失衡结点⑵ ⑵ 插入后结点插入后结点c的平衡因子的变化分析的平衡因子的变化分析 ①① 插入后插入后c的平衡因子是的平衡因子是1：在：在c的左子树上插入的左子树上插入设设c的左子树的深度为的左子树的深度为HcL，，则右子树的深度为则右子树的深度为HcL-1数据结构严蔚敏因因b插入后插入后的的平衡因子是平衡因子是1，则，则其右子树的深度为其右子树的深度为HcL，，以以b为根的子树的深度是为根的子树的深度是HcL+2；因；因插入后插入后a的的平衡因子平衡因子是是-2 ，则，则a的左子树的深度是的左子树的深度是HcL ② ② 插入后插入后c的平衡因子是的平衡因子是0：：c本身是插入结点本身是插入结点设设c的左子树的深度为的左子树的深度为HcL，，则右子树的深度也是则右子树的深度也是HcL；；因因b插入后插入后的的平衡因子是平衡因子是1，则，则b的右子树的深度为的右子树的深度为HcL，，以以b为根的子树的深度是为根的子树的深度是HcL+2；因；因插入后插入后a的的平衡因子平衡因子是是-2 ，则，则a的左子树的深度是的左子树的深度是HcL。

③③ 插入后插入后c的平衡因子是的平衡因子是-1：在：在c的右子树上插入的右子树上插入设设c的左子树的深度为的左子树的深度为HcL，，则右子树的深度为则右子树的深度为HcL+1 ，，以以c为根的子树的深度是为根的子树的深度是HcL+2；因；因b插入后插入后的的平衡因子平衡因子是是1，则，则b的右子树的深度为的右子树的深度为HcL+1，以，以b为根的子树的深为根的子树的深度是度是HcL+3；；则则a的右子树的深度是的右子树的深度是HcL+1数据结构严蔚敏⑶ ⑶ 平衡平衡化旋转方法化旋转方法 先以先以b进行一次进行一次顺时针旋转顺时针旋转，，再再以以a进行一次进行一次逆时针逆时针旋转旋转，，如图如图9-9所示所示即将整棵子树即将整棵子树(以以a为根为根)旋转旋转为以为以c为根为根，，a是是c的左子树的左子树，，b是是c的右子树；的右子树；c的的右子树移到右子树移到b的左子树位置的左子树位置，，c的的左子树移到左子树移到a的右子树位置的右子树位置图图9-9 RL型平衡型平衡化旋转示意图化旋转示意图abbRaLcLxcRxcbcbRaLcLxcRxa数据结构严蔚敏⑷ ⑷ 旋转后各结点旋转后各结点(a, ,b, ,c)的平衡因子分析的平衡因子分析 ① ① 旋转前旋转前 (插入后插入后)c的平衡因子是的平衡因子是1：： a的左子树没有变化的左子树没有变化，，深度是深度是HcL，，右子树是右子树是c旋转旋转前的左子树前的左子树，，深度为深度为HcL，则，则a的平衡因子是的平衡因子是0；；b的右子的右子树没有变化树没有变化，，深度为深度为HcL，，左子树是左子树是c旋转前的右子树旋转前的右子树，，深度为深度为HcL-1 ，则，则b的平衡因子是的平衡因子是-1；； c的左、右子树分的左、右子树分别是以别是以a 和和b为根的子树为根的子树，则，则c的平衡因子是的平衡因子是0 。

②② 旋转前旋转前 (插入后插入后)c的平衡因子是的平衡因子是0：： 旋转后旋转后a，，b，，c的平衡因子都是的平衡因子都是0 ③③ 旋转前旋转前 (插入后插入后)c的平衡因子是的平衡因子是-1：： 旋转后旋转后a，，b，，c的平衡因子分别是的平衡因子分别是1，，0，，0 综上所述综上所述，即，即整棵树旋转后是平衡的整棵树旋转后是平衡的数据结构严蔚敏⑸ ⑸ 旋转算法旋转算法Void LR_rotate(BBSTNode *a){ BBSTNode *b,*c ;b=a->Rchild ; c=b->Lchild ; /* 初始化初始化 */a->Rchild=c->Lchild ; b->Lchild=c->Rchild ;c->Lchild=a ; c->Rchild=b ;if (c->Bfactor==1){ a->Bfactor=0 ; b->Bfactor=-1 ; }else if (c->Bfactor==0) a->Bfactor=b->Bfactor=0 ;else { a->Bfactor=1 ;b->Bfactor=0 ; }}数据结构严蔚敏4 RR型平衡型平衡化旋转化旋转⑴ ⑴ 失衡原因失衡原因 在在结点结点a的的右孩子右孩子的右子树的右子树上进行插入，插入使上进行插入，插入使结结点点a失去失去平衡平衡。

要进行一次逆要进行一次逆时针旋转时针旋转，和，和LL型平衡化型平衡化旋转正好对称旋转正好对称⑵⑵ 平衡化旋转方法平衡化旋转方法 设设b是是a的右孩子，的右孩子，通通过逆时针旋转实现过逆时针旋转实现，，如图如图9-10所示所示用用b取代取代a的位的位置置，，a作为作为b的左子树的根的左子树的根结点结点，，b原来的左子树作原来的左子树作为为a的右子树的右子树图图9-10 RR型平衡型平衡化旋转示意图化旋转示意图babLaLbRxabbLaLbRx数据结构严蔚敏⑶ ⑶ 旋转算法旋转算法BBSTNode *RR_rotate(BBSTNode *a){ BBSTNode *b ;b=a->Rchild ; a->Rchild=b->Lchild ; b->Lchild=a ;a->Bfactor=b->Bfactor=0 ; a=b ;} 对于上述四种平衡化旋转对于上述四种平衡化旋转，，其正确性容易由其正确性容易由“遍历遍历所得中序序列不变所得中序序列不变”来证明来证明并且，无论是哪种情况，并且，无论是哪种情况，平衡化旋转处理完成后，形成的新子树仍然是平衡二叉平衡化旋转处理完成后，形成的新子树仍然是平衡二叉排序树，且其深度和插入前以排序树，且其深度和插入前以a为根结点的平衡二叉排为根结点的平衡二叉排序树的深度相同。

所以，在平衡二叉排序树上因插入结序树的深度相同所以，在平衡二叉排序树上因插入结点而失衡，仅需对失衡子树做平衡化旋转处理点而失衡，仅需对失衡子树做平衡化旋转处理数据结构严蔚敏9.4.3 平衡平衡二叉排序树二叉排序树的插入的插入 平衡二叉排序树的插入操作实际上是在二叉排序插平衡二叉排序树的插入操作实际上是在二叉排序插入的基础上完成以下工作：入的基础上完成以下工作：⑴⑴：判别插入结点后的二叉排序树是否产生不平衡：判别插入结点后的二叉排序树是否产生不平衡? ?⑵⑵：找出失去平衡的最小子树；：找出失去平衡的最小子树；⑶⑶：判断旋转类型，然后做相应调整判断旋转类型，然后做相应调整 失衡的最小子树的失衡的最小子树的根结点根结点a在插入前的在插入前的平衡因子不平衡因子不为为0，且是离插入结点最近的，且是离插入结点最近的平衡因子不为平衡因子不为0的结点的的结点的 若若a失衡失衡，从，从a到插入点的路径上的所有结点的到插入点的路径上的所有结点的平衡平衡因子因子都会发生变化都会发生变化，在该路径上还有一个结点的，在该路径上还有一个结点的平衡因平衡因子子不为不为0且该结点插入后没有失衡且该结点插入后没有失衡，其，其平衡因子平衡因子只能是只能是由由1到到0或由或由-1到到0，以该结点为根的子树深度不变。

该，以该结点为根的子树深度不变该结点的所有祖先结点的平衡因子也不变，更不会失衡结点的所有祖先结点的平衡因子也不变，更不会失衡数据结构严蔚敏1 算法思想算法思想( (插入结点的步骤插入结点的步骤) )①①：按照二叉排序树的定义，将结点：按照二叉排序树的定义，将结点s插入；插入；②②：在查找结点：在查找结点s的插入位置的过程中的插入位置的过程中，记录离结点，记录离结点s最近且最近且平衡因子不为平衡因子不为0的结点的结点a，若该，若该结点不存在结点不存在，，则则结点结点a指向根结点；指向根结点；③③：： 修改结点修改结点a到结点到结点s路径上所有结点的路径上所有结点的；；④④：判断是否产生不平衡，若不平衡，则确定旋转：判断是否产生不平衡，若不平衡，则确定旋转类型并做相应调整类型并做相应调整2 算法实现算法实现数据结构严蔚敏void Insert_BBST(BBSTNode *T, BBSTNode *S){ BBSTNode *f,*a,*b,*p,*q;if (T==NULL) { T=S ; T->Bfactor=1 ; return ; }a=p=T ; /* a指向离指向离s最近且最近且平衡因子不为平衡因子不为0的结点的结点 */f=q=NULL ; /* f指向指向a的父结点的父结点,q指向指向p父结点父结点 */ while (p!=NULL){ if (EQ(S->key, p->key) ) return ; /* 结点已存结点已存在在 */if (p->Bfactor!=0) { a=p ; f=q ; }q=p ;if (LT(S->key, p->key) ) p=p->Lchild ; else p=p->Rchild ; /* 在右子树中搜索在右子树中搜索 */} /* 找插入位置找插入位置 */数据结构严蔚敏if (LT(S->key,p->key)) q->Lchild=S ;/* s为左孩子为左孩子 */else q->Rchild=S ; /* s插入为插入为q的右孩子的右孩子 */p=a ;while (p!=S){ if (LT(S->key, p->key) ) { p->Bfactor++ ; p=p->Lchild ; }else { p->Bfactor-- ; p=p->Rchild ; }} /* 插入到左子树插入到左子树,平衡因子加平衡因子加1,插入到左子树插入到左子树,减减1 */if (a->Bfactor>-2&& a->Bfactor<2)return ; /* 未失去平衡未失去平衡,不做调整不做调整 */if (a->Bfactor==2){ b=a->Lchild ;数据结构严蔚敏if (b->Bfactor==1) p=LL_rotate(a) ;else p=LR_rotate(a) ; }else { b=a->Rchild ;if (b->Bfactor==1) p=RL_rotate(a) ;else p=RR_rotate(a) ; } /* 修改双亲结点指针修改双亲结点指针 */if (f==NULL) T=p ; /* p为根结点为根结点 */else if (f->Lchild==a) f->Lchild=p ;else f->Lchild=p ;}数据结构严蔚敏 例例：： 设要构造的平衡二叉树中各结点的值分别是设要构造的平衡二叉树中各结点的值分别是(3, 14, 25, 81, 44)，，平衡二叉树的构造过程如图平衡二叉树的构造过程如图9-11所示所示。

3314(a) 插入不超过两个结点插入不超过两个结点(b) 插入新结点失衡插入新结点失衡,RR平衡旋转平衡旋转31425314253142581(c) 插入新结点未失衡插入新结点未失衡(d) 插入结点失衡插入结点失衡,RL平衡旋转平衡旋转314258144314448125图图9-11 平衡二叉树的构造过程平衡二叉树的构造过程数据结构严蔚敏9. 5 索引查找索引查找 索引技术是组织大型数据库的重要技术，索引结构索引技术是组织大型数据库的重要技术，索引结构的基本组成是的基本组成是索引表索引表和和数据表数据表两部分，如图两部分，如图9-12所示所示◆◆ 数据表数据表：存储实际的数据记录；：存储实际的数据记录；◆◆ 索引表索引表：存储记录的：存储记录的关键字关键字和和记录记录( (存储存储) )地址地址之之间的对照表间的对照表，，每个元素称为一个每个元素称为一个索引项索引项索引表索引表数据表数据表图图9-12 索引结构的基本形式索引结构的基本形式 关键字关键字 存储地址存储地址 263 275 386 … … 1046关键字关键字 … 386 263 1046 … 275 通过通过索引表索引表可实现对数据表可实现对数据表中记录的快速查中记录的快速查找找。

索引表的组索引表的组织织有有线性结构线性结构和和树形结构树形结构两种两种数据结构严蔚敏9.5.1 顺序索引表顺序索引表 是将是将索引项索引项按按顺序结构顺序结构组织的线性索引表组织的线性索引表，而表中，而表中索引项索引项一般是一般是按关键字排序按关键字排序的的，其特点是：，其特点是：优点优点：：◆◆ 可以用折半查找方法快速找到关键字可以用折半查找方法快速找到关键字，进而找到，进而找到数据记录的物理地址，实现数据记录的快速查找；数据记录的物理地址，实现数据记录的快速查找；◆◆ 提供对变长数据记录的便捷访问提供对变长数据记录的便捷访问；；◆◆ 插入或删除数据记录时不需要移动记录插入或删除数据记录时不需要移动记录，但需要，但需要对索引表进行维护对索引表进行维护数据结构严蔚敏缺点缺点：：◆◆ 索引表中索引项的数目与数据表中记录数相同索引表中索引项的数目与数据表中记录数相同，，当索引表很大时，检索记录需多次访问外存；当索引表很大时，检索记录需多次访问外存；◆◆ 对索引表的维护代价较高，涉及到大量索引项的对索引表的维护代价较高，涉及到大量索引项的移动，不适合于插入和删除操作。

移动，不适合于插入和删除操作数据结构严蔚敏9.5.2 树形索引表树形索引表 平衡平衡二叉排序树便于动态查找，因此用二叉排序树便于动态查找，因此用平衡平衡二叉排二叉排序树来组织索引表是一种可行的选择当用于大型数据序树来组织索引表是一种可行的选择当用于大型数据库时，所有数据及索引都存储在外存，因此，涉及到内库时，所有数据及索引都存储在外存，因此，涉及到内、、外存之间频繁的数据交换，这种外存之间频繁的数据交换，这种交换速度的快慢交换速度的快慢成为制成为制约动态查找的约动态查找的瓶颈瓶颈若以二叉树的结点作为内若以二叉树的结点作为内、、外存之外存之间数据交换单位，则查找给定关键字时对磁盘平均进行间数据交换单位，则查找给定关键字时对磁盘平均进行㏒㏒2n次访问是不能容忍的，因此，必须次访问是不能容忍的，因此，必须选择选择一种能一种能尽可尽可能降低磁盘能降低磁盘I/O次数次数的索引组织方式的索引组织方式树结点的大小尽树结点的大小尽可能地接近页的大小可能地接近页的大小 R.Bayer和和E.Mc Creight在在1972年提出了一种年提出了一种多路多路平衡查找树平衡查找树，称为，称为B_树树(其变型体是其变型体是B+树树) 。

数据结构严蔚敏1 B_树树 B_树树主要用于文件系统中主要用于文件系统中，在，在B_树中树中，每个结点的，每个结点的大小为一个磁盘页，大小为一个磁盘页，结点中所包含的关键字及其孩子的结点中所包含的关键字及其孩子的数目取决于页的大小数目取决于页的大小一棵度为一棵度为m的的B_树树称为称为m阶阶B_树树，，其定义是：其定义是：一棵一棵m阶阶B_树树，或者是空树，或者是满足以下性质的，或者是空树，或者是满足以下性质的m叉树：叉树：⑴ ⑴ 根结点或者是叶子，或者至少有两棵子树，至多根结点或者是叶子，或者至少有两棵子树，至多有有m棵子树；棵子树；⑵ ⑵ 除根结点外，所有非终端结点至少有除根结点外，所有非终端结点至少有 m/2 棵子树，棵子树，至多有至多有m棵子树；棵子树； ⑶ ⑶ 所有叶子结点都在树的同一层上；所有叶子结点都在树的同一层上；数据结构严蔚敏 ⑷ ⑷ 每个结点应包含如下信息：每个结点应包含如下信息： (n，，A0，，K1，，A1，，K2，，A2，，… ，，Kn，，An)其中其中Ki(1≤i≤n)是关键字是关键字，且，且Ki

当然，在实际应用中每个结点中还应包含当然，在实际应用中每个结点中还应包含n个指向每个指向每个关键字的记录指针，如图个关键字的记录指针，如图9-13是一棵包含是一棵包含13个关键字个关键字的的4阶阶B_树树数据结构严蔚敏gfedcba1 241 151 ∧∧ 20 ∧∧2 ∧∧ 28 ∧∧ 31 ∧∧2 ∧∧ 10 ∧∧ 20 ∧∧1 ∧∧ 56 ∧∧1 ∧∧ 50 ∧∧1 ∧∧ 37 ∧∧3 33 48 53ih图图9-13 一棵包含一棵包含13个关键字的个关键字的4阶阶B_树树数据结构严蔚敏 根据根据m阶阶B_树的定义树的定义，结点的类型定义如下：，结点的类型定义如下：#define M 5 /* 根据实际需要根据实际需要定义定义B_树的阶数树的阶数 */typedef struct BTNode{ int keynum ; /* 结点中关键字的个数结点中关键字的个数 */struct BTNode *parent ; /* 指向父结点的指针指向父结点的指针 */KeyType key[M+1] ; /* 关键字向量关键字向量,key[0]未用未用 */struct BTNode *ptr[M+1] ; /* 子树指针向量子树指针向量 */RecType *recptr[M+1] ;/* 记录指针向量记录指针向量,recptr[0]未用未用 */}BTNode ;数据结构严蔚敏2 B_树的查找树的查找 由由B_树的定义可知树的定义可知，在其上的查找过程和二叉排序，在其上的查找过程和二叉排序树的查找相似。

树的查找相似⑴ ⑴ 算法思想算法思想① ① 从树的根结点从树的根结点T开始开始，在，在T所指向的结点的关键字所指向的结点的关键字向量向量key[1…keynum]中查找给定值中查找给定值K(用折半查找用折半查找) ：：若若key[i]=K(1≤i≤keynum)，则查找成功，返回结点及，则查找成功，返回结点及关键字位置；否则，转关键字位置；否则，转⑵⑵；；② ② 将将K与向量与向量key[1…keynum]中的各个分量的值进中的各个分量的值进行比较行比较，，以选定查找的子树以选定查找的子树：：◆◆ 若若Kptr[0]；；数据结构严蔚敏◆◆ 若若key[i]ptr[i]；；◆◆ 若若K>key[keynum]：：T=T->ptr[keynum]；；转转①①，直到，直到T是叶子结点且未找到相等的关键字，则是叶子结点且未找到相等的关键字，则查找失败查找失败⑵ ⑵ 算法实现算法实现int BT_search(BTNode *T, KeyType K, BTNode *p) /* 在在B_树中查找关键字树中查找关键字K, 查找成功返回在结点中的位置查找成功返回在结点中的位置 */ /* 及结点指针及结点指针p; 否则返回否则返回0及最后一个结点指针及最后一个结点指针 */{ BTNode *q ; int n ;p=q=T ;数据结构严蔚敏while (q!=NULL) { p=q ; q->key[0]=K ; /* 设置查找哨兵设置查找哨兵 */for (n=q->keynum ; Kkey[n] ; n--) if (n>0&&EQ(q->key[n], K) ) return n ; q=q->ptr[n] ; }return 0 ;} ⑶ ⑶ 算法分析算法分析 在在B_树上的查找有两中基本操作树上的查找有两中基本操作：：◆◆ 在在B_树上查找结点树上查找结点(查找算法中没有体现查找算法中没有体现)；；数据结构严蔚敏◆◆ 在结点中查找关键字在结点中查找关键字：在磁盘上找到指针：在磁盘上找到指针ptr所指所指向的结点后向的结点后，，将结点信息读入内存将结点信息读入内存后后再查找再查找。

因此，因此，磁盘上的查找次数磁盘上的查找次数(待查找的记录关键字在待查找的记录关键字在B_树上的树上的层次数层次数)是决定是决定B_树查找效率的首要因素树查找效率的首要因素 根据根据m阶阶B_树的定义树的定义，第一层上至少有，第一层上至少有1个结点，第个结点，第二层上至少有二层上至少有2个结点；除根结点外，所有非终端结点个结点；除根结点外，所有非终端结点至少有至少有 m/2 棵子树，棵子树，…，第，第h层上至少有层上至少有 m/2 h-2个结点在这些结点中：根结点至少包含在这些结点中：根结点至少包含1个关键字，其它结点个关键字，其它结点至少包含至少包含 m/2 -1个关键字，设个关键字，设s= m/2 ，则总的关键字，则总的关键字数目数目n满足：满足：n≧≧1+(s-1)∑ 2si=i=2h=2sh-1-1s-1sh-1-12(s-1)数据结构严蔚敏因此有因此有：： h≦≦1+ ㏒㏒s((n+1)/2)=1+㏒㏒ m/2 ((n+1)/2) 即在含有即在含有n个关键字的个关键字的B_树树上进行查找时，从根结上进行查找时，从根结点到待查找记录关键字的结点的路径上所涉及的结点数点到待查找记录关键字的结点的路径上所涉及的结点数不超过不超过1+ ㏒㏒ m/2 ((n+1)/2) 。

数据结构严蔚敏3 B_树的插入树的插入 B_树的生成也是从空树起树的生成也是从空树起，逐个插入关键字插，逐个插入关键字插入时不是每插入一个关键字就添加一个叶子结点，而是入时不是每插入一个关键字就添加一个叶子结点，而是首先在最低层的某个叶子结点中添加一个关键字，然后首先在最低层的某个叶子结点中添加一个关键字，然后有可能有可能““分裂分裂””⑴ ⑴ 插入思想插入思想① ① 在在B_树的中查找关键字树的中查找关键字K，若找到，表明关键字，若找到，表明关键字已存在，返回；否则，已存在，返回；否则，K的查找操作失败于某个叶子的查找操作失败于某个叶子结点，转结点，转 ②②；；② ② 将将K插入到该插入到该叶子结点中，插入时，若：叶子结点中，插入时，若：◆◆ 叶子结点的关键字数叶子结点的关键字数

的两个子结点 当将中间关键字当将中间关键字K m/2 插入到插入到p的父结点后，父结点的父结点后，父结点也可能不满足也可能不满足m阶阶B_树的要求树的要求(分枝数大于分枝数大于m)，则必须，则必须对父结点进行对父结点进行““分裂分裂””，一直进行下去，直到没有父结，一直进行下去，直到没有父结点或分裂后的父结点满足点或分裂后的父结点满足m阶阶B_树的要求树的要求数据结构严蔚敏 当根结点分裂时，因没有父结点，则建立一个新的当根结点分裂时，因没有父结点，则建立一个新的根，根，B_树增高一层树增高一层 例：在一个例：在一个3阶阶B_树树(2-3树树)上插入结点上插入结点，，其过程如其过程如图图9-14所示所示⑶ ⑶ 算法实现算法实现 要实现插入，首先必须考虑结点的分裂设待分要实现插入，首先必须考虑结点的分裂设待分裂的结点是裂的结点是p，分裂时先开辟一个新结点，依此将结点，分裂时先开辟一个新结点，依此将结点p中后半部分的关键字和指针移到新开辟的结点中中后半部分的关键字和指针移到新开辟的结点中分裂之后，而需要插入到父结点中的关键字在之后，而需要插入到父结点中的关键字在p的关键字向的关键字向量的量的p->keynum+1位置上位置上。

数据结构严蔚敏fh mb( (a) 一棵一棵2-3树树fh mb d(b) 插入插入d后后fh m pb d分裂分裂(c) 插入插入p后并进行分裂后并进行分裂hf mb dph lf mb dp(d) 插入插入l后后分裂分裂g h lf mb dp(e) 插入插入g后并进行分裂后并进行分裂lf h mb dpp分裂分裂图图9-14 在在B_树中进行插入的过程树中进行插入的过程lf h mb dpglb dpghfm(f) 继续进行分裂继续进行分裂数据结构严蔚敏BTNode *split(BTNode *p) /* 结点结点p中包含中包含m个关键字个关键字，，从中分裂出一个新的结点从中分裂出一个新的结点 */{ BTNode *q ; int k, mid, j ;q=(BTNode *)malloc(sizeof( BTNode)) ;mid=(m+1)/2 ; q->ptr[0]=p->ptr[mid] ;for (j=1,k=mid+1; k<=m; k++) { q->key[j]=p->key[k] ; q->ptr[j++]=p->ptr[k] ;} /* 将将p的后半部分移到新结点的后半部分移到新结点q中中 */q->keynum=m-mid ; p->keynum=mid-1 ;return(q) ;} 数据结构严蔚敏void insert_BTree(BTNode *T, KeyType K) /* 在在B_树树T中插入关键字中插入关键字K，，*/{ BTNode *q, *s1=NULL, *s2=NULL ; int n ;if (!BT_search(T, K, p)) /* 树中不存在关键字树中不存在关键字K */{ while (p!=NULL){ p->key[0]=K ; /* 设置哨兵设置哨兵 */ for (n=p->keynum ; Kkey[n] ; n--) { p->key[n+1]=p->key[n] ; p->ptr[n+1]=p->ptr[n] ; } /* 后移关键字和指针后移关键字和指针 */ p->key[n]=K ; p->ptr[n-1]=s1 ;数据结构严蔚敏 p->ptr[n+1]=s2 ; /* 置关键字置关键字K的左右指针的左右指针 */ if (++(p->keynum ))key[p->keynum+1] ; p=p->parent ; /* 取出父结点取出父结点*/ } if (p==NULL) /* 需要产生新的根结点需要产生新的根结点 */ { p=(BTNode *)malloc(sizeof( BTNode)) ; p->keynum=1 ; p->key[1]=K ; p->ptr[0]=s1 ; p->ptr[1] =s2 ; }}数据结构严蔚敏4 B_树的删除树的删除 在在B_树上删除一个树上删除一个关键字关键字K ，首先找到关键字所在，首先找到关键字所在的结点的结点N，然后在，然后在N中进行关键字中进行关键字K的删除操作的删除操作。

若若N不不是叶子结点，设是叶子结点，设K是是N中的第中的第i个关键字，则个关键字，则将指针将指针Ai-1所指子树中的最大关键字所指子树中的最大关键字(或最小关键字或最小关键字)K’放放在在(K)的位置的位置，然后删除，然后删除K’，而，而K’一定在叶子结点上一定在叶子结点上如图如图9-15(b)，删除关键字，删除关键字h，用关键字，用关键字g代替代替h的位置，的位置，然后再从叶子结点中删除关键字然后再从叶子结点中删除关键字g 利用利用m阶阶B_树的插入操作树的插入操作，，可从空树起可从空树起，将一组关，将一组关键字依次键字依次插入到插入到m阶阶B_树中树中，从而生成一个，从而生成一个m阶阶B_树树数据结构严蔚敏图图9-15 在在B_树中进行删除的过程树中进行删除的过程删除删除ql mb dqe ghfplb dpe ghfm删除删除h(a)删除删除elb dpegfmlbpegfm删除删除dlpg mb f(b)(c)(d)数据结构严蔚敏 从叶子结点中删除一个关键字的情况是：从叶子结点中删除一个关键字的情况是：⑴ ⑴ 若若结点结点N中的关键字中的关键字个数个数> m/2 -1：在结点中直：在结点中直接删除关键字接删除关键字K，如图，如图9-15(b)∽∽©所示所示。

⑵ ⑵ 若若结点结点N中的关键字中的关键字个数个数= m/2 -1：若：若结点结点N的的左左(右右)兄弟结点中的关键字个数兄弟结点中的关键字个数> m/2 -1，则将，则将结结点点N的左的左(或右或右)兄弟结点中的最大兄弟结点中的最大(或最小或最小)关键字上关键字上移到其父结点中移到其父结点中，而，而父结点中大于父结点中大于(或小于或小于)且紧靠上且紧靠上移关键字的移关键字的关键字下移到结点关键字下移到结点N，如图，如图9-15(a)⑶ ⑶ 若若结点结点N和其兄弟结点中的和其兄弟结点中的关键字数关键字数= m/2 -1：：删除删除结点结点N中的关键字中的关键字，再将，再将结点结点N中的关键字、中的关键字、指针与其兄弟结点以及分割二者的父结点中的某个指针与其兄弟结点以及分割二者的父结点中的某个关键字关键字Ki，，合并为一个结点合并为一个结点，若因此使，若因此使父结点中的父结点中的关键字个数关键字个数< m/2 -1 ，则依此类推，如图，则依此类推，如图9-15(d)数据结构严蔚敏算法实现算法实现　　　　在在B_树上树上删除一个关键字的操作，针对上述的删除一个关键字的操作，针对上述的⑵⑵和和⑶⑶的情况，相应的算法如下：的情况，相应的算法如下：int BTNode MoveKey(BTNode *p) /* 将将p的左的左(或右或右)兄弟结点中的最大兄弟结点中的最大(或最小或最小)关键字上移关键字上移 */ /* 到其父结点中到其父结点中,父结点中的关键字下移到父结点中的关键字下移到p中中 */{ BTNode *b , *f=p->parent ; /* f指向指向p的父结点的父结点 */int k, j ;for (j=0; f->ptr[j]!=p; j++) /* 在在f中找中找p的位置的位置 */if (j>0) 　　　　/* 若若p有左邻兄弟结点有左邻兄弟结点 */{ b=f->ptr[j-1] ; /* b指向指向p的左邻兄弟的左邻兄弟 */ 数据结构严蔚敏 if (b->keynum>(m-1)/2) /* 左邻兄弟有多余关键字左邻兄弟有多余关键字 */ { for (k=p->keynum; k>=0; k--) { p->key[k+1]=p->key[k]; p->ptr[k+1]=p->ptr[k]; } /* 将将p中关键字和指针后移中关键字和指针后移 */ p->key[1]=f->key[j]; f->key[j]=b->key[keynum] ; /* f中关键字下移到中关键字下移到p, b中最大关键字上移到中最大关键字上移到f */ p->ptr[0]= b->ptr[keynum] ; p->keynum++ ; b->keynum-- ;数据结构严蔚敏 return(1) ; } if (jkeynum) 　　/* 若若p有右邻兄弟结点有右邻兄弟结点 */ { b=f->ptr[j+1] ; /* b指向指向p的右邻兄弟的右邻兄弟 */ if (b->keynum>(m-1)/2) /* 右邻兄弟有多余关键字右邻兄弟有多余关键字 */ { p->key[p->keynum]=f->key[j+1] ; f->key[j+1]=b->key[1]; p->ptr[p->keynum]=b->ptr[0]; /* f中关键字下移到中关键字下移到p, b中最小关键字上移到中最小关键字上移到f */ for (k=0; kkeynum; k++)数据结构严蔚敏 { b->key[k]=b->key[k+1]; b->ptr[k]=b->ptr[k+1]; } /* 将将b中关键字和指针前移中关键字和指针前移 */ p->keynum++ ; b->keynum-- ; return(1) ; } } return(0); } /* 左右兄弟中无多余关键字左右兄弟中无多余关键字,移动失败移动失败 */} 数据结构严蔚敏BTNode *MergeNode(BTNode *p) /* 将将p与其左与其左(右右)邻兄弟合并邻兄弟合并,返回合并后的结点指针返回合并后的结点指针 */{ BTNode *b, f=p->parent ;int j, k ;for (j=0; f->ptr[j]!=p; j++) /* 在在f中找出中找出p的位置的位置 */if (j>0) b=f->ptr[j-1]; /* b指向指向p的左邻兄弟的左邻兄弟 */else { b=p; p=p->ptr[j+1]; } /* p指向指向p的右邻的右邻 */b->key[++b->keynum]=f->key[j] ;b->ptr[p->keynum]=p->ptr[0] ;for (k=1; k<=b->keynum ; k++){ b->key[++b->keynum]=p->key[k] ; b->ptr[b->keynum]=p->ptr[k] ; } /* 将将p中关键字和指针移到中关键字和指针移到b中中 */ 数据结构严蔚敏free(p);for (k=j+1; k<=f->keynum ; k++){ f->key[k-1]=f->key[k] ; f->ptr[k-1]=f->ptr[k] ; } /* 将将f中第中第j个关键字和指针前移个关键字和指针前移 */f->keynum-- ;return(b) ;}数据结构严蔚敏void DeleteBTNode(BTNode *T, KeyType K){ BTNode *p, *S ;int j,n ;m=BT_search(T, K, p) ; /* 在在T中查找中查找K的结点的结点 */if (j==0) return(T) ;if (p->ptr[j-1]){ S=p->ptr[j-1] ;while (S->ptr[S->keynum]) S=S->ptr[S->keynum] ; /* 在子树中找包含最大关键字的结点在子树中找包含最大关键字的结点 */p->key[j]=S->key[S ->keynum] ; p=S ; j=S->keynum ;}数据结构严蔚敏for (n=j+1; nkeynum; n++)p->key[n-1]=p->key[n] ; /* 从从p中删除第中删除第m个关键字个关键字 */ p->keynum-- ;while (p->keynum<(m-1)/2&&p->parent){ if (!MoveKey(p) ) p=MergeNode(p); p=p->parent ;} /* 若若p中关键字树目不够中关键字树目不够,按按⑵⑵处理处理 */ if (p==T&&T->keynum==0){ T=T->ptr[0] ; free(p) ; }}数据结构严蔚敏5 B+树树 在实际的文件系统中在实际的文件系统中，基本上不使用，基本上不使用B_树树，而是使，而是使用用B_树的一种变体树的一种变体，，称为称为m阶阶B+树树。

它与它与B_树的主要树的主要不同是不同是叶子结点中存储记录叶子结点中存储记录在B+树树中中，所有的非叶子，所有的非叶子结点可以看成是索引，而其中的关键字是作为结点可以看成是索引，而其中的关键字是作为““分界关分界关键字键字””，用来界定某一关键字的记录所在的子树一棵，用来界定某一关键字的记录所在的子树一棵m阶阶B+树与树与m阶阶B_树的主要差异是树的主要差异是：：⑴ ⑴ 若一个结点有若一个结点有n棵子树，则必含有棵子树，则必含有n个关键字；个关键字；⑵ ⑵ 所有叶子结点中包含了全部记录的关键字信息以所有叶子结点中包含了全部记录的关键字信息以及这些关键字记录的指针，而且叶子结点按关键字及这些关键字记录的指针，而且叶子结点按关键字的大小从小到大顺序链接；的大小从小到大顺序链接；数据结构严蔚敏⑶⑶ 所有的非叶子结点可以看成是索引的部分，结点所有的非叶子结点可以看成是索引的部分，结点中只含有其子树的根结点中的最大中只含有其子树的根结点中的最大(或最小或最小)关键字如图如图9-16是一棵是一棵3阶阶B+树 由于由于B+树的叶子结点和非叶子结点结构上的显著区树的叶子结点和非叶子结点结构上的显著区别别，因此需要一个标志域加以区分，结点结构定义如下：，因此需要一个标志域加以区分，结点结构定义如下：图图9-16 一棵一棵3阶阶B+树树35 9617 3558 76 965 12 1763 7679 84 9619 23 3541 49 58数据结构严蔚敏typedef enum{branch, left} NodeType ;typedef struct BPNode{ NodeTag tag ; /* 结点标志结点标志 */int keynum ; /* 结点中关键字的个数结点中关键字的个数 */struct BTNode *parent ; /* 指向父结点的指针指向父结点的指针 */KeyType key[M+1] ; /* 组关键字向量组关键字向量,key[0]未用未用 */union pointer{ struct BTNode *ptr[M+1] ; /* 子树指针向量子树指针向量 */RecType *recptr[M+1] ; /* recptr[0]未用未用 */}ptrType ; /* 用联合体定义子树指针和记录指针用联合体定义子树指针和记录指针 */}BPNode ;数据结构严蔚敏 与与B_树相比树相比，对，对B+树不仅可以从根结点开始树不仅可以从根结点开始按关按关键字随机查找，而且可以从最小关键字起，按键字随机查找，而且可以从最小关键字起，按叶子结点叶子结点的链接顺序进行顺序查找的链接顺序进行顺序查找。

在在B+树上进行随机查找、插树上进行随机查找、插入、删除的过程基本上和入、删除的过程基本上和B_树类似树类似 在在B+树上进行随机查找时树上进行随机查找时，若非，若非叶子结点的关键字叶子结点的关键字等于给定的等于给定的K值值，并不终止，而是继续向下直到，并不终止，而是继续向下直到叶子结叶子结点点(只有叶子结点才存储记录只有叶子结点才存储记录) ，， 即无论查找成功与否即无论查找成功与否，，都走了一条从根结点到都走了一条从根结点到叶子结点的路径叶子结点的路径 B+树的插入树的插入仅仅在仅仅在叶子结点上进行叶子结点上进行当叶子结点中叶子结点中的关键字个数的关键字个数大于大于m时时，，““分裂分裂””为两个结点，两个为两个结点，两个结结点中所含有的关键字个数分别是点中所含有的关键字个数分别是 (m+1)/2 和和  (m+1)/2  ，且将这两个，且将这两个结点中的最大关键字提升到父结点中结点中的最大关键字提升到父结点中，用，用来替代原结点在父结点中所对应的关键字提升后父结来替代原结点在父结点中所对应的关键字提升后父结点又可能会分裂，依次类推点又可能会分裂，依次类推。

数据结构严蔚敏9. 6 哈希哈希( (散列散列) )查找查找 基本思想基本思想：：在记录的存储地址和它的关键字之间在记录的存储地址和它的关键字之间建立一个确定的对应关系；这样，不经过比较，一次存建立一个确定的对应关系；这样，不经过比较，一次存取就能得到所查元素的查找方法取就能得到所查元素的查找方法例例 30个地区的各民族人口统计表个地区的各民族人口统计表以编号作关键字，以编号作关键字，构造构造哈希函数：哈希函数：H(key)=keyH(1)=1 ，， H(2)=2以地区别作关键字，取地区以地区别作关键字，取地区名称第一个拼音字母的序号名称第一个拼音字母的序号作哈希函数：作哈希函数：H(Beijing)=2 H(Shanghai)=19 H(Shenyang)=19编号编号省、市省、市(区区)总人口总人口汉族汉族回族回族…...1北京北京2上海上海…...…...数据结构严蔚敏9.6.1 基本概念基本概念 哈希函数哈希函数：：在记录的关键字与记录的存储地址之在记录的关键字与记录的存储地址之间建立的一种对应关系叫哈希函数间建立的一种对应关系叫哈希函数哈希函数是一种映象，是从关键字空间到存储地址空哈希函数是一种映象，是从关键字空间到存储地址空间的一种映象间的一种映象。

可写成：可写成：addr(ai)=H(ki) ，其中，其中i是表是表中一个元素中一个元素，，addr(ai)是是ai的地址的地址，， ki是是ai的关键字的关键字 哈希表哈希表：：应用哈希函数，由记录的关键字确定记应用哈希函数，由记录的关键字确定记录在表中的地址，并将记录放入此地址，这样构成的表录在表中的地址，并将记录放入此地址，这样构成的表叫叫哈希表哈希表 哈希查找哈希查找(又叫散列查找又叫散列查找)：：利用哈希函数进行查利用哈希函数进行查找的过程叫找的过程叫哈希查找哈希查找 数据结构严蔚敏 冲突冲突：对于不同的关键字：对于不同的关键字ki、、kj，，若若ki kj，，但但H(ki)=H(kj)的现象叫冲突的现象叫冲突(collision) 同义词同义词：具有相同函数值的两个不同的关键字，称：具有相同函数值的两个不同的关键字，称为该哈希函数的为该哈希函数的同义词同义词 哈希函数通常是一种压缩映象，所以冲突不可避免，哈希函数通常是一种压缩映象，所以冲突不可避免，只能尽量减少；当冲突发生时，应该有处理冲突的方法只能尽量减少；当冲突发生时，应该有处理冲突的方法。

设计一个散列表应包括设计一个散列表应包括：：①① 散列表的空间范围散列表的空间范围，，即确定散列函数的值域即确定散列函数的值域；；②② 构造合适的散列函数，使得对于所有可能的元素构造合适的散列函数，使得对于所有可能的元素(记录的关键字记录的关键字)，函数值均在散列表的地址空间范围，函数值均在散列表的地址空间范围内，且出现冲突的可能尽量小；内，且出现冲突的可能尽量小； ③③ 处理冲突的方法处理冲突的方法即当冲突出现时如何解决即当冲突出现时如何解决数据结构严蔚敏9.6.2 哈希函数的构造哈希函数的构造 哈希函数是一种映象，其设定很灵活，只要使哈希函数是一种映象，其设定很灵活，只要使任何任何关键字的哈希函数值都落在表长允许的范围之内关键字的哈希函数值都落在表长允许的范围之内即可即可哈希函数哈希函数“好坏好坏”的主要的主要评价因素有评价因素有：：◆◆ 散列函数的构造简单散列函数的构造简单；；◆◆ 能能““均匀均匀””地将散列表中的关键字映射到地址空地将散列表中的关键字映射到地址空间所谓““均匀均匀””(uniform)是指发生冲突的可能性是指发生冲突的可能性尽可能最少。

尽可能最少数据结构严蔚敏1 直接定址法直接定址法 取关键字或关键字的某个线性函数作哈希地址，即取关键字或关键字的某个线性函数作哈希地址，即H(key)=key 或或 H(key)=a·key+b(a,b为常数为常数) 特点特点：：直接定址法所得地址集合与关键字集合大小直接定址法所得地址集合与关键字集合大小相等，不会发生冲突，但实际中很少使用相等，不会发生冲突，但实际中很少使用2 数字分析法数字分析法 对关键字进行分析，取关键字的若干位或组合作为对关键字进行分析，取关键字的若干位或组合作为哈希地址哈希地址 适用于关键字位数比哈希地址位数大，且可能出现适用于关键字位数比哈希地址位数大，且可能出现的关键字事先知道的情况的关键字事先知道的情况数据结构严蔚敏例：例： 设有设有80个记录，关键字为个记录，关键字为8位十进制数，哈希地址位十进制数，哈希地址为为2位十进制数位十进制数┇8 1 3 4 6 5 3 28 1 3 7 2 2 4 28 1 3 8 7 4 2 28 1 3 0 1 3 6 78 1 3 2 2 8 1 7 8 1 3 3 8 9 6 78 1 3 6 8 5 3 78 1 4 1 9 3 5 5   分析：分析：  只取只取8  只取只取1  只取只取3、、4  只取只取2、、7、、5 数字分布近乎随机数字分布近乎随机所以：取所以：取任意两位或两位任意两位或两位 与另两位的叠加作哈希地址与另两位的叠加作哈希地址数据结构严蔚敏3 平方取中法平方取中法 将关键字平方后取中间几位作为哈希地址将关键字平方后取中间几位作为哈希地址。

一个数平方后中间几位和数的每一位都有关，则由一个数平方后中间几位和数的每一位都有关，则由随机分布的关键字得到的散列地址也是随机的随机分布的关键字得到的散列地址也是随机的散列函数所取的位数由散列表的长度决定这种方法数所取的位数由散列表的长度决定这种方法适于不知适于不知道全部关键字情况，是一种较为常用的方法道全部关键字情况，是一种较为常用的方法4 折叠法折叠法 将关键字分割成位数相同的几部分将关键字分割成位数相同的几部分(最后一部分可最后一部分可以不同以不同)，然后取这，然后取这几部分的叠加和几部分的叠加和作为哈希地址作为哈希地址 数位叠加有数位叠加有移位叠加移位叠加和和间界叠加间界叠加两种两种数据结构严蔚敏◆◆ 移位叠加：将分割后的几部分低位对齐相加移位叠加：将分割后的几部分低位对齐相加◆◆ 间界叠加：从一端到另一端沿分割界来回折迭，间界叠加：从一端到另一端沿分割界来回折迭，然后对齐相加然后对齐相加 适于关键字位数很多，且每一位上数字分布大致均适于关键字位数很多，且每一位上数字分布大致均匀情况匀情况例：例： 设关键字为设关键字为0442205864，哈希地址位数为，哈希地址位数为4 。

两两种不同的地址计算方法如下种不同的地址计算方法如下：：5 8 6 44 2 2 00 41 0 0 8 8H(key)=0088移位叠加移位叠加5 8 6 40 2 2 40 4 6 0 9 2H(key)=6092间界叠加间界叠加数据结构严蔚敏5 除留余数法除留余数法 取关键字被某个不大于哈希表表长取关键字被某个不大于哈希表表长m的数的数p除后所得除后所得余数作哈希地址，即余数作哈希地址，即H(key)=key MOD p (p m) 是一种简单、常用的哈希函数构造方法是一种简单、常用的哈希函数构造方法 利用这种方法的关键是利用这种方法的关键是p的选取的选取，，p选的不好，容易选的不好，容易产生同义词产生同义词p的选取的分析的选取的分析：：◆◆ 选取选取p=2i(p m)：运算便于用移位来实现，但等于：运算便于用移位来实现，但等于将关键字的高位忽略而仅留下低位二进制数将关键字的高位忽略而仅留下低位二进制数高位不高位不同而低位相同的关键字是同义词同而低位相同的关键字是同义词 ◆◆ 选取选取p=q f(q、、f都是质因数都是质因数，，p m)：则所有含有：则所有含有q或或f因子的关键字的散列地址均是因子的关键字的散列地址均是q或或f的倍数的倍数。

数据结构严蔚敏◆ ◆ 选取取p为素数或为素数或p=q f(q、、f是质数且均大于是质数且均大于20，，p m)：常用的选取方法，能减少冲突出现的可能性：常用的选取方法，能减少冲突出现的可能性6 随机数法随机数法 取关键字的随机函数值作哈希地址，即取关键字的随机函数值作哈希地址，即H(key)=random(key)当散列表中关键字长度不等时当散列表中关键字长度不等时，，该方法比较合适该方法比较合适选取哈希函数选取哈希函数，，考虑以下因素考虑以下因素◆◆ 计算哈希函数所需时间；计算哈希函数所需时间；◆◆ 关键字的长度；关键字的长度；◆◆ 哈希表长度（哈希地址范围）；哈希表长度（哈希地址范围）；◆◆ 关键字分布情况；关键字分布情况；◆◆ 记录的查找频率记录的查找频率数据结构严蔚敏9.6.3 冲突处理的方法冲突处理的方法冲突处理冲突处理：：当出现冲突时，为冲突元素找到另一个存当出现冲突时，为冲突元素找到另一个存储位置储位置1 开放定址法开放定址法基本方法基本方法：：当冲突发生时，形成某个探测序列；按此当冲突发生时，形成某个探测序列；按此序列逐个探测散列表中的其他地址，直到找到给定的关序列逐个探测散列表中的其他地址，直到找到给定的关键字或一个空地址键字或一个空地址(开放的地址开放的地址)为止，将发生冲突的记为止，将发生冲突的记录放到该地址中录放到该地址中。

散列地址的计算公式是散列地址的计算公式是：： Hi(key)=(H(key)+di) MOD m，，i=1, 2, …, k(k m-1)其中：其中：H(key)：：哈希函数哈希函数；；m：：散列散列表长度表长度；；di：第：第i次探测时的次探测时的增量序列增量序列；；Hi(key) ：经第：经第i次探测后得到的散列地址次探测后得到的散列地址数据结构严蔚敏⑴⑴ 线性探测法线性探测法 将散列表将散列表T[0 …m-1]看成循环向量看成循环向量当发生冲突时当发生冲突时，，从初次发生冲突的位置依次向后探测其他的地址从初次发生冲突的位置依次向后探测其他的地址增量序列为：增量序列为：di=1, 2, 3, …, m-1 设初次发生冲突的地址是设初次发生冲突的地址是h，则依次探测，则依次探测T[h+1]，，T[h+2]…，直到，直到T[m-1]时又循环到表头时又循环到表头，再次探测，再次探测T[0]，，T[1]…，直到，直到T[h-1]探测过程终止的情况是探测过程终止的情况是：：◆◆ 探测到的地址为空探测到的地址为空：表中没有记录：表中没有记录若是查找则若是查找则失败失败；；若是插入则将记录写入到该地址若是插入则将记录写入到该地址；；◆◆ 探测到的地址有给定的关键字探测到的地址有给定的关键字：：若是查找则成功若是查找则成功；；若是插入则失败若是插入则失败；；数据结构严蔚敏◆◆ 直到直到T[h]：仍未：仍未探测到空地址或给定的关键字探测到空地址或给定的关键字，，散列表满。

散列表满例例1 ：：设散列表长为设散列表长为7，，记录关键字组为：记录关键字组为：15, 14, 28, 26, 56, 23，散列函数：，散列函数：H(key)=key MOD 7，，冲突处理冲突处理采用线性探测采用线性探测法法解：解：H(15)=15 MOD 7=1 H(14)=14 MOD 7=0 H(28)=28 MOD 7=0 冲突冲突 H1(28)=1 又又冲突冲突H2(28)=2 H(26)=26 MOD 7=5H(56)=56 MOD 7=0 冲突冲突 H1(56)=1 又又冲突冲突H2(56)=2 又又冲突冲突 H3(56)=3 H(23)=23 MOD 7=2 冲突冲突 H1(23)=3 又又冲突冲突H3(23)=4数据结构严蔚敏线性探测法的特点线性探测法的特点◆◆ 优点优点：只要散列表未满：只要散列表未满，，总能找到一个不冲突的总能找到一个不冲突的散列地址散列地址；；◆◆ 缺点缺点：每个产生冲突的记录被散列到离冲突最近：每个产生冲突的记录被散列到离冲突最近的空地址上的空地址上，从而又，从而又增加了更多的冲突机会增加了更多的冲突机会(这种现这种现象称为冲突的象称为冲突的“聚集聚集”)。

⑵⑵ 二次探测法二次探测法增量序列为：增量序列为：di=1²,-1²,2²,-2²,3²,……±k² (k ⌊ ⌊m/2⌋ ⌋)上述例题若采用二次探测法进行冲突处理上述例题若采用二次探测法进行冲突处理，，则则：：H(15)=15 MOD 7=1 H(14)=14 MOD 7=0 0 1 2 3 4 5 614 15 28 56 23 26数据结构严蔚敏H(28)=28 MOD 7=0 冲突冲突 H1(28)=1 又又冲突冲突H2(28)=4H(26)=26 MOD 7=5H(56)=56 MOD 7=0 冲突冲突 H1(56)=1 又又冲突冲突H2(56)=0 又又冲突冲突 H3(56)=4 又又冲突冲突 H4(56)=2 H(23)=23 MOD 7=2 冲突冲突 H1(23)=3二次探测法的特点二次探测法的特点◆◆ 优点优点：探测序列跳跃式地散列到整个表中：探测序列跳跃式地散列到整个表中，不易，不易产生产生冲突的冲突的“聚集聚集”现象；现象；◆◆ 缺点缺点：不能保证探测到散列表的所有地址：不能保证探测到散列表的所有地址。

14 15 56 23 28 26 0 1 2 3 4 5 6数据结构严蔚敏⑶⑶ 伪随机探测法伪随机探测法 增量序列使用一个增量序列使用一个伪随机函数来产生一个伪随机函数来产生一个落在闭区落在闭区间间[1，，m-1]的的随机序列随机序列例例2 ：： 表长为表长为11的哈希表中已填有关键字为的哈希表中已填有关键字为17，，60，，29的记录，散列函数为的记录，散列函数为H(key)=key MOD 11 现有第现有第4个记录，其关键字为个记录，其关键字为38，按三种处理冲突的方法，将它，按三种处理冲突的方法，将它填入表中填入表中1) H(38)=38 MOD 11=5 冲突冲突 H1=(5+1) MOD 11=6 冲突冲突 H2=(5+2) MOD 11=7 冲突冲突 H3=(5+3) MOD 11=8 不冲突不冲突数据结构严蔚敏(2) H(38)=38 MOD 11=5 冲突冲突 H1=(5+1²) MOD 11=6 冲突冲突 H2=(5-1²) MOD 11=4 不冲突不冲突(3) H(38)=38 MOD 11=5 冲突冲突 设伪随机数序列为设伪随机数序列为9，则，则H1=(5+9) MOD 11=3 不冲突不冲突0 1 2 3 4 5 6 7 8 9 1060 17 29 383838数据结构严蔚敏2 再哈希法再哈希法 构造若干个哈希函数，当发生冲突时，利用不同构造若干个哈希函数，当发生冲突时，利用不同的哈希函数再计算下一个新哈希地址，直到不发生冲突的哈希函数再计算下一个新哈希地址，直到不发生冲突为止为止。

即：即：Hi=RHi(key) i=1, 2, …, k RHi ：一组：一组不同的哈希函数不同的哈希函数第一次发生冲突时，发生冲突时，用用RH1计算，计算，第二次第二次发生冲突时，用发生冲突时，用RH2计算计算…依此类依此类推知道得到某个推知道得到某个Hi不再冲突为止不再冲突为止◆◆ 优点：优点：不易产生不易产生冲突的冲突的“聚集聚集”现象；现象；◆ ◆ 缺点：计算时间增加缺点：计算时间增加数据结构严蔚敏3 链地址法链地址法方法方法：：将所有关键字为同义词将所有关键字为同义词(散列地址相同散列地址相同)的记录存的记录存储在一个单链表中，并用一维数组存放链表的头指针储在一个单链表中，并用一维数组存放链表的头指针 设散列表长为设散列表长为m，定义一个一维指针数组，定义一个一维指针数组：：RecNode *linkhash[m]，其中，其中RecNode是结点类型，每是结点类型，每个分量的初值为空个分量的初值为空凡散列地址为凡散列地址为k的记录都插入到以的记录都插入到以linkhash[k]为头指针的链表中，插入位置可以在表头或为头指针的链表中，插入位置可以在表头或表尾或按关键字排序插入表尾或按关键字排序插入。

例：例： 已知一组关键字已知一组关键字(19, 14, 23, 1, 68, 20, 84, 27, 55, 11, 10, 79) ，哈希函数为：，哈希函数为：H(key)=key MOD 13，，用链用链地址法处理冲突地址法处理冲突，如右图图，如右图图9-17所示所示 优点优点：：不易产生不易产生冲突的冲突的“聚集聚集”；删除记录也很简单删除记录也很简单数据结构严蔚敏图图9-17 用链地址法处理冲突的散列表用链地址法处理冲突的散列表79 ⋀ ⋀ 14 12755 ⋀ ⋀ 6810 ⋀ ⋀ 2320 ⋀ ⋀ 11 ⋀ ⋀ 84 ⋀ ⋀ 190123456789101112⋀ ⋀⋀ ⋀⋀ ⋀⋀ ⋀⋀ ⋀⋀ ⋀⋀ ⋀数据结构严蔚敏4 建立公共溢出区建立公共溢出区方法方法：：在基本散列表之外，另外设立一个溢出表保存在基本散列表之外，另外设立一个溢出表保存与基本表中记录冲突的所有记录与基本表中记录冲突的所有记录 设散列表长为设散列表长为m，设立基本散列表，设立基本散列表hashtable[m]，，每个分量保存一个记录；溢出表每个分量保存一个记录；溢出表overtable[m]，一旦某，一旦某个记录的散列地址发生冲突，都填入溢出表中个记录的散列地址发生冲突，都填入溢出表中。

例：例： 已知一组关键字已知一组关键字(15, 4, 18, 7, 37, 47) ，散列表，散列表长度为长度为7 ，哈希函数为：，哈希函数为：H(key)=key MOD 7，，用用建立公建立公共溢出区共溢出区法处理冲突法处理冲突得到的基本表和溢出表如下得到的基本表和溢出表如下：：Hashtable表：表：散列地址散列地址 0 1 2 3 4 5 6 关键字关键字 7 15 37 4 47 overtable表：表：溢出地址溢出地址 0 1 2 3 4 5 6 关键字关键字 18数据结构严蔚敏9.6.4 哈希查找过程及分析哈希查找过程及分析1 哈希查找过程哈希查找过程 哈希表的主要目的是用哈希表的主要目的是用于快速查找，且插入和删除于快速查找，且插入和删除操作都要用到查找操作都要用到查找由于散由于散列表的特殊组织形式，其查列表的特殊组织形式，其查找有特殊的方法找有特殊的方法 设散列为设散列为HT[0…m-1]，，散列函数为散列函数为H(key)，解决冲，解决冲突的方法为突的方法为R(x, i) ，则在散，则在散列表上查找定值为列表上查找定值为K的记录的记录的过程如图的过程如图9-18所示所示。

给定给定k值值计算计算H(k)此地址为空此地址为空?关键字关键字==k?查找失败查找失败查找成功查找成功按处理冲突按处理冲突方法计算方法计算HiNYYN图图9-18 散列表的查找过程散列表的查找过程数据结构严蔚敏2 查找算法查找算法#define NULLKEY -1 /* 根据关键字类型定义空标识根据关键字类型定义空标识 */typedef struct{ KeyType key ; /* 关键字域关键字域 */otherType otherinfo ; /* 记录的其它域记录的其它域 */}RecType ;int Hash_search(RecType HT[], KeyType k, int m)/* 查找散列表查找散列表HT中的关键字中的关键字K,用开放定址法解决冲突用开放定址法解决冲突 */{ int h, j ;h=h(k) ;while (jkey, k)) return(p); else p=p->link;return(NULL);} /* 查找散列表查找散列表HT中的关键字中的关键字K,用链地址法解决冲突用链地址法解决冲突 */数据结构严蔚敏3 哈希查找分析哈希查找分析 从哈希查找过程可见从哈希查找过程可见：尽管散列表在关键字与记录：尽管散列表在关键字与记录的存储地址之间建立了直接映象的存储地址之间建立了直接映象，但由于，但由于“冲突冲突”，查，查找过程仍是一个给定值与关键字进行比较的过程，评价找过程仍是一个给定值与关键字进行比较的过程，评价哈希查找效率仍要用哈希查找效率仍要用ASL。

哈希查找哈希查找时时关键字与给定值比较的次数取决于：关键字与给定值比较的次数取决于：◆◆ 哈希函数；哈希函数；◆◆ 处理冲突的方法；处理冲突的方法；◆◆ 哈希表的填满因子哈希表的填满因子  填满因子填满因子 的定义是的定义是：：表中填入的记录数表中填入的记录数哈希表长度哈希表长度 =数据结构严蔚敏 各种散列函数所构造的散列表的各种散列函数所构造的散列表的ASL如下如下：： ⑴⑴ 线性探测法的平均查找长度是线性探测法的平均查找长度是：：12)1-  1 (1+Snl成功成功≈12(1-  )21) (1+Snl失败失败≈ ⑵⑵ 二次探测二次探测、、伪随机探测伪随机探测、、再再哈希哈希法的平均查找长度法的平均查找长度是是：：11- Snl失败失败≈ ㏑㏑(1- )1 Snl成功成功≈ -⑶⑶ 用链地址法解决冲突的平均查找长度是用链地址法解决冲突的平均查找长度是：：Snl失败失败≈  +e-  21+Snl成功成功≈数据结构严蔚敏习习 题题 九九⑴⑴ 对于一个有对于一个有n个元素的线性表，若采用顺序查找方个元素的线性表，若采用顺序查找方法时的平均查找长度是什么？若结点是有序的，则采用法时的平均查找长度是什么？若结点是有序的，则采用折半查找法是的平均查找长度是什么折半查找法是的平均查找长度是什么? ⑵⑵ 设查找表采用单链表存储，请分别写出对该表进行设查找表采用单链表存储，请分别写出对该表进行顺序查找的静态查找和动态查找的算法。

顺序查找的静态查找和动态查找的算法⑶⑶ 设二叉排序树中的关键字互不相同：则设二叉排序树中的关键字互不相同：则①① 最小元素无左孩子，最大元素无右孩子，此命最小元素无左孩子，最大元素无右孩子，此命题是否正确？题是否正确？②② 最大和最小元素一定是叶子结点吗？最大和最小元素一定是叶子结点吗？③③ 一个新结点总是插入在叶子结点上吗？一个新结点总是插入在叶子结点上吗？数据结构严蔚敏⑷ ⑷ 试比较哈希表构造时几种冲突处理方法的优点和试比较哈希表构造时几种冲突处理方法的优点和缺点⑸ ⑸ 将关键字序列将关键字序列(10, 2, 26, 4, 18, 24, 21, 15, 8, 23, 5, 12, 14)依次插入到初态为空的依次插入到初态为空的二叉排序树中，请画出所二叉排序树中，请画出所得到的树得到的树T；； 然后画出删除然后画出删除10之后的之后的二叉排序树二叉排序树T1 ；； 若若再将再将10插入到插入到T1中得到的二中得到的二叉排序树叉排序树T2是否与是否与T1相同相同? 请给出请给出T2的先序的先序、、中序和后序序列中序和后序序列⑹ ⑹ 设有关键字序列为：设有关键字序列为：(Dec, Feb, Nov, Oct, June, Sept, Aug, Apr, May, July, Jan, Mar) ，请手工构造一棵，请手工构造一棵二叉排序树。

该树是二叉排序树该树是平衡二平衡二叉排序树叉排序树? 若不是，请为其若不是，请为其构造一棵平衡二叉排序树构造一棵平衡二叉排序树数据结构严蔚敏⑺ ⑺ 设关键字序列是设关键字序列是(19, 14, 23, 01, 68, 84, 27, 55, 11, 34, 79)，散列表长度是，散列表长度是11，散列函数是，散列函数是H(key)=key MOD 11，，① ① 采用开放地址法的线性探测方法解决冲突，采用开放地址法的线性探测方法解决冲突，请请构造该关键字序列的哈希表构造该关键字序列的哈希表② ② 采用开放地址法的二次探测方法解决冲突，采用开放地址法的二次探测方法解决冲突，请请构造该关键字序列的哈希表构造该关键字序列的哈希表⑻ ⑻ 试比较线性索引和树形索引的优点和缺点试比较线性索引和树形索引的优点和缺点数据结构严蔚敏⑼ ⑼ 设关键字序列是设关键字序列是(19, 24, 23, 17, 38, 04, 27, 51, 31, 34, 69)，散列表长度是，散列表长度是11，散列函数是，散列函数是H(key)=key MOD 11，，① ① 采用开放地址法的线性探测方法解决冲突，采用开放地址法的线性探测方法解决冲突，请请构造该关键字序列的哈希表构造该关键字序列的哈希表。

② ② 求出在等概率情况下，该方法的查找成功和不求出在等概率情况下，该方法的查找成功和不成功的平均查找长度成功的平均查找长度ASL⑽ ⑽ 下图是一棵下图是一棵3阶阶B_树树，请画出插入关键字，请画出插入关键字B,L,P,Q后的树形后的树形GD EI MCAHJ KN O数据结构严蔚敏第第10章章 内部排序内部排序 在信息处理过程中，最基本的操作是查找从查找在信息处理过程中，最基本的操作是查找从查找来说，效率最高的是折半查找，折半查找的前提是所有来说，效率最高的是折半查找，折半查找的前提是所有的数据元素的数据元素(记录记录)是按关键字有序的需要将一个无序是按关键字有序的需要将一个无序的数据文件转变为一个有序的数据文件的数据文件转变为一个有序的数据文件 将任一文件中的记录通过某种方法整理成为按将任一文件中的记录通过某种方法整理成为按(记记录录)关键字有序排列的处理过程称为关键字有序排列的处理过程称为排序排序 排序是排序是数据处理数据处理中一种中一种最常用的操作最常用的操作数据结构严蔚敏10.1 排序的基本概念排序的基本概念⑴⑴ 排序排序(Sorting) 排序排序是将一批是将一批(组组)任意次序的记录重新排列成任意次序的记录重新排列成按关按关键字有序键字有序的记录序列的过程，其定义为：的记录序列的过程，其定义为： 给定一组记录序列：给定一组记录序列：{R1 , R2 , ,…, Rn}，其相应的，其相应的关键字序列是关键字序列是{K1 , K2 , ,…, Kn} 。

确定确定1, 2, … n的一个的一个排列排列p1 , p2 , ,…, pn，使其相应的关键字满足如下非递减，使其相应的关键字满足如下非递减(或非递增或非递增)关系：关系： Kp1≤Kp2 ≤…≤Kpn的序列的序列{Kp1 ,Kp2 , …,Kpn} ，这种操作称为排序这种操作称为排序 关键字关键字Ki可以是记录可以是记录Ri的主关键字，也可以是次关的主关键字，也可以是次关键字或若干数据项的组合键字或若干数据项的组合数据结构严蔚敏 ◆◆ Ki是主关键字：排序后得到的结果是唯一的；是主关键字：排序后得到的结果是唯一的； ◆◆ Ki是次关键字：排序后得到的结果是不唯一的是次关键字：排序后得到的结果是不唯一的⑵⑵ 排序的稳定性排序的稳定性 若记录序列中有若记录序列中有两个或两个以上关键字相等两个或两个以上关键字相等的记录：的记录： Ki =Kj(i≠j，，i, j=1, 2, … n)，且在排序前，且在排序前Ri先于先于Rj(i

排序算法有许多，但就全面性能而言，还没有一种排序算法有许多，但就全面性能而言，还没有一种公认为最好的每种算法都有其优点和缺点，分别适合公认为最好的每种算法都有其优点和缺点，分别适合不同的数据量和硬件配置不同的数据量和硬件配置 评价排序算法的标准有：评价排序算法的标准有：执行时间执行时间和和所需的辅助空所需的辅助空间间，其次是，其次是算法的稳定性算法的稳定性数据结构严蔚敏 若排序算法所需的辅助空间不依赖问题的规模若排序算法所需的辅助空间不依赖问题的规模n，即，即空间复杂度是空间复杂度是O(1) ，则称排序方法是，则称排序方法是就地排序就地排序，否则是，否则是非就地排序非就地排序⑶ ⑶ 排序的分类排序的分类 待排序的记录数量不同，排序过程中涉及的存储器待排序的记录数量不同，排序过程中涉及的存储器的不同，有不同的排序分类的不同，有不同的排序分类①① 待排序的记录数不太多待排序的记录数不太多：所有的记录都能存放在：所有的记录都能存放在内存中进行排序，称为内存中进行排序，称为内部排序内部排序；；②② 待排序的记录数太多待排序的记录数太多：所有的记录不可能存放在：所有的记录不可能存放在内存中，内存中， 排序过程中必须在内、外存之间进行数据排序过程中必须在内、外存之间进行数据交换，这样的排序称为交换，这样的排序称为外部排序外部排序。

数据结构严蔚敏⑷ ⑷ 内部排序的基本操作内部排序的基本操作 对内部排序地而言，其基本操作有两种：对内部排序地而言，其基本操作有两种：◆◆ 比较两个关键字的大小；比较两个关键字的大小；◆◆ 存储位置的移动：从一个位置移到另一个位置存储位置的移动：从一个位置移到另一个位置 第一种操作是必不可少的；而第二种操作却不是必第一种操作是必不可少的；而第二种操作却不是必须的，取决于记录的存储方式，具体情况是：须的，取决于记录的存储方式，具体情况是：①① 记录存储在一组连续地址的存储空间记录存储在一组连续地址的存储空间：记录之间：记录之间的逻辑顺序关系是通过其物理存储位置的相邻来体现，的逻辑顺序关系是通过其物理存储位置的相邻来体现，记录的移动是必不可少的记录的移动是必不可少的；；②② 记录采用链式存储方式记录采用链式存储方式：记录之间的逻辑顺序关：记录之间的逻辑顺序关系是通过结点中的指针来体现，排序过程系是通过结点中的指针来体现，排序过程仅需修改结仅需修改结点的指针点的指针，而，而不需要移动记录不需要移动记录；；数据结构严蔚敏③③ 记录存储在一组连续地址的存储空间记录存储在一组连续地址的存储空间：构造另一：构造另一个辅助表来保存各个记录的存放地址个辅助表来保存各个记录的存放地址(指针指针) ：排序过：排序过程程不需要移动记录不需要移动记录，而，而仅需修改仅需修改辅助表中的辅助表中的指针指针，排，排序后视具体情况决定是否调整记录的存储位置。

序后视具体情况决定是否调整记录的存储位置 ①①比较适合记录数较少的情况；而比较适合记录数较少的情况；而②②、、③③则适合记则适合记录数较少的情况录数较少的情况 为讨论方便，假设待排序的记录是以为讨论方便，假设待排序的记录是以①①的情况存储，的情况存储，且设排序是按升序排列的；关键字是一些可直接用比较且设排序是按升序排列的；关键字是一些可直接用比较运算符进行比较的类型运算符进行比较的类型数据结构严蔚敏待排序的记录类型的定义如下：待排序的记录类型的定义如下：#define MAX_SIZE 100Typedef int KeyType ;typedef struct RecType{ KeyType key ; /* 关键字码关键字码 */infoType otherinfo ; /* 其他域其他域 */}RecType ;typedef struct Sqlist{ RecType R[MAX_SIZE] ;int length ;}Sqlist ;数据结构严蔚敏10.2 插入排序插入排序 采用的是以采用的是以 “玩桥牌者玩桥牌者”的方法为基础的的方法为基础的。

即在考即在考察记录察记录Ri之前之前，设以前的所有记录，设以前的所有记录R1, R2 ,…., Ri-1已排好已排好序序，然后将，然后将Ri插入到插入到已排好序的诸记录的适当位置已排好序的诸记录的适当位置 最基本的插入排序是最基本的插入排序是直接插入排序直接插入排序(Straight Insertion Sort) 数据结构严蔚敏10.2.1 直接插入排序直接插入排序1 排序思想排序思想 将待排序的记录将待排序的记录Ri，插入到已，插入到已排好序的排好序的记录表记录表R1, R2 ,…., Ri-1中中，得到一个新的、记录数增加，得到一个新的、记录数增加1的有序表的有序表 直到所有的记录都插入完为止直到所有的记录都插入完为止 设设待排序的记录顺序存放在数组待排序的记录顺序存放在数组R[1…n]中，在排序中，在排序的某一时刻，将记录序列分成两部分：的某一时刻，将记录序列分成两部分：◆◆ R[1…i-1]：已：已排好序的有序部分排好序的有序部分；；◆◆ R[i…n]：未：未排好序的无序部分排好序的无序部分 显然，在刚开始排序时，显然，在刚开始排序时，R[1]是已经是已经排好序的。

排好序的数据结构严蔚敏 例例：：设有关键字序列为：设有关键字序列为：7, 4, -2, 19, 13, 6，直接插，直接插入排序的过程如下图入排序的过程如下图10-1所示：所示：初始记录的关键字：初始记录的关键字： [7] 4 -2 19 13 6第一趟排序：第一趟排序： [4 7] -2 19 13 6第二趟排序：第二趟排序： [-2 4 7] 19 13 6第三趟排序：第三趟排序： [-2 4 7 19] 13 6第四趟排序：第四趟排序： [-2 4 7 13 19] 6第五趟排序：第五趟排序： [-2 4 6 7 13 19]图图10-1 直接插入排序的过程直接插入排序的过程数据结构严蔚敏2 算法实现算法实现void straight_insert_sort(Sqlist *L){ int i, j ;for (i=2; i<=L->length; i++){ L->R[0]=L->R[i]; j=i-1; /* 设置哨兵设置哨兵 */while( LT(L->R[0].key, L->R[j].key) ) { L->R[j+1]=L->R[j]; j--; } /* 查找插入位置查找插入位置 */L->R[j+1]=L->R[0]; /* 插入到相应位置插入到相应位置 */}}数据结构严蔚敏3 算法说明算法说明 算法中的算法中的R[0]开始时并不存放任何待排序的记录，开始时并不存放任何待排序的记录，引入的作用主要有两个：引入的作用主要有两个：①① 不需要增加辅助空间：不需要增加辅助空间： 保存当前待插入的记录保存当前待插入的记录R[i]，，R[i]会因为记录的后移而被占用；会因为记录的后移而被占用；②② 保证查找插入位置的内循环总可以在超出循环边保证查找插入位置的内循环总可以在超出循环边界之前找到一个等于当前记录的记录，起界之前找到一个等于当前记录的记录，起“哨兵监视哨兵监视”作用，避免在内循环中每次都要判断作用，避免在内循环中每次都要判断j是否越界是否越界。

数据结构严蔚敏4 算法分析算法分析⑴ ⑴ 最好情况最好情况：：若待排序记录按关键字从小到大排若待排序记录按关键字从小到大排列列( (正序正序) )，算法中的内循环无须执行，则一趟排序时：，算法中的内循环无须执行，则一趟排序时：关键字比较次数关键字比较次数1次，记录移动次数次，记录移动次数2次次(R[i]→R[0], R[0]→R[j+1]) 则整个排序的关键字比较次数和记录移动次数分别则整个排序的关键字比较次数和记录移动次数分别是：是：比较次数比较次数：：∑1=n-1ni=2移动次数移动次数：：∑ 2=2(n-1)ni=2数据结构严蔚敏⑵ ⑵ 最坏情况最坏情况：：若待排序记录按关键字从大到小排若待排序记录按关键字从大到小排列列( (逆序逆序) )，则一趟排序时：算法中的内循环体执行，则一趟排序时：算法中的内循环体执行i-1，关键字比较次数，关键字比较次数i次，记录移动次数次，记录移动次数i+1则就整个排序而言：则就整个排序而言：比较次数比较次数：：∑ i=ni=2(n-1)(n+1)2移动次数移动次数：：∑(i+1)=ni=2(n-1)(n+4)2 一般地一般地，认为，认为待排序的记录可能出现的各种排列的待排序的记录可能出现的各种排列的概率相同概率相同，则取以上两种情况的平均值，作为排序的，则取以上两种情况的平均值，作为排序的关关键字比较次数和记录移动次数键字比较次数和记录移动次数，，约为约为n2/4，则复杂度为，则复杂度为O(n2) 。

数据结构严蔚敏10.2.2 其它插入排序其它插入排序1 折半插入排序折半插入排序 当将待排序的记录当将待排序的记录R[i] 插入到已插入到已排好序的排好序的记录子表记录子表R[1…i-1]中时中时，由于，由于R1, R2 ,…, Ri-1已已排好序排好序，则查找插，则查找插入位置可以用入位置可以用“折半查找折半查找”实现，则直接插入排序就变实现，则直接插入排序就变成为折半插入排序成为折半插入排序⑴ ⑴ 算法实现算法实现void Binary_insert_sort(Sqlist *L){ int i, j, low, high, mid ;for (i=2; i<=L->length; i++){ L->R[0]=L->R[i]; /* 设置哨兵设置哨兵 */数据结构严蔚敏low=1 ; high=i-1 ; while (low<=high) { if ( LT(L->R[0].key, L->R[mid].key) ) high=mid-1 ; else low=mid+1 ; } /* 查找插入位置查找插入位置 */for (j=i-1; j>=high+1; j--)L->R[j+1]=L->R[j]; L->R[high+1]=L->R[0]; /* 插入到相应位置插入到相应位置 */}}数据结构严蔚敏 从时间上比较从时间上比较，折半插入排序仅仅减少了关键字的，折半插入排序仅仅减少了关键字的比较次数比较次数，却没有减少，却没有减少记录的移动次数记录的移动次数，，故时间故时间复杂度复杂度仍然为仍然为O(n2) 。

⑵⑵ 排序示例排序示例 设有一组关键字设有一组关键字30, 13, 70, 85, 39, 42, 6, 20，采用折，采用折半插入排序方法排序的过程如图半插入排序方法排序的过程如图10-2所示：所示：数据结构严蔚敏i=1 (30) 13 70 85 39 42 6 20i=2 13 (13 30) 70 85 39 42 6 20┇ ┇i=7 6 (6 13 30 39 42 70 85) 20i=8 20 (6 13 30 39 42 70 85) 20lowhighmidi=8 20 (6 13 30 39 42 70 85) 20lowhighmidi=8 20 (6 13 30 39 42 70 85) 20mid highlowi=8 20 (6 13 20 30 39 42 70 85)图图10-2 折半插入排序过程折半插入排序过程数据结构严蔚敏2 2-路插入排序路插入排序 是对折半插入排序的改进是对折半插入排序的改进，，以减少排序过程中移动以减少排序过程中移动记录的次数。

附加记录的次数附加n个记录的辅助空间个记录的辅助空间，方法是，方法是：：① ① 另设一个和另设一个和L->R同类型的数组同类型的数组d，，L->R[1]赋给赋给d[1]，将，将d[1]看成是排好序的序列中中间位置的记录；看成是排好序的序列中中间位置的记录；②② 分别将分别将L->R[ ]中的第中的第i个记录依次插入到个记录依次插入到d[1]之前之前或之后或之后的有序序列中，具体方法的有序序列中，具体方法：： ◆◆ L->R[i].keyR[i]插入到插入到d[1]之之前前的有序表中；的有序表中；◆◆ L->R[i].key≥d[1].key：： L->R[i]插入到插入到d[1]之之后后的有序表中；的有序表中；数据结构严蔚敏关键点关键点：：实现时将实现时将向量向量d看成是循环向量，并设两个指看成是循环向量，并设两个指针针first和和final分别指示排序过程中得到的有序序列中的分别指示排序过程中得到的有序序列中的第一个和最后一个记录第一个和最后一个记录排序示例排序示例设有初始关键字集合设有初始关键字集合{49, 38, 65, 13, 97, 27, 76} ，采用，采用2-路插入排序的过程如右图路插入排序的过程如右图10-3所示所示。

在在2-路插入排序中，移动记录的次数约为路插入排序中，移动记录的次数约为n2/8 但当当L->R[1]是待排序记录中关键字最大或最小的记录时是待排序记录中关键字最大或最小的记录时，，2-路插入排序就完全失去了优越性路插入排序就完全失去了优越性数据结构严蔚敏2776d49firstfirstfirstfirstfinalfinalfinalfinal653897971313图图10-3 2-路插入排序过程路插入排序过程3 表插入排序表插入排序前面的插入排序不可避免地要移动记录前面的插入排序不可避免地要移动记录，，若不移动记录若不移动记录就需要改变数据结构附加就需要改变数据结构附加n个记录的辅助空间个记录的辅助空间，记录，记录类型修改为：类型修改为：数据结构严蔚敏typedef struct RecNode{ KeyType key ;infotype otherinfo ;int *next;}RecNode ;初始化初始化：下标值为：下标值为0的分量作为表头结点的分量作为表头结点，关键字取，关键字取为最大值，各分量的指针值为空；为最大值，各分量的指针值为空；① ① 将静态链表中将静态链表中数组下标值为数组下标值为1的分量的分量(结点结点)与表头与表头结点构成一个循环链表；结点构成一个循环链表；② ② i=2 ，将分量，将分量R[i]按关键字递减插入到循环链表；按关键字递减插入到循环链表；③③ 增加增加i ，重复，重复②②，直到全部分量插入到循环链表，直到全部分量插入到循环链表。

数据结构严蔚敏例：例：设有关键字集合设有关键字集合{49, 38, 65, 97, 76, 13, 27, 49} ，采，采用表插入排序的过程如下图用表插入排序的过程如下图10-4所示所示 0 1 2 3 4 5 6 7 8key域域next域域MAXINT 49 38 65 13 97 27 76 49 1 0 - - - - - - -i=2MAXINT 49 38 65 13 97 27 76 49 2 0 1 - - - - - -i=3MAXINT 49 38 65 13 97 27 76 49 2 3 1 0 - - - - -i=4MAXINT 49 38 65 13 97 27 76 49 4 3 1 0 2 - - - -i=5MAXINT 49 38 65 13 97 27 76 49 4 3 1 5 2 0 - - -数据结构严蔚敏 和直接插入排序相比，不同的是修改和直接插入排序相比，不同的是修改2n次指针值以次指针值以代替移动记录，而代替移动记录，而关键字的比较次数相同关键字的比较次数相同，，故时间复杂故时间复杂度为度为O(n2)。

表表插入排序得到一个有序链表，对其可以方便地进插入排序得到一个有序链表，对其可以方便地进行顺序查找，但不能实现随即查找行顺序查找，但不能实现随即查找根据需要，可以对根据需要，可以对记录进行重排，记录重排详见记录进行重排，记录重排详见P268i=6MAXINT 49 38 65 13 97 27 76 49 4 3 1 5 6 0 2 - -i=7MAXINT 49 38 65 13 97 27 76 49 4 3 1 7 6 0 2 5 -i=8MAXINT 49 38 65 13 97 27 76 49 4 8 1 7 6 0 2 5 3图图10-4 表插入排序过程表插入排序过程数据结构严蔚敏10.2.3 希尔排序希尔排序 希尔排序希尔排序(Shell Sort，又称，又称缩小增量法缩小增量法)是一种分组是一种分组插入排序方法插入排序方法。

1 排序思想排序思想①① 先取一个正整数先取一个正整数d1(d1

void shell_pass(Sqlist *L, int d) /* 对顺序表对顺序表L进行一趟希尔排序进行一趟希尔排序, 增量为增量为d */{ int j, k ;for (j=d+1; j<=L->length; j++){ L->R[0]=L->R[j] ; /* 设置监视哨兵设置监视哨兵 */k=j-d ;while (k>0&<(L->R[0].key, L->R[k].key) ) { L->R[k+d]=L->R[k] ; k=k-d ; }L->R[k+j]=L->R[0] ;}}数据结构严蔚敏 然后在根据增量数组然后在根据增量数组dk进行希尔排序进行希尔排序void shell_sort(Sqlist *L, int dk[], int t) /* 按增量序列按增量序列dk[0 … t-1],对顺序表对顺序表L进行希尔排序进行希尔排序 */{ int m ;for (m=0; m<=t; m++)shll_pass(L, dk[m]) ;} 希尔排序的分析比较复杂，涉及一些数学上的问题，希尔排序的分析比较复杂，涉及一些数学上的问题，其时间是所取的其时间是所取的“增量增量”序列的函数序列的函数。

希尔排序特点希尔排序特点 子序列的构成不是简单的子序列的构成不是简单的“逐段分割逐段分割”，而是将相，而是将相隔某个增量的记录组成一个子序列隔某个增量的记录组成一个子序列数据结构严蔚敏 希尔排序可提高排序速度，原因是：希尔排序可提高排序速度，原因是：◆◆ 分组后分组后n值减小，值减小，n²更小，而更小，而T(n)=O(n²),所以所以T(n)从总体上看是减小了从总体上看是减小了；；◆◆ 关键字较小的记录跳跃式前移，在进行最后一趟关键字较小的记录跳跃式前移，在进行最后一趟增量增量为为1的插入排序时，序列已基本有序的插入排序时，序列已基本有序增量序列取法增量序列取法◆◆ 无除无除1以外的公因子以外的公因子；；◆◆ 最后一个增量值必须为最后一个增量值必须为1数据结构严蔚敏10.3 快速排序快速排序 是一类基于交换的排序是一类基于交换的排序，系统地，系统地交换反序的记录交换反序的记录的偶对的偶对，直到不再有这样一来的偶对为止其中最基本，直到不再有这样一来的偶对为止其中最基本的是的是冒泡排序冒泡排序(Bubble Sort)数据结构严蔚敏10.3.1 冒泡冒泡排序排序1 排序思想排序思想 依次比较相邻的两个记录的关键字依次比较相邻的两个记录的关键字，若两个记录，若两个记录是反序的是反序的(即前一个记录的关键字即前一个记录的关键字大于大于后前一个记录的后前一个记录的关键字关键字)，则进行交换，直到没有反序的记录为止。

则进行交换，直到没有反序的记录为止① ① 首先将首先将L->R[1]与与L->R[2]的关键字进行比较的关键字进行比较，若，若为反序为反序( (L->R[1]的关键字大于的关键字大于L->R[2]的关键字的关键字) )，则，则交换两个记录交换两个记录；；然后比较然后比较L->R[2]与与L->R[3]的关键字的关键字，，依此类推，直到依此类推，直到L->R[n-1]与与L->R[n]的关键字比较后的关键字比较后为止为止，称为一趟，称为一趟冒泡排序冒泡排序，，L->R[n]为关键字最大的为关键字最大的记录记录数据结构严蔚敏② ② 然后进行第二趟然后进行第二趟冒泡排序冒泡排序，对前，对前n-1个记录进行个记录进行同样的操作同样的操作 一般地，第一般地，第i趟冒泡排序是对趟冒泡排序是对L->R[1 … n-i+1]中的中的记录进行的记录进行的，因此，若待排序的记录有，因此，若待排序的记录有n个个，则要经过，则要经过n-1趟趟冒泡排序才能使所有的记录有序冒泡排序才能使所有的记录有序2 排序示排序示例例 设有设有9个待排序的记录个待排序的记录，关键字分别为，关键字分别为23, 38, 22, 45, 23, 67, 31, 15, 41，冒泡排序的过程如图，冒泡排序的过程如图10-6所示所示。

3 算法实现算法实现#define FALSE 0#define TRUE 1数据结构严蔚敏图图10-6 冒泡排序过程冒泡排序过程23 38 22 45 23 67 31 15 41初始关键字序列初始关键字序列:第一趟排序后第一趟排序后:23 22 38 23 45 31 15 41 67第二趟排序后第二趟排序后:22 23 23 38 31 15 41 45 67第三趟排序后第三趟排序后:22 23 23 31 15 38 41 45 67第四趟排序后第四趟排序后:22 23 23 15 31 38 41 45 67第五趟排序后第五趟排序后:22 23 15 23 31 38 41 45 67第六趟排序后第六趟排序后:22 15 23 23 31 38 41 45 67第七趟排序后第七趟排序后:15 22 23 23 31 38 41 45 67数据结构严蔚敏void Bubble_Sort(Sqlist *L){ int j ,k , flag ;for (j=0; jlength; j++) /* 共有共有n-1趟排序趟排序 */{ flag=TRUE ;for (k=1; k<=L->length-j; k++) /* 一趟排序一趟排序 */ if (LT(L->R[k+1].key, L->R[k].key ) ) { flag=FALSE ; L->R[0]=L->R[k] ; L->R[k]=L->R[k+1] ; L->R[k+1]=L->R[0] ; } if (flag==TRUE) break ;}}数据结构严蔚敏故时间复杂度故时间复杂度：：T(n)=O(n²)空间复杂度：空间复杂度：S(n)=O(1)4 算法分析算法分析时间复杂度时间复杂度◆◆ 最好情况最好情况(正序正序)：：比较次数：比较次数：n-1；移动次数：；移动次数：0；；◆◆ 最坏情况最坏情况(逆序逆序)：：比较次数比较次数：：∑(n-i)=n-1i=1n(n-1)2移动次数移动次数：： 3∑(n-i)=n-1i=13n(n-1)2数据结构严蔚敏10.3.2 快速排序快速排序1 排序思想排序思想 通过一趟排序，将待排序记录分割成独立的两部分，通过一趟排序，将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，其中一部分记录的关键字均比另一部分记录的关键字小，再分别对这两部分记录进行下一趟排序，以达到整个序再分别对这两部分记录进行下一趟排序，以达到整个序列有序列有序。

2 排序过程排序过程 设待排序的记录序列是设待排序的记录序列是R[s…t] ，在，在记录序列中记录序列中任取任取一个记录一个记录(一般取一般取R[s])作为作为参照参照(又称为又称为基准基准或或枢轴枢轴)，以，以R[s].key为基准重新排列其余的所有记录，方法是为基准重新排列其余的所有记录，方法是：：数据结构严蔚敏◆◆ 所有关键字比基准小的放所有关键字比基准小的放R[s]之前之前；；◆◆ 所有关键字比基准大的放所有关键字比基准大的放R[s]之后之后 以以R[s].key最后所在位置最后所在位置i作为分界，将序列作为分界，将序列R[s…t]分割成两个子序列，称为一趟快速排序分割成两个子序列，称为一趟快速排序3 一趟快速排序方法一趟快速排序方法 从序列的两端交替扫描各个记录，将从序列的两端交替扫描各个记录，将关键字小于关键字小于基准关键字的记录基准关键字的记录依次依次放置到序列的前边放置到序列的前边；；而将而将关键字关键字大于基准关键字的记录大于基准关键字的记录从序列的最后端起，依次从序列的最后端起，依次放置到放置到序列的后边序列的后边，直到扫描完所有的记录，直到扫描完所有的记录。

设置指针设置指针low，，high，初值为第，初值为第1个和最后一个记录个和最后一个记录的位置数据结构严蔚敏 设两个变量设两个变量i，，j，初始时令，初始时令i=low，，j=high，，以以R[low].key作为基准作为基准(将将R[low]保存在保存在R[0]中中) ① ① 从从j所指位置向前搜索：将所指位置向前搜索：将R[0].key与与R[j].key进行进行比较比较：：◆◆ 若若R[0].key≤R[j].key ：令：令j=j-1，然后继续进行，然后继续进行比较，比较， 直到直到i=j或或R[0].key>R[j].key为止为止；；◆◆ 若若R[0].key>R[j].key ：：R[j]R[i]，，腾空腾空R[j]的的位置位置，， 且令且令i=i+1；；② ② 从从i所指位置起向后搜索：将所指位置起向后搜索：将R[0].key与与R[i].key进进行比较行比较：：◆◆ 若若R[0].key≥R[i].key ：令：令i=i+1，然后继续进行，然后继续进行比较，比较， 直到直到i=j或或R[0].key

4 一趟排序示一趟排序示例例 设有设有6个待排序的记录个待排序的记录，关键字分别为，关键字分别为29, 38, 22, 45, 23, 67，一趟快速排序的过程如图，一趟快速排序的过程如图10-7所示所示5 算法实现算法实现⑴⑴ 一趟快速排序算法的实现一趟快速排序算法的实现int quick_one_pass(Sqlist *L , int low, int high){ int i=low, j=high ;数据结构严蔚敏图图10-7 一趟快速排序过程一趟快速排序过程j前移前移2个位置后个位置后,R[j]放放R[i]的位置的位置:29 23 38 22 45 67 31ij初始关键字序列初始关键字序列:29 29 38 22 45 23 67 31ij029 23 22 45 38 67 31iji后移后移1个位置后个位置后,R[i]放放R[j]的位置的位置:29 23 22 45 38 67 31ijj前移前移2个位置后个位置后,R[j]放放R[i]的位置的位置:29 23 22 29 45 38 67 31i ji后前移后前移1个位置后个位置后,i和和j的位置重合的位置重合:数据结构严蔚敏L->R[0]=L->R[i] ; /* R[0]作为临时单元和哨兵作为临时单元和哨兵 */do { while (LQ(L->R[0].key, L->R[j].key)&&(j>i)) j-- ;if (j>i) { L->R[i]=L->R[j] ; i++; }while (LQ(L->R[i].key, L->R[0].key)&&(j>i)) i++ ;if (j>i) { L->R[j]=L->R[i] ; j--; }} while(i!=j) ; /* i=j时退出扫描时退出扫描 */L->R[i]=L->R[0] ; return(i) ;}数据结构严蔚敏⑵⑵ 快速排序算法实现快速排序算法实现 当进行一趟快速排序后当进行一趟快速排序后，，采采用同样方法分别对用同样方法分别对两两个个子序列子序列快速排序快速排序，直到，直到子子序列记录个为序列记录个为1为止为止。

①① 递归算法递归算法 void quick_Sort(Sqlist *L , int low, int high){ int k ;if (low

设长度设长度为为n的记录序列进行排序的比较次数为的记录序列进行排序的比较次数为C(n)，则，则C(n)=n-1+C(k)+C(n-k-1) ◆◆ 最好情况最好情况：：每次划分得到的子序列大致相等每次划分得到的子序列大致相等，则，则C(n)≤n+2×C(n/2)+C(n-k-1)≤n+2×[n/2+ 2×C((n/2)/2)≤ 2n+4×C(n/4)≤…≤h×n+2h×C(n/2h) ，当，当n/2h=1时排序结束时排序结束数据结构严蔚敏即即C(n)≤n×㏒㏒2n+n×C(1) ，，C(1)看成常数因子看成常数因子，，即即C(n)≤O(n×㏒㏒2n) ；；◆◆ 最坏情况最坏情况：：每次划分得到的子序列中有一个为空每次划分得到的子序列中有一个为空，，另一个子序列的长度为另一个子序列的长度为n-1即每次划分所选择的基即每次划分所选择的基准是当前待排序序列中的最小准是当前待排序序列中的最小(或最大或最大)关键字比较次数比较次数：：∑(n-i)=n-1i=1n(n-1)2即即C(n)=O(n2)◆◆ 一般情况一般情况：： 对对n个记录进行快速排序所需的时间个记录进行快速排序所需的时间T(n)组成是组成是：：① ① 对对n个记录进行一趟划分所需的时间是个记录进行一趟划分所需的时间是：：n×C ，，C是是常常数数；；② ② 对对所得到的两个子序列所得到的两个子序列进行快速排序的时间进行快速排序的时间：：Tavg(n)=C(n)+Tavg(k-1)+Tavg(n-k) …… ⑴⑴数据结构严蔚敏 若记录是随机排列的，若记录是随机排列的，k取值在取值在1~n之间的概率相同之间的概率相同，，则：则：Tavg(n)=n×C+∑ [Tavg(k-1)+Tavg(n-k)]nk=01n=n×C+∑ Tavg(k) …… ⑵⑵n-1k=02n 当当n>1时，用时，用n-1代替代替⑵⑵中的中的n，得到，得到：：Tavg(n)=(n-1)×C+∑ Tavg(k) …… ⑶⑶n-2k=02n∴∴ nTavg(n)-(n-1)Tavg(n-1)=(2n-1)×C+2Tavg(n-1) ，，即即Tavg(n)=(n+1)/n×Tavg(n-1)+(2n-1)/n×C<(n+1)/n×Tavg(n-1)+2C<(n+1)/n×[n/(n-1)×Tavg(n-2)+2C]+2C数据结构严蔚敏=(n+1)/(n-1)×Tavg(n-2)+2(n+1)[1/n+1/(n+1)]×C< …Tavg(1)+2(n+1)×C[2n+13141+1n+1n1+…++]∴∴ Tavg(n)<只有只有1个记录的排序时间是个记录的排序时间是一个常数一个常数，，∴∴ 快速排序的平均时间复杂度是快速排序的平均时间复杂度是：：T(n)=O(n㏒㏒2n) 从所需要的附加空间来看从所需要的附加空间来看，快速排序算法是递归调，快速排序算法是递归调用，系统内用堆栈保存递归参数，当每次划分比较均匀用，系统内用堆栈保存递归参数，当每次划分比较均匀时，栈的最大深度为时，栈的最大深度为[㏒㏒2n]+1 。

∴∴ 快速排序的空间复杂度是快速排序的空间复杂度是：：S(n)=O(㏒㏒2n) 从排序的稳定性来看，快速排序是从排序的稳定性来看，快速排序是不稳定不稳定的数据结构严蔚敏10. 4 选择排序选择排序 选择排序选择排序(Selection Sort)的基本思想是：每次的基本思想是：每次从当前从当前待排序的记录待排序的记录中选取关键字最小的中选取关键字最小的记录表，然后记录表，然后与与待排序的记录序列待排序的记录序列中的第中的第一个记录进行交换，直到整一个记录进行交换，直到整个记录序列有序为止个记录序列有序为止 数据结构严蔚敏10.4.1 简单选择排序简单选择排序 简单选择排序简单选择排序(Simple Selection Sort ，又称为，又称为直直接选择排序接选择排序)的基本操作是的基本操作是：通过：通过n-i次关键字间的比较，次关键字间的比较，从从n-i+1个记录中选取关键字最小的记录，然后和第个记录中选取关键字最小的记录，然后和第i个记个记录进行交换，录进行交换，i=1, 2, … n-1 1 排序示例排序示例 例例：：设有关键字序列为：设有关键字序列为：7, 4, -2, 19, 13, 6，直接选，直接选择排序的过程如下图择排序的过程如下图10-8所示。

所示数据结构严蔚敏图图10-8 直接选择排序的过程直接选择排序的过程初始记录的关键字：初始记录的关键字： 7 4 -2 19 13 6第一趟排序：第一趟排序：-2 4 7 19 13 6第二趟排序：第二趟排序： -2 4 7 19 13 6第三趟排序：第三趟排序： -2 4 6 19 13 7第四趟排序：第四趟排序： -2 4 6 7 13 19第五趟排序：第五趟排序： -2 4 6 7 13 19第六趟排序：第六趟排序： -2 4 6 7 13 19数据结构严蔚敏2 算法实现算法实现void simple_selection_sort(Sqlist *L){ int m, n , k;for (m=1; mlength; m++){ k=m ; for (n=m+1; n<=L->length; n++) if ( LT(L->R[n].key, L->R[k].key) ) k=n ;if (k!=m) /* 记录交换记录交换 */ { L->R[0]=L->R[m]; L->R[m]=L->R[k]; L->R[k]=L->R[0]; } }}数据结构严蔚敏3 算法分析算法分析 整个算法是二重循环整个算法是二重循环：外循环控制排序的趟数，对：外循环控制排序的趟数，对n个记录进行排序的趟数为个记录进行排序的趟数为n-1趟；内循环控制每一趟的趟；内循环控制每一趟的排序排序。

进行第进行第i趟排序时趟排序时，关键字的比较次数为，关键字的比较次数为n-i，则：，则：比较次数比较次数：：∑ (n-i)=n-1i=1n(n-1)2 ∴∴ 时间复杂度时间复杂度是是：：T(n)=O(n2) 空间复杂度是空间复杂度是：：S(n)=O(1) 从排序的稳定性来看从排序的稳定性来看，，直接选择排序是直接选择排序是不稳定不稳定的数据结构严蔚敏10.4.2 树形选择排序树形选择排序 借助借助““淘汰赛淘汰赛””中的对垒就很容易理解树形选择排中的对垒就很容易理解树形选择排序的思想序的思想 首先对首先对n个记录的关键字两两进行比较个记录的关键字两两进行比较，选取，选取 n/2 个较小者个较小者；然后这；然后这 n/2 个较小者个较小者两两进行比较两两进行比较，选取，选取 n/4 个较小者个较小者… 如此重复，直到只剩如此重复，直到只剩1个关键字为止个关键字为止该过程可用一棵有该过程可用一棵有n个叶子结点的完全二叉树表示个叶子结点的完全二叉树表示，如，如图图10-9所示所示 每个枝结点的关键字都等于其左每个枝结点的关键字都等于其左、、右孩子结点中较右孩子结点中较小的关键字小的关键字，，根结点的关键字就是最小的关键字根结点的关键字就是最小的关键字。

数据结构严蔚敏 输出最小关键字后输出最小关键字后，根据，根据关系的可传递性关系的可传递性，欲选取，欲选取次小关键字，只需将叶子结点中的最小关键字改为次小关键字，只需将叶子结点中的最小关键字改为“最最大值大值” ，然后重复上述步骤即可，然后重复上述步骤即可 含有含有n个叶子结点的完全二叉树的深度为个叶子结点的完全二叉树的深度为 ㏒㏒2n +1，，则总的时间复杂度为则总的时间复杂度为O(n㏒㏒2n) 492525372828196519153415251515图图10-９９ “淘汰赛淘汰赛”过程示意图过程示意图数据结构严蔚敏10.4.3 堆排序堆排序1 堆的定义堆的定义 是是n个元素的序列个元素的序列H={k1, k2 , … kn} ，，满足满足：：ki≤k2i 当当2i≤n时时ki≤k2i+1 当当2i+1≤n时时或或ki≥k2i 当当2i≤n时时ki ≥k2i+1 当当2i+1≤n时时其中其中：： i=1,2 , …,  n/2  由堆的定义知由堆的定义知，堆是一棵以，堆是一棵以k1为根的完全二叉树为根的完全二叉树。

若对该二叉树的结点进行编号若对该二叉树的结点进行编号(从上到下从上到下，，从左到右从左到右)，，得到的序列就是将二叉树的结点以得到的序列就是将二叉树的结点以顺序结构存放顺序结构存放，堆的，堆的结构正好和该序列结构完全一致结构正好和该序列结构完全一致数据结构严蔚敏2 堆的性质堆的性质①① 堆是一棵采用顺序存储结构的完全堆是一棵采用顺序存储结构的完全二叉树二叉树，， k1是是根结点；根结点；②② 堆的根结点是关键字序列中的最小堆的根结点是关键字序列中的最小(或最大或最大)值值，，分别称为小分别称为小(或大或大)根堆；根堆；③③ 从根结点到每一叶子结点路径上的元素组成的序从根结点到每一叶子结点路径上的元素组成的序列都是按元素值列都是按元素值(或关键字值或关键字值)非递减非递减(或非递增或非递增)的；的；④④堆中的任一子树也是堆堆中的任一子树也是堆 利用堆顶记录的关键字值最小利用堆顶记录的关键字值最小(或最大或最大)的性质的性质，从，从当前待排序的记录中当前待排序的记录中依次选取关键字依次选取关键字最小最小(或最大或最大)的记的记录，就可以实现对数据记录的排序，这种排序方法称为录，就可以实现对数据记录的排序，这种排序方法称为堆排序堆排序。

数据结构严蔚敏3 堆排序思想堆排序思想①① 对一组待排序的记录，按堆的定义对一组待排序的记录，按堆的定义建立堆建立堆；；②② 将将堆顶记录和最后一个记录交换堆顶记录和最后一个记录交换位置位置，则前，则前n-1个记录是无序的个记录是无序的，而最后，而最后一个记录是有序的；一个记录是有序的；③③ 堆顶记录堆顶记录被交换后被交换后，前，前n-1个记录不再是堆个记录不再是堆，需，需将前将前n-1个待排序记录重新组织成为一个堆个待排序记录重新组织成为一个堆，然后，然后将将堆顶记录和倒数第二个记录交换堆顶记录和倒数第二个记录交换位置位置，即将整个序，即将整个序列中次小关键字值的记录调整列中次小关键字值的记录调整(排除排除)出无序区；出无序区；④④ 重复上述步骤重复上述步骤，直到全部记录排好序为止，直到全部记录排好序为止 结论结论：：排序过程中，排序过程中，若若采用采用小根堆小根堆，排序后得到的是，排序后得到的是非递减序列非递减序列；若；若采用采用大根堆大根堆，排序后得到的是，排序后得到的是非递增序非递增序列列数据结构严蔚敏堆堆排序的关键排序的关键①① 如何由一个无序序列建成一个堆？如何由一个无序序列建成一个堆？②② 如何在输出堆顶元素之后，调整剩余元素，使之如何在输出堆顶元素之后，调整剩余元素，使之成为一个新的堆？成为一个新的堆？ 4 堆的调整堆的调整——筛选筛选⑴ ⑴ 堆的调整思想堆的调整思想 输出堆顶元素之后，以堆中最后一个元素替代之；输出堆顶元素之后，以堆中最后一个元素替代之；然后将根结点值与左、右子树的根结点值进行比较，并然后将根结点值与左、右子树的根结点值进行比较，并与其中小者进行交换与其中小者进行交换；重复上述操作，直到是叶子结点；重复上述操作，直到是叶子结点或其关键字值小于等于左、右子树的关键字的值，将得或其关键字值小于等于左、右子树的关键字的值，将得到新的堆。

称这个从堆顶至叶子的调整过程为到新的堆称这个从堆顶至叶子的调整过程为“筛选筛选”，如图，如图10-10所示所示数据结构严蔚敏注意注意：：筛选过程中，根结点的左、右子树都是堆，因筛选过程中，根结点的左、右子树都是堆，因此，筛选是从根结点到某个叶子结点的一次调整过程此，筛选是从根结点到某个叶子结点的一次调整过程图图10-10 堆的筛选过程堆的筛选过程49253728196534182715492537281965342718154927372819653425181549253728196534181527数据结构严蔚敏⑵⑵ 堆调整堆调整算法实现算法实现void Heap_adjust(Sqlist *H, int s, int m)/* H->R[s…m]中记录关键字除中记录关键字除H->R[s].key均满足堆定义均满足堆定义 *//* 调整调整H->R[s]的位置使之成为的位置使之成为小根堆小根堆 */{ int j=s, k=2*j ; /* 计算计算H->R[j]的左孩子的位置的左孩子的位置 */H->R[0]=H->R[j] ; /* 临时保存临时保存H->R[j] */ for (k=2*j; k<=m; k=2*k){ if ((kR[k+1].key, H->R[k].key)) k++ ; /* 选择选择左、右孩子中关键字的最小者左、右孩子中关键字的最小者 */if ( LT(H->R[k].key, H->R[0].key) ) { H->R[j]=H->R[k] ; j=k ; k=2*j }else break ;}数据结构严蔚敏H->R[j]=H->R[0] ; }5 堆的建立堆的建立 利用筛选算法，可以将任意无序的记录序列建成一利用筛选算法，可以将任意无序的记录序列建成一个堆，个堆，设设R[1],R[2], …,R[n]是待排序的记录序列。

是待排序的记录序列 将二叉树的将二叉树的每棵子树都筛选成为堆每棵子树都筛选成为堆只有根结点的只有根结点的树是堆树是堆第⌊ ⌊n/2⌋ ⌋个结点之后的所有个结点之后的所有结点都没有子树，即结点都没有子树，即以以第第 n/2 个结点之后的个结点之后的结点为根的子树都是堆结点为根的子树都是堆因此，，以这些结点为以这些结点为左、右孩子的结点，其左、右子树都是堆，左、右孩子的结点，其左、右子树都是堆，则则进行一次筛选进行一次筛选就可以成为堆就可以成为堆同理，只要将这些结点同理，只要将这些结点的直接父结点的直接父结点进行一次筛选进行一次筛选就可以成为堆就可以成为堆… 只需从只需从第第 n/2 个记录到第个记录到第1个记录依次进行筛选就可个记录依次进行筛选就可以建立堆以建立堆数据结构严蔚敏可用下列语句实现可用下列语句实现：：for (j=n/2; j>=1; j--)Heap_adjust(R, j , n) ;6 堆排序算法实现堆排序算法实现 堆的根结点是堆的根结点是关键字最小的记录关键字最小的记录，，输出根结点后输出根结点后，，是以序列的最后一个记录作为根结点，而原来堆的是以序列的最后一个记录作为根结点，而原来堆的左、左、右子树都是堆右子树都是堆，则，则进行一次筛选进行一次筛选就可以成为堆就可以成为堆。

void Heap_Sort(Sqlist *H){ int j ;for (j=H->length/2; j>0; j--)Heap_adjust(H, j , H->length) ; /* 初始建堆初始建堆 */数据结构严蔚敏for (j=H->length/2; j>=1; j--){ H->R[0]=H->R[1] ; H->R[1]=H->R[j] ;H->R[j]=H->R[0] ; /* 堆顶与最后一个交换堆顶与最后一个交换 */Heap_adjust(H, 1, j-1) ; }}7 算法分析算法分析 主要过程：初始建堆和重新调整成堆主要过程：初始建堆和重新调整成堆设记录数为设记录数为n，所对应的完全二叉树深度为，所对应的完全二叉树深度为h ◆◆ 初始建堆初始建堆：每个非叶子结点都要从上到下做：每个非叶子结点都要从上到下做“筛筛选选” 第i层结点数层结点数≤2i-1，结点下移的最大深度是，结点下移的最大深度是h-i，而每下移一层要比较，而每下移一层要比较2次，则比较次数次，则比较次数C1(n)为：为：数据结构严蔚敏C1(n) ≤ 2 ∑ (2i-1×(h-i))≤4(2h-h-1)h-1i=1∵∵ h= ㏒㏒2n +1，， ∴∴ C1(n)≤4(n-㏒㏒2n-1)◆ ◆ 筛选调整筛选调整：每次筛选要将根结点：每次筛选要将根结点“下沉下沉”到到一个一个合适位置合适位置。

第第i次筛选时次筛选时：堆中元素个：堆中元素个数为数为n-i+1；堆；堆的深度是的深度是 ㏒㏒2(n-i+1) +1，则进行，则进行n-1次次“筛选筛选”的比的比较次数较次数C2(n)为为：：C2(n) ≤ ∑ (2×㏒㏒2(n-i+1))n-1i=1∴∴ C2(n)<2n㏒㏒2n∴∴ 堆排序的比较次数的数量级为：堆排序的比较次数的数量级为： T(n)=O(n㏒㏒2n)；而附加空间就是交换时所用的临时空间，故空间复；而附加空间就是交换时所用的临时空间，故空间复杂度为：杂度为： S(n)=O(1) 数据结构严蔚敏10. 5 归并排序归并排序 归并归并(Merging) ：是指将两个或两个以上的有序序：是指将两个或两个以上的有序序列合并成一个有序序列若采用线性表列合并成一个有序序列若采用线性表(无论是那种存储无论是那种存储结构结构)易于实现，其时间复杂度为易于实现，其时间复杂度为O(m+n) 归并思想实例归并思想实例：：两堆扑克牌，都两堆扑克牌，都已从小到大排好已从小到大排好序序，要将两堆合并为一堆且要求，要将两堆合并为一堆且要求从小到大排序从小到大排序。

◆◆ 将两堆最上面的抽出将两堆最上面的抽出(设为设为C1，，C2)比较大小，将比较大小，将小者置于一边作为新的一堆小者置于一边作为新的一堆(不妨设不妨设C1

其核心是如何将相邻的两个子序列归并成一其核心是如何将相邻的两个子序列归并成一个子序列个子序列设相邻的两个子序列分别为相邻的两个子序列分别为：：{R[k], R[k+1], …, R[m]}和和{R[m+1], R[m+2],…, R[h]}，将它们归并为一个有序的子序列，将它们归并为一个有序的子序列：：{DR[l], DR[l+1], …, DR[m], DR[m+1], …, DR[h] }数据结构严蔚敏例：例：设有设有9个待排序的记录个待排序的记录，关键字分别为，关键字分别为23, 38, 22, 45, 23, 67, 31, 15, 41，，归并归并排序的过程如图排序的过程如图10-11所示所示图图10-11 归并排序过程归并排序过程[23] [38] [22] [45] [23] [67] [31] [15] [41]初始关键字初始关键字:[23 38] [22 45] [23 67] [15 31] [41]一趟归并后一趟归并后:[22 23 38 45] [15 23 31 67] [41]二趟归并后二趟归并后:[15 22 23 23 31 38 45 67] [41]三趟归并后三趟归并后:[15 22 23 23 31 38 41 45 67四趟归并后四趟归并后:数据结构严蔚敏归并的算法归并的算法void Merge(RecType R[], RecType DR[], int k, int m, int h){ int p, q, n ; p=n=k, q=m+1 ;while ((p<=m)&&(q<=h)){ if (LQ(R[p].key, R[q].key) ) /* 比较两个子序列比较两个子序列 */ DR[n++]=R[p++] ;else DR[n++]=R[q++] ;}while (p<=m) /* 将剩余子序列复制到结果序列中将剩余子序列复制到结果序列中 */DR[n++]=R[p++] ;while (q<=h) DR[n++]=R[q++] ;}数据结构严蔚敏2 一趟归并排序一趟归并排序 一趟归并排序都是从前到后，依次将相邻的两个有一趟归并排序都是从前到后，依次将相邻的两个有序子序列归并为一个序子序列归并为一个，且除最后一个子序列外，且除最后一个子序列外，其余每，其余每个子序列的长度都相同个子序列的长度都相同。

设这些子序列的长度为设这些子序列的长度为d，则，则一趟归并排序的过程是一趟归并排序的过程是：：从从j=1开始，依次将相邻的两个有序子序列开始，依次将相邻的两个有序子序列R[j…j+d-1]和和R[j+d…j+2d-1]进行归并进行归并；；每次归并两个子序列每次归并两个子序列后，后，j后移动后移动2d个位置，即个位置，即j=j+2d；；若剩下的元素不足若剩下的元素不足两个子序列时，分以下两种情况处理两个子序列时，分以下两种情况处理：：①① 剩下的元素个数剩下的元素个数>d：再调用一次上述过程：再调用一次上述过程，将，将一个长度为一个长度为d的子序列和不足的子序列和不足d的子序列进行归并的子序列进行归并；； ②② 剩下的元素个数剩下的元素个数≤d：：将剩下的元素依次复制到将剩下的元素依次复制到归并后的序列中归并后的序列中数据结构严蔚敏⑴ ⑴ 一趟归并排序算法一趟归并排序算法void Merge_pass(RecType R[], RecType DR[], int d, int n){ int j=1 ;while ((j+2*d-1)<=n){ Merge(R, DR, j, j+d-1, j+2*d-1) ;j=j+2*d ; } /* 子序列两两归并子序列两两归并 */if (j+d-1

算法是算法是：：void Merge_sort(Sqlist *L, RecType DR[]){ int d=1 ;while(dlength){ Merge_pass(L->R, DR, d, L->length) ;Merge_pass(DR, L->R, 2*d, L->length) ;d=4*d ;}}数据结构严蔚敏3 算法分析算法分析 具有具有n个待排序记录的归并次数是㏒个待排序记录的归并次数是㏒2n，而，而一趟归一趟归并的时间复杂度为并的时间复杂度为O(n)，则整个归并排序的，则整个归并排序的时间复杂度时间复杂度无论是最好还是最坏情况均为无论是最好还是最坏情况均为O(n㏒㏒2n)在排序过程中，在排序过程中，使用了辅助向量使用了辅助向量DR，大小与待排序记录空间相同，则空，大小与待排序记录空间相同，则空间复杂度为间复杂度为O(n)归并排序是稳定的归并排序是稳定的数据结构严蔚敏10. 6 基数排序基数排序 基数排序基数排序(Radix Sorting) 又称为又称为桶排序桶排序或或数字数字排序排序：按待排序记录的关键字的组成成分：按待排序记录的关键字的组成成分(或或“位位”)进进行排序行排序。

基数排序基数排序和前面的各种内部排序方法完全不同，和前面的各种内部排序方法完全不同，不不需要进行关键字的比较和记录的移动借助于多关键字需要进行关键字的比较和记录的移动借助于多关键字排序思想实现单逻辑关键字的排序排序思想实现单逻辑关键字的排序数据结构严蔚敏10.6.1 多关键字排序多关键字排序 设有设有n个记录个记录{R1, R2, …,Rn}，， 每个记录每个记录Ri的关键的关键字是由若干项字是由若干项(数据项数据项)组成，即记录组成，即记录Ri的关键字的关键字Key是是若干项的集合：若干项的集合： {Ki1, Ki2, …,Kid}(d>1) 记录记录{R1, R2, …,Rn}有序的，指的是有序的，指的是 i, j∈∈[1,n]，，i

进行排序 最后，将所有的子序列依次联接成一个有序的记录最后，将所有的子序列依次联接成一个有序的记录序列，序列，该方法称为该方法称为最高位优先最高位优先(Most Significant Digit first) 另一种方法正好相反另一种方法正好相反，排序的顺序是从最低位开始，，排序的顺序是从最低位开始，称为称为最低位优先最低位优先(Least Significant Digit first)数据结构严蔚敏10.6.2 链式基数排序链式基数排序 若记录的若记录的关键字由若干关键字由若干确定的确定的部分部分(又称为又称为 “位位”)组成，每一位组成，每一位(部分部分)都有确定数目的取值都有确定数目的取值对这样的记对这样的记录序列排序的有效方法是基数排序录序列排序的有效方法是基数排序 设有设有n个待排序记录个待排序记录{R1, R2, …,Rn}，， (单单)关键字是关键字是由由d位位(部分部分)组成，每位有组成，每位有r种取值，则关键字种取值，则关键字R[i].key可可以看成一个以看成一个d元组：元组： R[i].key={Ki1, Ki2, …,Kid} 。

基数排序可以采用前面介绍的基数排序可以采用前面介绍的MSD或或LSD方法方法以下以下以LSD方法讨论链式基数排序方法讨论链式基数排序数据结构严蔚敏1 排序思想排序思想⑴⑴ 首先以静态链表存储首先以静态链表存储n个待排序记录，头结点指针个待排序记录，头结点指针指向第一个记录结点指向第一个记录结点；； ⑵⑵ 一趟排序的过程是：一趟排序的过程是：①① 分配分配：： 按按Kd值的升序顺序，改变记录指针，值的升序顺序，改变记录指针，将链表中的记录结点分配到将链表中的记录结点分配到r个链表个链表(桶桶)中，每个链中，每个链表中所有记录的关键字的最低位表中所有记录的关键字的最低位(Kd)的值都相等的值都相等，，用用f[i]、、e[i]作为第作为第i个链表的头结点和尾结点个链表的头结点和尾结点；；②② 收集收集：：改变所有非空链表的尾结点指针，使改变所有非空链表的尾结点指针，使其指向下一个非空连表的第一个结点，从而将其指向下一个非空连表的第一个结点，从而将r个个链表中的记录重新链接成一个链表链表中的记录重新链接成一个链表；；⑶⑶ 如此依次按如此依次按Kd-1, Kd-2, … K1分别进行，共进行分别进行，共进行d趟趟排序后排序完成排序后排序完成。

数据结构严蔚敏2 排序示例排序示例 设有关键字序列为设有关键字序列为1039, 2121, 3355, 4382, 66, 118的的一组记录，采用链式基数排序的过程如下图一组记录，采用链式基数排序的过程如下图10-12所示所示103921213355438200660118 ∧∧head初始链表初始链表f[1]f[0]f[2]f[4]f[3]f[5]f[7]f[6]f[8]f[9]e[1]e[0]e[2]e[4]e[3]e[5]e[7]e[6]e[8]e[9]2121 43823355 006601181039分配分配：：212143823355006601181039 ∧∧head第一趟收集结果第一趟收集结果：：数据结构严蔚敏0118 2121f[1]f[0]f[2]f[4]f[3]f[5]f[7]f[6]f[8]f[9]e[1]e[0]e[2]e[4]e[3]e[5]e[7]e[6]e[8]e[9]3355 006643821039分配分配：：011821211039335500664382 ∧∧head第二趟收集结果第二趟收集结果：：103900660118212133554382∧∧head第三趟收集结果第三趟收集结果：：01182121f[1]f[0]f[2]f[4]f[3]f[5]f[7]f[6]f[8]f[9]e[1]e[0]e[2]e[4]e[3]e[5]e[7]e[6]e[8]e[9]分配分配：：3355438210390066数据结构严蔚敏006601181039212133554382∧∧head第四趟收集结果第四趟收集结果：：1039f[1]f[0]f[2]f[4]f[3]f[5]f[7]f[6]f[8]f[9]e[1]e[0]e[2]e[4]e[3]e[5]e[7]e[6]e[8]e[9]分配分配：：006601182121 3355 4382图图10-12 以以LSD方法进行链式基数排序的过程方法进行链式基数排序的过程数据结构严蔚敏3 链式基数排序算法链式基数排序算法 为实现基数排序，用两个指针数组来分别管理所有为实现基数排序，用两个指针数组来分别管理所有的缓存的缓存(桶桶)，同时对待排序记录的数据类型进行改造，，同时对待排序记录的数据类型进行改造，相应的数据类型定义如下：相应的数据类型定义如下：#define BIT_key 8 /* 指定关键字的位数指定关键字的位数d */#define RADIX 10 /* 指定关键字基数指定关键字基数r */typedef struct RecType{ char key[BIT_key] ; /* 关键字域关键字域 */infoType otheritems ;struct RecType *next ;}SRecord, *f[RADIX] ,*e[RADIX] ;/* 桶的头尾指针数组桶的头尾指针数组 */数据结构严蔚敏void Radix_sort(SRecord *head ){ int j, k, m ;SRecord *p, *q, *f[RADIX], *e[RADIX] ; for (j=BIT_key-1; j>=0; j--) /* 关键字的每位一趟排序关键字的每位一趟排序 */{ for (k=0; kkey[j]) ; /* 取关键字的第取关键字的第j位位kj */ if (f[m]==NULL) f[m]=p ; else e[m]->next=p ; p=p->next ;数据结构严蔚敏 }head=NULL ; /* 以以head作为头指针进行收集作为头指针进行收集 */ q=head ; /* q作为收集后的尾指针作为收集后的尾指针 */for (k=0; knext=f[k] ; else head=f[k] ; q=e[k] ; } } /* 完成一趟排序的收集完成一趟排序的收集 */q->next=NULL ; /* 修改收集链尾指针修改收集链尾指针 */}}数据结构严蔚敏4 算法分析算法分析 设有设有n个待排序记录个待排序记录，关键字位数为，关键字位数为d，，每位有每位有r种种取值。

取值则排序的趟数是则排序的趟数是d；；在每在每一趟中：一趟中：◆◆ 链表初始化的时间复杂度：链表初始化的时间复杂度：O(r) ；； ◆◆ 分配的时间复杂度：分配的时间复杂度：O(n) ；； ◆◆ 分配后收集的时间复杂度：分配后收集的时间复杂度：O(r) ；； 则链式基数排序的则链式基数排序的时间复杂度为：时间复杂度为： O(d(n+r)) 在排序过程中使用的辅助空间是在排序过程中使用的辅助空间是：：2r个链表指针个链表指针，， n个指针域个指针域空间，则空空间，则空间复杂度为：间复杂度为：O(n+r) 基数排序是稳定的基数排序是稳定的数据结构严蔚敏10. 7 各种内部排序的比较各种内部排序的比较 各种内部排序按所采用的基本思想各种内部排序按所采用的基本思想(策略策略)可分为：可分为：插入排序插入排序、、交换交换排序排序、、选择选择排序排序、、归并归并排序排序和和基基数数排序排序，它们的基本策略分别是：，它们的基本策略分别是：1 插入排序插入排序：：依次将无序序列中的一个依次将无序序列中的一个记录记录，按关，按关键字值的大小插入到已键字值的大小插入到已排好序排好序一个子序列的适当位置，一个子序列的适当位置，直到所有的记录都插入为止直到所有的记录都插入为止。

具体的方法有具体的方法有：直接插入：直接插入、、表表插入插入、、2-路路插入和插入和shell排序排序2 交换交换排序排序：：对于待排序记录序列中的记录，两两对于待排序记录序列中的记录，两两比较记录的关键字比较记录的关键字，并对反序的两个记录进行交换，直，并对反序的两个记录进行交换，直到整个序列中没有反序的记录偶对为止到整个序列中没有反序的记录偶对为止具体的方法有具体的方法有：：冒泡排序冒泡排序、快速、快速排序排序数据结构严蔚敏3 选择选择排序排序：：不断地从不断地从待排序的记录序列待排序的记录序列中选取关中选取关键字最小的键字最小的记录，放在已记录，放在已排好序的序列排好序的序列的最后的最后，直到所，直到所有记录都被选取为止有记录都被选取为止具体的方法有具体的方法有：简单选择排序：简单选择排序、、堆堆排序排序4 归并归并排序排序：：利用利用“归并归并”技术不断地对待排序记技术不断地对待排序记录序列中的有序子序列进行合并，直到合并为一个有序录序列中的有序子序列进行合并，直到合并为一个有序序列为止序列为止5 基数排序基数排序：：按待排序记录的关键字的组成成分按待排序记录的关键字的组成成分(“位位”)从低到高从低到高(或从高到低或从高到低)进行进行。

每次是按记录关键字每次是按记录关键字某一某一““位位””的值将所有记录分配到相应的的值将所有记录分配到相应的桶中，再按桶桶中，再按桶的编号依次将记录进行收集，最后得到一个有序序列的编号依次将记录进行收集，最后得到一个有序序列 各种内部排序方法的性能比较如下表各种内部排序方法的性能比较如下表数据结构严蔚敏方法方法平均时间平均时间最坏所需时间最坏所需时间附加空间附加空间稳定性稳定性直接插入直接插入O(n2)O(n2)O(1)稳定的稳定的Shell排序排序O(n1.3)O(1)不稳定的不稳定的直接选择直接选择O(n2)O(n2)O(1)不稳定的不稳定的堆排序堆排序O(n㏒㏒2n)O(n㏒㏒2n)O(1)不稳定的不稳定的冒泡排序冒泡排序O(n2)O(n2)O(1)稳定的稳定的快速排序快速排序O(n㏒㏒2n)O(n2)O(㏒㏒2n)不稳定的不稳定的归并排序归并排序O(n㏒㏒2n)O(n㏒㏒2n)O(n)稳定的稳定的基数排序基数排序O(d(n+r))O(d(n+r))O(n+r)稳定的稳定的表表7-1 主要内部排序方法的性能主要内部排序方法的性能数据结构严蔚敏 讲稿中讨论的排序方法是在顺序存储结构上实现的讲稿中讨论的排序方法是在顺序存储结构上实现的，，在排序过程中需要移动大量记录。

当记录数很多、在排序过程中需要移动大量记录当记录数很多、时间时间耗费很大耗费很大时时，可以采用静态链表作为存储结构，可以采用静态链表作为存储结构但有些排序方法排序方法，若采用静态链表作存储结构，则无法实现表，若采用静态链表作存储结构，则无法实现表排序排序选取排序方法的主要考虑因素：选取排序方法的主要考虑因素：◆◆ 待排序的记录数目待排序的记录数目n；；◆◆ 每个记录的大小；每个记录的大小；◆◆ 关键字的结构及其初始状态；关键字的结构及其初始状态；◆◆ 是否要求排序的稳定性；是否要求排序的稳定性；◆◆ 语言工具的特性；语言工具的特性；◆◆ 存储结构的初始条件和要求；存储结构的初始条件和要求； ◆◆ 时间复杂度时间复杂度、、空间复杂度和开发工作的复杂程度空间复杂度和开发工作的复杂程度的平衡点等的平衡点等数据结构严蔚敏习习 题题 十十⑴⑴ 回答下列各题：回答下列各题：①① 从未排序序列中挑选元素，并将其依次放入到从未排序序列中挑选元素，并将其依次放入到已排序序列中已排序序列中(初始时为空初始时为空)的一端的方法是什么？的一端的方法是什么？②② 在待排序的元素基本有序的前提下，效率最高在待排序的元素基本有序的前提下，效率最高的排序方法是什么的排序方法是什么?③③ 从未排序序列中依次取出元素与已排序序列从未排序序列中依次取出元素与已排序序列 (初初始时为空始时为空)中的元素进行比较，将其放入已排序序中的元素进行比较，将其放入已排序序列的正确位置方法是什么？列的正确位置方法是什么？④④ 设有设有1000个元素，个元素， 希望采用最快的速度挑选出希望采用最快的速度挑选出其中前其中前10个最大的元素，个最大的元素， 最好的方法是什么最好的方法是什么?数据结构严蔚敏⑵ ⑵ 若对关键字序列为若对关键字序列为(54, 37, 93, 25, 17, 68, 58, 41, 76)的的一组记录进行快速排序时，递归调用使用的栈所能到一组记录进行快速排序时，递归调用使用的栈所能到达的最大深度是多少达的最大深度是多少? ?共需递归调用多少次共需递归调用多少次? ?其中第二次其中第二次递归调用是对哪组记录进行排序递归调用是对哪组记录进行排序? ?⑶ ⑶ 在堆排序，快速排序和归并排序中，若只从存储在堆排序，快速排序和归并排序中，若只从存储空间考虑，应选择哪种方法；若只从排序结果的稳定性空间考虑，应选择哪种方法；若只从排序结果的稳定性考虑，应选择哪种方法；若只从平均情况下排序最快考考虑，应选择哪种方法；若只从平均情况下排序最快考虑，应选择哪种方法；虑，应选择哪种方法；⑷ ⑷ 设有关键字序列为设有关键字序列为(14, 17, 53, 35, 9, 32, 68, 41, 76, 23)的的一组记录，请给出用希尔排序法一组记录，请给出用希尔排序法(增量序列是增量序列是5, 3, 1)排序时的每一躺结果。

排序时的每一躺结果⑸ ⑸ 设有关键字序列为设有关键字序列为(14, 17, 53, 35, 9, 37, 68, 21, 46)的的一组记录，请给出冒泡排序法排序时的每一躺结果一组记录，请给出冒泡排序法排序时的每一躺结果数据结构严蔚敏⑹ ⑹ 设有关键字序列为设有关键字序列为(14, 17, 53, 35, 9, 37, 68, 21, 46)的的一组记录，利用快速排序法进行排序时，请给出以第一组记录，利用快速排序法进行排序时，请给出以第一个记录为基准得到的一次划分结果一个记录为基准得到的一次划分结果⑺ ⑺ 设关键字序列为设关键字序列为(14, 17, 53, 35, 9, 37, 68, 21)的的一组一组记录，请给出按非递增采用堆排序时的每一躺结果记录，请给出按非递增采用堆排序时的每一躺结果⑻ ⑻ 设关键字序列为设关键字序列为(314, 617, 253, 335, 19, 237, 464, 121, 46, 231, 176, 344)的的一组记录，请给出采用基数排一组记录，请给出采用基数排序时的每一躺结果序时的每一躺结果⑼ ⑼ 将哨兵放在将哨兵放在R[n]中，被排序的记录存放在中，被排序的记录存放在R[1…n-1]中中，重写直接插入排序算法。

重写直接插入排序算法⑽ ⑽ 实际中常采用单链表存储数据记录，请写出排序实际中常采用单链表存储数据记录，请写出排序记录的结构的定义并修改记录的结构的定义并修改数据结构严蔚敏第第11章章 文件与外部排序文件与外部排序 在许多实际应用中，特别是数据处理时，都需要在许多实际应用中，特别是数据处理时，都需要长期存储海量数据，这些数据通常以长期存储海量数据，这些数据通常以文件文件的方式组织并的方式组织并存储在外存如何有效地管理这些数据，从而给使用者存储在外存如何有效地管理这些数据，从而给使用者提供方便而高效的使用数据的方法称为提供方便而高效的使用数据的方法称为文件管理文件管理 在实际存取这些海量数据时，为了方便使用，往往在实际存取这些海量数据时，为了方便使用，往往以某种顺序排序后再存储在外存上，这种排序称为以某种顺序排序后再存储在外存上，这种排序称为外部外部排序排序在排序时由于一次不能将数据文件中的所有数据在排序时由于一次不能将数据文件中的所有数据同时装入内存中进行，因此就必须研究如何对外存上的同时装入内存中进行，因此就必须研究如何对外存上的数据进行排序的技术。

数据进行排序的技术数据结构严蔚敏11.1 文件的基本概念文件的基本概念1 文件的基本概念文件的基本概念⑴⑴ 数据项数据项(Item或或field) ：数据文件中最小的基本：数据文件中最小的基本单位单位，反映实体某一方面的特征，反映实体某一方面的特征—属性的数据表示属性的数据表示⑵⑵ 记录记录(Record) ：一个实体的所有数据项的集合一个实体的所有数据项的集合 用来标识一个记录的数据项集合用来标识一个记录的数据项集合(一个或多个一个或多个)称为关键称为关键字项字项(Key) ，关键字项的值称为关键字，关键字项的值称为关键字；；能唯一标识一能唯一标识一个记录的关键字称为个记录的关键字称为主关键字主关键字(Primary Key)，其它的关，其它的关键字称为键字称为次关键字次关键字(Secondary Key) 通常的记录指的是通常的记录指的是逻辑记录逻辑记录，是从用户角度所看到，是从用户角度所看到的对数据的表示和存取的方式的对数据的表示和存取的方式数据结构严蔚敏 文件存储在外存上文件存储在外存上，通常是以块，通常是以块(I/O读写的基本单读写的基本单位，称为位，称为物理记录物理记录)存取。

存取 物理记录和逻辑记录之间的关系是物理记录和逻辑记录之间的关系是：： ①① 一个物理记录存放一个逻辑记录一个物理记录存放一个逻辑记录；； ②② 一个物理记录包含多个逻辑记录一个物理记录包含多个逻辑记录；； ③③ 多个物理记录存放一个逻辑记录多个物理记录存放一个逻辑记录 ⑶⑶ 文件文件(File)：大量性质相同的数据记录的集合文：大量性质相同的数据记录的集合文件的所有记录是按某种排列顺序呈现在用户面前件的所有记录是按某种排列顺序呈现在用户面前，这种，这种排列顺序可以是按记录的关键字，也可以是按记录进入排列顺序可以是按记录的关键字，也可以是按记录进入文件的先后等文件的先后等则记录之间形成一种线性结构则记录之间形成一种线性结构(逻辑上的逻辑上的)，称为文件的，称为文件的逻辑结构逻辑结构；文件在外存上的组织方式称为；文件在外存上的组织方式称为文件的文件的物理结构物理结构基本的物理结构有基本的物理结构有：顺序结构：顺序结构，链接，链接结构，索引结构结构，索引结构 数据结构严蔚敏⑷⑷ 文件的分类文件的分类⑴⑴ 按记录类型，可分为操作系统文件和数据库文件按记录类型，可分为操作系统文件和数据库文件：： ①① 操作系统文件操作系统文件(流式文件流式文件) ：： 连续的字符序列连续的字符序列(串串)的集合的集合；；②② 数据库文件数据库文件：： 有特定结构有特定结构(所有记录的结构都相所有记录的结构都相同同)的数据记录的集合的数据记录的集合。

⑵⑵ 按记录长度，可分为定长记录文件和不定长记录按记录长度，可分为定长记录文件和不定长记录文件文件：： ①① 定长记录文件定长记录文件：文件中每个记录都有固定的数：文件中每个记录都有固定的数据项组成据项组成，每个数据项的长度都是固定的，每个数据项的长度都是固定的；；②② 不定长记录文件不定长记录文件：与：与定长记录文件相反定长记录文件相反数据结构严蔚敏2 文件的有关操作文件的有关操作 文件是由大量记录组成的线性表文件是由大量记录组成的线性表，因此，对文件的，因此，对文件的操作主要是针对记录的，通常有操作主要是针对记录的，通常有：记录的检索：记录的检索、插入、、插入、删除、修改和排序，其中检索是最基本的操作删除、修改和排序，其中检索是最基本的操作⑴⑴ 检索记录检索记录 根据用户的要求从文件中查找相应的记录根据用户的要求从文件中查找相应的记录①① 查找下一个记录查找下一个记录：找当前记录的下一个逻辑记录：找当前记录的下一个逻辑记录；；②② 查找第查找第k个记录个记录：给出记录的逻辑序号，根据该序：给出记录的逻辑序号，根据该序号查找相应的记录号查找相应的记录；；③③ 按关键字查找按关键字查找：给出指定的关键字值，查找关键字：给出指定的关键字值，查找关键字值相同或满足条件的记录。

对数据库文件，有以下四值相同或满足条件的记录对数据库文件，有以下四种按关键字查找的方式：种按关键字查找的方式：数据结构严蔚敏◆◆ 简单匹配简单匹配：查找关键字的值与给定的值相等的：查找关键字的值与给定的值相等的记录记录；；◆◆ 区域匹配区域匹配：查找关键字的值在某个区域范围内：查找关键字的值在某个区域范围内的记录的记录；；◆◆ 函数匹配函数匹配：给出关键字的某个函数：给出关键字的某个函数，，查找符合查找符合条件的记录条件的记录；；◆◆ 组合条件匹配组合条件匹配：给出用布尔表达式表示的多个：给出用布尔表达式表示的多个条件组合条件组合，，查找符合条件的记录查找符合条件的记录⑵⑵ 插入记录插入记录 将给定的记录插入到文件的指定位置插入是首先将给定的记录插入到文件的指定位置插入是首先要确定插入点的位置要确定插入点的位置(检索记录检索记录)，然后才能插入，然后才能插入数据结构严蔚敏⑶⑶ 删除记录删除记录 从文件中删除给定的记录记录的删除有两种情况：从文件中删除给定的记录记录的删除有两种情况：① ① 在文件中删除第在文件中删除第k个记录个记录；；② ② 在文件中删除符合条件的记录。

在文件中删除符合条件的记录⑷⑷ 修改记录修改记录 对符合条件的记录对符合条件的记录，更改某些属性值，更改某些属性值修改时首先修改时首先要要检索到所要修改的记录，然后才能修改检索到所要修改的记录，然后才能修改⑸ ⑸ 记录排序记录排序 根据指定的关键字根据指定的关键字，对文件中的记录按关键字值的，对文件中的记录按关键字值的大小以非递减或非递增的方式重新排列大小以非递减或非递增的方式重新排列(或存储或存储)数据结构严蔚敏11.2 文件的组织方式文件的组织方式 文件的组织方式文件的组织方式指的是文件的物理结构指的是文件的物理结构11.2.1 顺序文件顺序文件 记录记录按按其在文件中的其在文件中的逻辑顺序逻辑顺序依次进入存储介质依次进入存储介质在顺序文件中在顺序文件中，记录的逻辑顺序和存储顺序是一致的，记录的逻辑顺序和存储顺序是一致的⑴ ⑴ 根据根据记录是否按关键字排序记录是否按关键字排序：可分为排序顺序文：可分为排序顺序文件和一般顺序文件件和一般顺序文件；；⑵ ⑵ 根据根据逻辑上相邻逻辑上相邻的记录的的记录的物理位置物理位置关系：可分为关系：可分为连续顺序文件和链接顺序文件。

连续顺序文件和链接顺序文件 顺序文件类似于线性表的顺序存储结构顺序文件类似于线性表的顺序存储结构，比较简单，，比较简单，适合于顺序存取的外存介质，但不适合随机处理适合于顺序存取的外存介质，但不适合随机处理数据结构严蔚敏11.2.2 索引文件索引文件 索引技术是组织大型数据库的一种重要技术，索引技术是组织大型数据库的一种重要技术，索引索引是记录和记录存储地址之间的对照表是记录和记录存储地址之间的对照表索引结构索引结构(称为称为索引文件索引文件)由由索引表索引表和和数据表数据表两部分，如图两部分，如图11-1所示所示◆◆ 数据表数据表：存储实际的数据记录；：存储实际的数据记录；◆◆ 索引表索引表：存储记录的：存储记录的关键字关键字和和记录记录(存储存储)地址地址之间之间的对照表的对照表，，每个元素称为一个每个元素称为一个索引项索引项 如果数据文件中的每一个记录都有一个索引项如果数据文件中的每一个记录都有一个索引项，这，这种索引称为种索引称为稠密索引稠密索引，否则，称为，否则，称为非稠密索引非稠密索引 对于非稠密索引，通常将文件记录划分为若干块，对于非稠密索引，通常将文件记录划分为若干块，块内块内记录可以记录可以无序无序，但，但块间块间必须必须有序有序。

若块内记录是有若块内记录是有序的序的，称为索引顺序文件，否则称为索引非顺序文件，称为索引顺序文件，否则称为索引非顺序文件对于对于索引非顺序文件，只需对每一块建立一个索引项索引非顺序文件，只需对每一块建立一个索引项数据结构严蔚敏图图11-1 索引结构的基本形式索引结构的基本形式 索引表索引表数据表数据表关键字关键字 指针指针 263 275 386 … … 1046 593 681 386 1046 681 … … 593 263 275关键字关键字 其他域其他域(a) 稠密索引文件稠密索引文件索引表索引表数据表数据表(b) 非稠密索引文件非稠密索引文件 263 386 681关键字关键字 指针指针 … … 386 681 … … 263 275关键字关键字 其他域其他域数据结构严蔚敏 对于对于稠密索引稠密索引，可以根据，可以根据索引项直接查找到记录的索引项直接查找到记录的位置位置若在索引表中若在索引表中采用顺序查找采用顺序查找，查找，查找时间复杂度为时间复杂度为O(n) ；若；若采用折半查找采用折半查找，查找，查找时间复杂度为时间复杂度为O(㏒㏒2n) 。

对于稠密索引对于稠密索引，索引项，索引项数目与数据表中记录数相同数目与数据表中记录数相同，，当索引表很大时，检索记录需多次访问外存当索引表很大时，检索记录需多次访问外存 对于对于非稠密索引非稠密索引，查找的基本思想是：，查找的基本思想是： 首先根据索引找到记录所在块，再将该块读入到内首先根据索引找到记录所在块，再将该块读入到内存，然后再在块内顺序查找存，然后再在块内顺序查找 平均查找长度由两部分组成：块地址的平均查找长平均查找长度由两部分组成：块地址的平均查找长度度Lb，块内记录的平均查找长度，块内记录的平均查找长度Lw，即，即ASLbs=Lb+Lw 若将长度为若将长度为n的文件分为的文件分为b块，每块内有块，每块内有s个记录，则个记录，则b=n/s 设每块的查找概率为设每块的查找概率为1/b，块内每个的记录查找，块内每个的记录查找概率为概率为1/b，则采用顺序查找方法时有：，则采用顺序查找方法时有：数据结构严蔚敏ASLbs=Lb+Lw=(b+1)/2+(s+1)/2=(n/s+s)+1显然，当显然，当s=n1/2时时，，ASLbs的值达到最小的值达到最小；； 若在索引表中采用折半查找方法时有：若在索引表中采用折半查找方法时有：ASLbs=Lb+Lw= ㏒㏒2(n/s+1)+s/2 如果文件中记录数很庞大，对非稠密索引而言，索如果文件中记录数很庞大，对非稠密索引而言，索引也很大，可以将索引表再分块，建立引也很大，可以将索引表再分块，建立索引的索引索引的索引，形，形成树形结构的多级索引，如后面将要介绍的成树形结构的多级索引，如后面将要介绍的ISAM文件文件和和VSAM文件。

文件数据结构严蔚敏11.2.3 ISAM文件文件 ISAM(Indexed Sequential Access Method，，顺序索顺序索引存取方法引存取方法)，是专为磁盘存取设计的一种文件组织方，是专为磁盘存取设计的一种文件组织方式，采用静态索引结构，是一种三级索引结构的顺序文式，采用静态索引结构，是一种三级索引结构的顺序文件件图11-2是一个磁盘组的结构图是一个磁盘组的结构图……磁道磁道扇区扇区…柱面柱面图图11-2 一个磁盘组结构形式一个磁盘组结构形式盘面盘面 ISAM文件文件由由基本文基本文件件、、磁道索引磁道索引、、柱面索引柱面索引和和主索引主索引组成组成 基本文件基本文件按关键字的按关键字的值顺序存放值顺序存放，首先集中存，首先集中存放在同一柱面上，然后再放在同一柱面上，然后再顺序存放在相邻柱面上顺序存放在相邻柱面上；；对于对于同一柱面，则按盘面同一柱面，则按盘面的次序顺序存放的次序顺序存放数据结构严蔚敏 在每个柱面上，还开辟了一个溢出区，存放从该柱在每个柱面上，还开辟了一个溢出区，存放从该柱面的磁道上溢出的记录面的磁道上溢出的记录。

同一同一磁道上溢出的记录通常由磁道上溢出的记录通常由指针相链接指针相链接 ISAM文件为每个磁道建立一个索引项，相同柱面文件为每个磁道建立一个索引项，相同柱面的磁道索引项组成一个索引表，称为的磁道索引项组成一个索引表，称为磁道索引磁道索引，由基本，由基本索引项和溢出索引项组成，其结构是索引项和溢出索引项组成，其结构是：： ◆◆ 基本索引项基本索引项：：关键字域存放该磁道上的最大关键关键字域存放该磁道上的最大关键字字；指针域；指针域存放该磁道的首地址存放该磁道的首地址 关键字关键字 指针指针 关键字关键字 指针指针基本索引项基本索引项溢出索引项溢出索引项数据结构严蔚敏◆◆ 溢出索引项溢出索引项：是为插入记录设置的关键字域存：是为插入记录设置的关键字域存放该磁道上放该磁道上溢出溢出的记录的最大关键字；指针域存放的记录的最大关键字；指针域存放溢溢出出记录链表的头指针记录链表的头指针 在磁道索引的基础上，又为文件所占用的柱面建立在磁道索引的基础上，又为文件所占用的柱面建立一个一个柱面索引柱面索引，其结构是，其结构是：：关键字关键字 指针指针 关键字域存放该柱面上的最大关键字关键字域存放该柱面上的最大关键字；指针域指向；指针域指向该柱面的第该柱面的第1个磁道索引项个磁道索引项。

当柱面索引很大时，柱面索引本身占用很多磁道，当柱面索引很大时，柱面索引本身占用很多磁道，又可为柱面索引建立一个又可为柱面索引建立一个主索引主索引则ISAM文件的三级文件的三级索引结构如图索引结构如图11-3所示所示数据结构严蔚敏磁道索引磁道索引柱面索引柱面索引R7 R13 R23 … R76 ┇ ┇ ┇ ┇R31基本区基本区溢出区溢出区柱面柱面C1 … R2340 … R3760 ┇ ┇ ┇ ┇溢出区溢出区柱面柱面Cn23 3076┇ ┇ ┇ ┇23403760┇ ┇ ┇ ┇┇ ┇76136┇ ┇348┇ ┇768┇ ┇3760主索引主索引348768┇ ┇3760图图11-3 ISAM文件结构示意图文件结构示意图数据结构严蔚敏1 ISAM文件的检索文件的检索 根据关键字查找时，首先从主索引中查找记录所根据关键字查找时，首先从主索引中查找记录所在的柱面索引块的位置；再从柱面索引块中查找磁道索在的柱面索引块的位置；再从柱面索引块中查找磁道索引块的位置；然后再从磁道索引块中查找出该记录所在引块的位置；然后再从磁道索引块中查找出该记录所在的磁道位置；最后从磁道中顺序查找要检索的记录。

的磁道位置；最后从磁道中顺序查找要检索的记录2 记录的插入记录的插入 首先根据待插入记录的关键字查找到相应位置首先根据待插入记录的关键字查找到相应位置；；然然后将该磁道中后将该磁道中插入位置及以后的记录后移插入位置及以后的记录后移一个位置一个位置(若若溢出，将该磁道中最后一个记录存入同一柱面的溢出区，溢出，将该磁道中最后一个记录存入同一柱面的溢出区，并修改磁道索引并修改磁道索引) ；最后将记录插入到相应位置最后将记录插入到相应位置数据结构严蔚敏3 记录的删除记录的删除 只需找到要删除的记录，对其只需找到要删除的记录，对其做删除标记做删除标记，不移动，不移动记录记录当经过多次插入和删除操作后当经过多次插入和删除操作后，基本区有大量被，基本区有大量被删除的记录，而溢出区也可能有大量记录，则周期性地删除的记录，而溢出区也可能有大量记录，则周期性地整理整理ISAM文件，形成一个新的文件，形成一个新的ISAM文件文件4 ISAM文件的特点文件的特点◆◆ 优点优点：节省存储空间：节省存储空间，查找速度快，查找速度快；；◆◆ 缺点缺点：处理删除记录复杂：处理删除记录复杂，多次删除后，多次删除后存储空间的存储空间的利用率和存取效率降低利用率和存取效率降低，需定期整理，需定期整理ISAM文件文件。

数据结构严蔚敏11.2.4 VSAM文件文件 VSAM(Virtual Storage Access Method，虚拟存取，虚拟存取方法方法)，也是一种索引顺序文件组织方式，利用，也是一种索引顺序文件组织方式，利用OS的虚的虚拟存储器功能，采用的是基于拟存储器功能，采用的是基于B+树的动态索引结构树的动态索引结构 文件文件的存取不是以柱面、磁道等物理空间为存取单的存取不是以柱面、磁道等物理空间为存取单位，而是以逻辑空间位，而是以逻辑空间——控制区间控制区间(Control Interval)和和控制区域控制区域(Control Range)为存取单位为存取单位 一个一个VSAM文件由文件由索引集索引集、、顺序集顺序集和和数据集数据集组成，组成，如图如图11-4所示所示 文件的文件的记录都存放在数据集中记录都存放在数据集中，数据集又分成多个，数据集又分成多个控制区间控制区间；；VSAM进行进行I/O操作的基本单位是控制区间操作的基本单位是控制区间，，由一组连续的存储单元组成，同一文件的控制区间大小由一组连续的存储单元组成，同一文件的控制区间大小相同相同；；数据结构严蔚敏 每个控制区间存放一个或多个逻辑记录，记录是按每个控制区间存放一个或多个逻辑记录，记录是按关键字值顺序存放在控制区间的前端，尾端存放记录的关键字值顺序存放在控制区间的前端，尾端存放记录的控制信息和控制区间的控制信息，如图控制信息和控制区间的控制信息，如图11-5所示所示。

控制区间控制区间 69 124 246 22 38 69 198 246…… 12 20 24 31 38……6812141720 212 228 246……203208212213218228233238246┇ ┇┇ ┇┇ ┇控制区域控制区域索索引引集集顺序集顺序集B+树树图图11-4 VSAM文件结构示意图文件结构示意图数据集数据集数据结构严蔚敏 顺序集顺序集是由是由B+树索引结构的叶子结点组成每个结树索引结构的叶子结点组成每个结点存放若干个相邻控制区间的索引项，每个索引项存放点存放若干个相邻控制区间的索引项，每个索引项存放一个控制区间中记录的最大关键字值和指向该控制区间一个控制区间中记录的最大关键字值和指向该控制区间的指针顺序集中的每个结点及与它所对应的全部控制的指针顺序集中的每个结点及与它所对应的全部控制区间组成一个区间组成一个控制区域控制区域 顺序集中的结点之间按顺序顺序集中的结点之间按顺序链接链接成一个链表，每个成一个链表，每个结点又在其上层建立索引，并逐层向上按结点又在其上层建立索引，并逐层向上按B+树的形式建树的形式建立多级索引立多级索引。

则则顺序集中的每一个结点就是顺序集中的每一个结点就是B+树的叶子树的叶子结点结点；在顺序集之上的索引部分称为；在顺序集之上的索引部分称为索引集索引集 在在VSAM文件上既可以按文件上既可以按B+树的方式实现记录的查树的方式实现记录的查找，又可以利用顺序集索引实现记录顺序查找找，又可以利用顺序集索引实现记录顺序查找未用的未用的自由空间自由空间Rn的的控制信息控制信息…R1的的控制信息控制信息控制区间的控制区间的控制信息控制信息R1 R2 … Rn图图11-5 控制区间的结构控制区间的结构数据结构严蔚敏 VSAM文件中没有溢出区，解决方法是留出空间文件中没有溢出区，解决方法是留出空间：：◆◆ 每个控制区间中留出空间每个控制区间中留出空间；； ◆◆ 每个控制区域留出空的控制空间，并在顺序集的每个控制区域留出空的控制空间，并在顺序集的索引中指出索引中指出1 记录的插入记录的插入 首先根据待插入记录的关键字查找到相应的位置：首先根据待插入记录的关键字查找到相应的位置：◆◆ 若若该控制区间有可用空间该控制区间有可用空间：将关键字：将关键字大于待插入大于待插入记录的关键字的记录全部后移记录的关键字的记录全部后移一个位置，在空出的一个位置，在空出的位置存放待插入记录；位置存放待插入记录；◆◆ 若若控制区间没有可用空间控制区间没有可用空间：利用同一控制区域的：利用同一控制区域的一个空白控制空间进行区间分裂，将近一半记录移一个空白控制空间进行区间分裂，将近一半记录移到新的控制区间中，并修改顺序集中相应的索引，到新的控制区间中，并修改顺序集中相应的索引，插入新的记录；插入新的记录；数据结构严蔚敏◆◆ 若若控制区域中没有空白控制空间控制区域中没有空白控制空间：则开辟一个新的：则开辟一个新的控制区域，进行控制区间域分裂和相应的顺序集中的控制区域，进行控制区间域分裂和相应的顺序集中的结点分裂结点分裂。

也可按也可按B+树的分裂方法进行树的分裂方法进行2 记录的删除记录的删除 先找到要删除的记录，然后将同一控制区间中比删先找到要删除的记录，然后将同一控制区间中比删除记录关键字大的所有记录逐个前移，覆盖要删除的记除记录关键字大的所有记录逐个前移，覆盖要删除的记录录当一个控制区间的记录全部删除后当一个控制区间的记录全部删除后，需修改顺序集，需修改顺序集中相应的索引项中相应的索引项3 VSAM文件的特点文件的特点⑴⑴ 优点优点 ◆◆ 能动态地分配和释放空间；能动态地分配和释放空间；数据结构严蔚敏◆◆ 能保持较高的能保持较高的查询效率，无论是查询原有的还查询效率，无论是查询原有的还是后插入的记录，都有相同的查询速度是后插入的记录，都有相同的查询速度；；◆◆ 能保持较高的能保持较高的存储利用率存储利用率(平均平均75%) ；；◆◆ 永远不需定期整理文件或对文件进行再组织永远不需定期整理文件或对文件进行再组织⑵⑵ 缺点缺点 ◆◆ 为保证具有较好的索引结构，在插入或删除时为保证具有较好的索引结构，在插入或删除时索引结构本身也在变化索引结构本身也在变化；；◆◆ 控制信息和索引占用空间较多，因此，控制信息和索引占用空间较多，因此，VSAM文文件通常比较庞大件通常比较庞大。

基于基于B+树的树的VSAM文件通常被作为大型索引顺序文文件通常被作为大型索引顺序文件的标准件的标准数据结构严蔚敏11.2.5 散列文件散列文件 散列文件散列文件(直接存取文件直接存取文件) ：：利用散列存储方式利用散列存储方式组织的文件组织的文件类似散列表类似散列表，即根据文件中记录关键字的，即根据文件中记录关键字的特点，设计一个散列函数和冲突处理方法，将记录散列特点，设计一个散列函数和冲突处理方法，将记录散列到存储介质上到存储介质上 在散列文件中，磁盘上的记录是成组存放的，若干在散列文件中，磁盘上的记录是成组存放的，若干个记录组成一个存储单位，称为个记录组成一个存储单位，称为桶桶(Bucket)，，同一个桶同一个桶中的记录都是同义词中的记录都是同义词(关键字的角度关键字的角度) 设设一个桶中能存放一个桶中能存放m个记录个记录，，当桶中已有当桶中已有m个同义个同义词的记录时，要存放第词的记录时，要存放第m+1个同义词就个同义词就“溢出溢出” 冲突处理方法一般是处理方法一般是拉链法拉链法 检索记录时，先根据给定值求出散列桶地址，将基检索记录时，先根据给定值求出散列桶地址，将基数据结构严蔚敏桶的记录读入内存进行顺序查找，若找到关键字等于给桶的记录读入内存进行顺序查找，若找到关键字等于给定值的记录，则查找成功；否则，依次读入各溢出桶中定值的记录，则查找成功；否则，依次读入各溢出桶中的记录继续进行查找。

的记录继续进行查找 在散列文件中删除记录，是对在散列文件中删除记录，是对记录加删除标记记录加删除标记 散列文件的特点散列文件的特点⑴⑴ 优点优点 ◆◆ 文件随机存取，记录不需进行排序文件随机存取，记录不需进行排序；；◆◆ 插入、删除方便，存取速度快插入、删除方便，存取速度快；；◆◆ 不需要索引区，不需要索引区，节省节省存储空间存储空间⑵⑵ 缺点缺点 ◆◆ 不能进行顺序存取，只能按关键字随机存取不能进行顺序存取，只能按关键字随机存取；；◆◆ 检索方式仅限于简单查询检索方式仅限于简单查询数据结构严蔚敏11.2.6 多关键字文件多关键字文件 数据库文件常常是多关键字文件，多关键字文件的数据库文件常常是多关键字文件，多关键字文件的特点是不仅可以对主关键字进行各种查询，而且可以对特点是不仅可以对主关键字进行各种查询，而且可以对次关键字进行各种查询次关键字进行各种查询因此，对多关键字文件除了可，对多关键字文件除了可按前面的方法组织主关键字索引外，还需要建立各个次按前面的方法组织主关键字索引外，还需要建立各个次关键字的索引关键字的索引由于建立由于建立次关键字的索引的结构不同，次关键字的索引的结构不同，多关键字文件有多重表文件和倒排文件多关键字文件有多重表文件和倒排文件。

数据结构严蔚敏1 多重表文件多重表文件 多重表文件多重表文件(Multilist Files)的特点是：记录按主的特点是：记录按主关键字的顺序构成一个串联文件关键字的顺序构成一个串联文件(物理上的物理上的) ，并建立主，并建立主关键字索引关键字索引(称为主索引称为主索引)；对每个次关键字都建立次关；对每个次关键字都建立次关键字索引键字索引(称为次索引称为次索引)，所有具有同一次关键字值的记，所有具有同一次关键字值的记录构成一个链表录构成一个链表(逻辑上的逻辑上的) 主索引主索引一般是非稠密索引，其索引项一般有两项：一般是非稠密索引，其索引项一般有两项：主关键字值、头指针主关键字值、头指针 次索引次索引一般是稠密索引，其索引项一般有三项：次一般是稠密索引，其索引项一般有三项：次关键字值、头指针、链表长度关键字值、头指针、链表长度头指针头指针指向数据文件中指向数据文件中具有该次关键字值的第具有该次关键字值的第1个记录，在数据文件中为各个个记录，在数据文件中为各个次关键字增加一个指针域，指向具有相同次关键字值的次关键字增加一个指针域，指向具有相同次关键字值的下一个记录的地址。

下一个记录的地址数据结构严蔚敏 对于任何次关键字的查询，都应首先查找对应的索对于任何次关键字的查询，都应首先查找对应的索引，然后顺着相应指针所指的方向查找属于本链表的记引，然后顺着相应指针所指的方向查找属于本链表的记录多重表文件的特点多重表文件的特点⑴⑴ 优点优点易于构造和修改、查询方便易于构造和修改、查询方便⑵⑵ 缺点缺点插入和删除一个记录时，需要修改多个次关键字的插入和删除一个记录时，需要修改多个次关键字的指针指针(在链表中插入或删除记录在链表中插入或删除记录)，同时还要修改各，同时还要修改各索引中的有关信息索引中的有关信息数据结构严蔚敏2 倒排文件倒排文件 倒排文件倒排文件又称逆转表文件与多重表文件类似，又称逆转表文件与多重表文件类似，可以处理多关键字查询其差别是：可以处理多关键字查询其差别是：◆ ◆ 多重表文件：将具有相同关键字值的记录链接在多重表文件：将具有相同关键字值的记录链接在一起，在数据文件中设有与各个关键字对应的指针一起，在数据文件中设有与各个关键字对应的指针域；域；◆◆ 倒排文件：将具有相同关键字值的记录的地址收倒排文件：将具有相同关键字值的记录的地址收集在一起，并保存到相应的次关键字的索引项中，集在一起，并保存到相应的次关键字的索引项中，在数据文件中不设置对应的指针域，见在数据文件中不设置对应的指针域，见p321。

次索引次索引是次关键字倒排表，倒排表由次关键字值、是次关键字倒排表，倒排表由次关键字值、记录指针记录指针(地址地址)，索引中保持次关键字的逻辑顺序索引中保持次关键字的逻辑顺序数据结构严蔚敏倒排表文件的特点倒排表文件的特点⑴⑴ 优点优点检索速度快，插入和删除操作比多重表文件简单检索速度快，插入和删除操作比多重表文件简单当插入一个记录时，只要将记录存入数据文件，并当插入一个记录时，只要将记录存入数据文件，并将其存储地址加入各倒排表中；删除也很方便将其存储地址加入各倒排表中；删除也很方便⑵⑵ 缺点缺点倒排表维护比较困难在同一索引表中，不同关键倒排表维护比较困难在同一索引表中，不同关键字值的记录数目不同，同一倒排表中的各项长度不字值的记录数目不同，同一倒排表中的各项长度不等数据结构严蔚敏11. 3 外部排序外部排序 当对数据记录量巨大的数据文件进行排序时，由于当对数据记录量巨大的数据文件进行排序时，由于受到内存容量的限制，无法将所有数据记录一次全部读受到内存容量的限制，无法将所有数据记录一次全部读入到内存进行排序过程中需要多次进行内、外存之间入到内存进行。

排序过程中需要多次进行内、外存之间的数据交换的数据交换利用外存对数据文件进行排序利用外存对数据文件进行排序称为称为外部外部排序排序数据结构严蔚敏11.3.1 外部排序方法外部排序方法 外部排序最基本的方法是外部排序最基本的方法是归并归并这种方法是由两个这种方法是由两个相对独立的阶段组成：相对独立的阶段组成：① ① 按内存按内存( (缓冲区缓冲区) )的大小，将的大小，将n个记录的数据文件个记录的数据文件分成若干个长度为分成若干个长度为l的段或子文件，依次读入内存并的段或子文件，依次读入内存并选择有效的内部排序方法进行排序；然后将排好序选择有效的内部排序方法进行排序；然后将排好序的有序子文件重新写入到外存子的有序子文件重新写入到外存子文件称为文件称为归并段归并段或或顺串顺串② ② 采用归并的办法对采用归并的办法对归并段归并段进行逐趟归并，使进行逐趟归并，使归并归并段段的长度逐渐增大，直到最后合并成只有一个的长度逐渐增大，直到最后合并成只有一个归并归并段段的文件的文件—排好序的文件排好序的文件数据结构严蔚敏1 外部排序的简单方法外部排序的简单方法 归并排序有多种方法，最简单的就是归并排序有多种方法，最简单的就是2-路归并。

路归并 设有一个设有一个磁盘上的数据文件，共有磁盘上的数据文件，共有100,000个记录个记录(A1，， A2，， …，，A100000)，页块长为，页块长为200个记录，供排序个记录，供排序使用的缓冲区可提供容纳使用的缓冲区可提供容纳1000个记录的空间，现要对该个记录的空间，现要对该文件进行排序，排序过程可按如下步骤进行：文件进行排序，排序过程可按如下步骤进行：  第一步第一步：：每次将每次将5个页块个页块(1000个记录个记录)由外存读到由外存读到内存，内存， 进行内排序，整个文件共得到进行内排序，整个文件共得到10个初始顺串个初始顺串R1~R10 (每一个顺串占每一个顺串占5个页块个页块)，然后把它们写回到磁，然后把它们写回到磁盘上去，如图盘上去，如图11-6所示 第二步第二步：：然后两两归并，直到成为一个有序文件然后两两归并，直到成为一个有序文件为止数据结构严蔚敏R’’1有序的数据文件有序的数据文件R1R2R3R4R5R6R7R8R9R10R’1R’2R’3R’4R’5R’’2R’’3R’’’1R’’’2图图11-6 外部排序过程示意图外部排序过程示意图数据结构严蔚敏 由图可知，每趟归并由由图可知，每趟归并由m个归并段得到个归并段得到┌m/2┐个个归归并段。

并段2 外排序的时间分析外排序的时间分析 外排序的时间消耗比内排序大得多，原因是：外排序的时间消耗比内排序大得多，原因是：● 外排序的数据量外排序的数据量(记录记录)一般很大；一般很大；● 外排序涉及到内、外存之间的数据交换操作；外排序涉及到内、外存之间的数据交换操作；● 外存的操作速度远远比内存中的操作慢外存的操作速度远远比内存中的操作慢外排序的总时间由三部分组成：外排序的总时间由三部分组成：外排序的时间外排序的时间=产生初始归并段的时间产生初始归并段的时间(内排序内排序)m×tis +I/O操作的时间操作的时间d×tio +内部归并的时间内部归并的时间s×utmg数据结构严蔚敏其中：其中：m：：初初始始归归并并段段数数目目；；tis：：得得到到一一个个归归并并段段的的内内排排序序时间；时间；d：总的读、写次数；：总的读、写次数；tio：一次读、写的时间；：一次读、写的时间；s：：归归并并的的趟趟数数；；utmg：：对对u个个记记录录进进行行一一趟趟内内部部归归并并排序的时间。

排序的时间 一一般般地地，，tio>>tis，，tio>>tmg，，tio而而取取决决于于所所用用外外存存,因因此此，，影影响响外外排排序序效效率率的的主主要要原原因因是是内内、、外外存存之之间间数数据据交交换换(读、写外存读、写外存)提高效率的主要方法提高效率的主要方法(途径途径)有：有：● 进行多路归并，减少文件归并的趟数；进行多路归并，减少文件归并的趟数；● 增加归并段的长度，减少初始归并的数目；增加归并段的长度，减少初始归并的数目；● 根据不同归并段的长度，采取最佳归并方案根据不同归并段的长度，采取最佳归并方案数据结构严蔚敏。