数据结构严蔚敏 图4

合集下载

严蔚敏数据结构-第四章 串

严蔚敏数据结构-第四章 串
S1 4 a b c d S2 2 e f T 6 a b c d e f
15
(2)S1串长 最大串长 串长<最大串长 串长 最大串长; S1,S2串长和 最大串长 串长和>最大串长 串长和 最大串长;
S1 6 a b c d e f S2 6 g h i j k l T 8 a b c d e f g h
3
串的抽象数据类型的定义: 串的抽象数据类型的定义: ADT String{ 数据对象: 数据对象:D={ai|ai∈CharacterSet, i=1,2,...,n, n>=0} 数据关系: 数据关系:R1={<ai-1,ai>|ai-1,ai∈D, i=2,...,n} 基本操作: 基本操作: StrAssign(&T, chars)
11
作业: 作业: 1.用5种串的基本操作(StrAssign、StrCompare、StrLen Concat、SubString)来逻辑实现StrInsert(&S, pos, T)操作 、 操作. )
Status StrInsert(String S, int pos , String T) { if ……….. return error; , , ); ); ); );
chars是字符串常量。生成一个其值等于chars的串 。 是字符串常量。生成一个其值等于 的串T。 是字符串常量 的串
StrCopy(&T, S)
存在则由串S复制得串 串S存在则由串 复制得串 存在则由串 复制得串T
StrEmpty(S)
存在则若S为空串 串S存在则若 为空串 返回真否则返回假 存在则若 为空串,返回真否则返回假
Sub返回串 的第pos个字符起长度为 返回串S的第 个字符起长度为len的子串 用Sub返回串S的第pos个字符起长度为len的子串

最新250页的精品清华大学严蔚敏数据结构

最新250页的精品清华大学严蔚敏数据结构

证略。
例5for(i=2;i<=n;++I)
for(j=2;j<=i-1;++j)
{++x;a[i,j]=x;}
语句频度为:
1+2+3+…+n-2=(1+n-2) ×(n-2)/2
=(n-1)(n-2)/2
=n2-3n+2
∴时间复杂度为O(n2)
即此算法的时间复杂度为平方阶.
一个算法时间为O(1)的算法,它的 基本运算执行的次数是固定的。因此,
事先分析 求出该算法的一个时间界限函数
事后测试 收集此算法的执行时间和实际占用 空间的统计资料。
定义:如果存在两个正常数c和n0,对于所有的 n≧n0,有︱f(n) ︳≦c|g(n) ︳
则记作 f(n)=O(g(n))
一般情况下,算法中基本操作重复执行的 次数是问题规模n的某个函数,算法的时 间量度记作
此,只要有人能将现有指数时间算法中
(1)有穷性 一个算法必须总是在执行有穷步 之后结束,且每一步都在有穷时间内完成。
(2)确定性 算法中每一条指令必须有确切的 含义。不存在二义性。且算法只有一个入口和 一个出口。
(3)可行性 一个算法是可行的。即算法描述 的操作都是可以通过已经实现的基本运算执行 有限次来实现的。
4)输入 一个算法有零个或多个输入,这些输 入取自于某个特定的对象集合。
250页的精品清华大学严蔚敏数 据结构
第一章 绪 论
1.1 什么是数据结构 1.2 基本概念和术语 1.3 抽象数据类型的表示与实现 1.4 算法和算法分类
1.4.1 算法 1.4.2 算法设计的要求 1.4.3 算法效率的度量 1.4.4 算法的存储空间的需求

串-第4章-《数据结构题集》答案解析-严蔚敏吴伟民版

串-第4章-《数据结构题集》答案解析-严蔚敏吴伟民版

串-第4章-《数据结构题集》答案解析-严蔚敏吴伟民版习题集解析部分第4章串——《数据结构题集》-严蔚敏.吴伟民版源码使⽤说明链接☛☛☛课本源码合辑链接☛☛☛习题集全解析链接☛☛☛相关测试数据下载链接☛本习题⽂档的存放⽬录:数据结构\▼配套习题解析\▼04 串⽂档中源码的存放⽬录:数据结构\▼配套习题解析\▼04 串\▼习题测试⽂档-04源码测试数据存放⽬录:数据结构\▼配套习题解析\▼04 串\▼习题测试⽂档-04\Data⼀、基础知识题4.1❶简述空串和空格串(或称空格符串)的区别。

4.2❷对于教科书4.1节中所述串的各个基本操作,讨论是否可由其他基本操作构造⽽得,如何构造?4.3❶设s = ‘I AM A STUDENT’,t = ‘GOOD’,q = ‘WORKER’。

求:StrLength(s),StrLength(t),SubString(s, 8, 7),SubString(t, 2, 1),Index(s, ‘A’),Index(s, t),Replace(s, ‘STUDENT’, q),Concat(SubString(s, 6, 2), Concat(t, SubString(s, 7, 8)))。

4.4❶已知下列字符串a = ‘THIS’, f = ‘A SAMPLE’, c = ‘GOOD’, d = ‘NE’,b = ‘ ’.s = Concat(a, Concat(SubString(f, 2, 7), Concat(b, SubString(a, 3, 2)))),t = Replace(f, SubString(f, 3, 6), c),u = Concat(SubString(c, 3, 1), d),g = ‘IS’,v = Concat(s, Concat(b, Concat(t, Concat(b, u)))),试问:s,t,v,StrLength(s),Index(v, g),Index(u, g)各是什么?4.5❶试问执⾏以下函数会产⽣怎样的输出结果?void demonstrate(){StrAssign(s, ‘THIS IS A BOOK’);Replace(s, SubString(s, 3, 7), ‘ESE ARE’);StrAssign(t, Concat(s, ‘S’));StrAssign(u, ‘XYXYXYXYXYXY’);StrAssign(v, SubString(u, 6, 3));StrAssign(w, ‘W’);printf(‘t=’, t, ‘v=’, v, ‘u=’, Replace(u, v, w));}//demonstrate4.6❷已知:s = ‘(XYZ)+*’,t = ‘(X+Z)*Y’。

数据结构-清华大学严蔚敏

数据结构-清华大学严蔚敏
④ 除最后一个元素外,每个元素均有唯一一个直接 后继。
精选ppt课件
4
2.2 线性表的顺序存储
顺序存储 :把线性表的结点按逻辑顺序依次存放 在一组地址连续的存储单元里。用这种方法存储的线性 表简称顺序表。
顺序存储的线性表的特点:
◆ 线性表中所有元素所占的存储空间是连续的; ◆ 数据元素在存储空间中是按逻辑顺序依次存放。 设有非空的线性表:(a1,a2,…an) 。顺序存储如图 2-1所示。
8
图2-2 链表结点结构
单链表是由表头唯一确定,因此单
链表可以用头指针的名字来命名。
1100
例1、线性表L=(bat,cat,eat,fat,
hat)
1300
其带头结点的单链表的逻辑状态和物理
存储方式如图2-3所示。
1305
head
3695
head
bat
cat
eat
fat
hat ⋀ 3700
图2-3 带头结点的单链表的逻辑精选状ppt课态件、物理存储方式
图2-6是带头结点的单循环链表的示意图。
head
head a1
a2
……
an
空表
非空表
图2-6 单循环链表精选示ppt意课件图
10
2.4 双向链表
双向链表(Double Linked List) :指的是构
成链表的每个结点中设立两个指针域:一个指向其直接 前趋的指针域prior,一个指向其直接后继的指针域 next。这样形成的链表中有两个方向不同的链,故称 为双向链表。
LOC(ai+1)=LOC(ai)+l
精选ppt课件
6
2.3 线性表的链式存储
2.3.1 线性表的链式存储结构

数据结构(C)严蔚敏——4

数据结构(C)严蔚敏——4
m*n-1
Data Structure 2013-7-10
a0,n-1 a1,n-1
…….. am-1 ,n-1
Page 9
5.3 矩阵的压缩存储
4 8 0 0 0
7 2 3 4
2 7 1 9
3 1 7 8
4 9 8 6
7 2 3 4
重点和难点

重点是学习数组类型的定义及其存储表示。
知识点

数组的类型定义、数组的存储表示、特殊矩阵的压缩存储表示方法、 随机稀疏矩阵的压缩存储表示方法。
Data Structure
2013-7-10
Page 1
5.1 数组的定义
数组是线性表的推广

数组可以看成是一种特殊的线性表,即线性表中数据元素本身也 是一个线性表。 a 01 a 02 ... a 0,n-1 a 00 a a11 a12 ... a1,n-1 列向量 10 A m×n = ... ... ... ... ... a m-1,0 a m-1,1 a m-1,2 ... a m-1,n-1
对称矩阵
n阶矩阵;
aij=aji
Data Structure
1i,j n
2013-7-10 Page 11
特殊矩阵

值相同的元素或者零元素在矩阵中的分布有一定规律。
7 2 3 4
0 7 1 9
0 0 7 8
0 0 0 6
三角矩阵
n阶矩阵; 下(上)三角矩阵:矩阵的上(下)三角(不 包括对角线)中的元均为常数c或零。
a 01 a 02 a11 a12 ... ... a m-1, a m-1,2 1

数据结构C语言版(第2版)严蔚敏人民邮电出版社课后习题答案

数据结构C语言版(第2版)严蔚敏人民邮电出版社课后习题答案

数据结构(C语言版)(第2版)课后习题答案李冬梅2015.3目录第1章绪论...................................................................................... 错误!未定义书签。

第2章线性表 .................................................................................. 错误!未定义书签。

第3章栈和队列 .............................................................................. 错误!未定义书签。

第4章串、数组和广义表 ............................................................... 错误!未定义书签。

第5章树和二叉树........................................................................... 错误!未定义书签。

第6章图............................................................................................ 错误!未定义书签。

第7章查找...................................................................................... 错误!未定义书签。

第8章排序...................................................................................... 错误!未定义书签。

数据结构严蔚敏ppt课件

数据结构严蔚敏ppt课件数据结构(严蔚敏)版●资料上传者:安徽大学研究生●资料使用范围:各大学考研及本科教学●欢迎报考安徽大学研究生●“星光考研书屋”祝您学习愉快[学习目标]掌握线性表的顺序存储结构和抽象数据类型中定义的每一种操作的含义,在顺序存储方式下每一种操作的具体实现和相应的时间复杂度;掌握链接存储的概念,线性表的单、双链接存储结构,对它们进行插入和删除结点的方法,循环单、双链表和带表头附加结点的单、双链表的结构和操作特点;掌握每一种线性表操作在由动态结点构成的单链表上具体实现的算法以及相应的时间复杂度。

2第2章线性表线性结构是最常用、最简单的一种数据结构。

而线性表是一种典型的线性结构。

其基本特点是线性表中的数据元素是有序且是有限的。

在这种结构中:① 存在一个唯一的被称为“第一个”的数据元素;② 存在一个唯一的被称为“最后一个”的数据元素;③ 除第一个元素外,每个元素均有唯一一个直接前驱;④ 除最后一个元素外,每个元素均有唯一一个直接后继。

32.1 线性表的逻辑结构线性表(Linear List ) :是由n(n ≧0)个数据元素(结点)a 1,a 2,…a n 组成的有限序列。

该序列中的所有结点具有相同的数据类型。

其中数据元素的个数n 称为线性表的长度。

当n=0时,称为空表。

当n>0时,将非空的线性表记作: (a 1,a 2,…a n ) a 1称为线性表的第一个(首)结点,a n 称为线性表的最后一个(尾)结点。

2.1.1 线性表的定义4a1,a2,…a i-1都是a i(2≦i≦n)的前驱,其中a i-1是a i的直接前驱;a i+1,a i+2,…a n都是a i(1≦i ≦n-1)的后继,其中a i+1是a i 的直接后继。

2.1.2线性表的逻辑结构线性表中的数据元素a i所代表的具体含义随具体应用的不同而不同,在线性表的定义中,只不过是一个抽象的表示符号。

◆线性表中的结点可以是单值元素(每个元素只有一个数据项) 。

《数据结构(C语言版 第2版)》(严蔚敏 著)第四章练习题答案

《数据结构(C语言版第2版)》(严蔚敏著)第四章练习题答案第4章串、数组和广义表1.选择题(1)串是一种特殊的线性表,其特殊性体现在()。

A.可以顺序存储B.数据元素是一个字符C.可以链式存储D.数据元素可以是多个字符若答案:B(2)串下面关于串的的叙述中,()是不正确的?A.串是字符的有限序列B.空串是由空格构成的串C.模式匹配是串的一种重要运算D.串既可以采用顺序存储,也可以采用链式存储答案:B解释:空格常常是串的字符集合中的一个元素,有一个或多个空格组成的串成为空格串,零个字符的串成为空串,其长度为零。

(3)串“ababaaababaa”的next数组为()。

A.012345678999 B.012121111212 C.011234223456 D.0123012322345答案:C(4)串“ababaabab”的nextval为()。

A.010104101B.010102101 C.010100011 D.010101011答案:A(5)串的长度是指()。

A.串中所含不同字母的个数B.串中所含字符的个数C.串中所含不同字符的个数D.串中所含非空格字符的个数答案:B解释:串中字符的数目称为串的长度。

(6)假设以行序为主序存储二维数组A=array[1..100,1..100],设每个数据元素占2个存储单元,基地址为10,则LOC[5,5]=()。

A.808 B.818 C.1010 D.1020答案:B解释:以行序为主,则LOC[5,5]=[(5-1)*100+(5-1)]*2+10=818。

(7)设有数组A[i,j],数组的每个元素长度为3字节,i的值为1到8,j的值为1到10,数组从内存首地址BA开始顺序存放,当用以列为主存放时,元素A[5,8]的存储首地址为()。

A.BA+141 B.BA+180 C.BA+222 D.BA+225答案:B解释:以列序为主,则LOC[5,8]=[(8-1)*8+(5-1)]*3+BA=BA+180。

数据结构严蔚敏(全部章节814张PPT)-(课件)

① 集合:结构中的数据元素除了“同属于一个集合” 外,没有其它关系。
② 线性结构:结构中的数据元素之间存在一对一的 关系。
③ 树型结构:结构中的数据元素之间存在一对多的 关系。
④ 图状结构或网状结构:结构中的数据元素之间存 在多对多的关系。
图1-3 四类基本结构图
1.1.3 数据结构的形式定义
数据结构的形式定义是一个二元组: Data-Structure=(D,S)
计算机求解问题的一般步骤
编写解决实际问题的程序的一般过程:
– 如何用数据形式描述问题?—即由问题抽象出一个 适当的数学模型; – 问题所涉及的数据量大小及数据之间的关系; – 如何在计算机中存储数据及体现数据之间的关系? – 处理问题时需要对数据作何种运算? – 所编写的程序的性能是否良好? 上面所列举的问题基本上由数据结构这门课程来回答。
其中:D是数据元素的有限集,S是D上关系的有限集。 例2:设数据逻辑结构B=(K,R)
K={k1, k2, …, k9} R={ <k1, k3>,<k1, k8>,<k2, k3>,<k2, k4>,<k2, k5>,<k3, k9>, <k5, k6>,<k8, k9>,<k9, k7>,<k4, k7>,<k4, k6> } 画出这逻辑结构的图示,并确定那些是起点,那些是终点
<基本操作名>(<参数表>) 初始条件: <初始条件描述> 操作结果: <操作结果描述>
– 初始条件:描述操作执行之前数据结构和参数应 满足的条件;若不满足,则操作失败,返回相应的出 错信息。

严蔚敏数据结构第四章答案

void String_Reverse(Stringtype s,Stringtype &r)//求s的逆串r{StrAssign(r,''); //初始化r为空串for(i=Strlen(s);i;i--){StrAssign(c,SubString(s,i,1));StrAssign(r,Concat(r,c)); //把s的字符从后往前添加到r中}}//String_Reverse4.11void String_Subtract(Stringtype s,Stringtype t,Stringtype &r)//求所有包含在串s中而t中没有的字符构成的新串r{StrAssign(r,'');for(i=1;i<=Strlen(s);i++){StrAssign(c,SubString(s,i,1));for(j=1;j<i&&StrCompare(c,SubString(s,j,1));j++); //判断s的当前字符c是否第一次出现if(i==j){for(k=1;k<=Strlen(t)&&StrCompare(c,SubString(t,k,1));k++); //判断当前字符是否包含在t中if(k>Strlen(t)) StrAssign(r,Concat(r,c));}}//for}//String_Subtract4.12int Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T替换为V,并返回置换次数{for(n=0,i=1;i<=Strlen(S)-Strlen(T)+1;i++) //注意i的取值范围if(!StrCompare(SubString(S,i,Strlen(T)),T)) //找到了与T匹配的子串{ //分别把T的前面和后面部分保存为head和tailStrAssign(head,SubString(S,1,i-1));StrAssign(tail,SubString(S,i+Strlen(T),Strlen(S)-i-Strlen(T)+1));StrAssign(S,Concat(head,V));StrAssign(S,Concat(S,tail)); //把head,V,tail连接为新串i+=Strlen(V); //当前指针跳到插入串以后n++;}//ifreturn n;}//Replace分析:i+=Strlen(V);这一句是必需的,也是容易忽略的.如省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S='place',T='ace', V='face',则省掉i+=Strlen(V);运行时会出现什么结果?4.13int Delete_SubString(Stringtype &s,Stringtype t)//从串s中删除所有与t相同的子串,并返回删除次数{for(n=0,i=1;i<=Strlen(s)-Strlen(t)+1;i++)if(!StrCompare(SubString(s,i,Strlen(t)),t)){StrAssign(head,SubString(S,1,i-1));StrAssign(tail,SubString(S,i+Strlen(t),Strlen(s)-i-Strlen(t)+1));StrAssign(S,Concat(head,tail)); //把head,tail连接为新串n++;}//ifreturn n,}//Delete_SubString4.14Status NiBoLan_to_BoLan(Stringtype str,Stringtype &new)//把前缀表达式str转换为后缀式new{Initstack(s); //s的元素为Stringtype类型for(i=1;i<=Strlen(str);i++){r=SubString(str,i,1);if(r为字母) push(s,r);else{if(StackEmpty(s)) return ERROR;pop(s,a);if(StackEmpty(s)) return ERROR;pop(s,b);StrAssign(t,Concat(r,b));StrAssign(c,Concat(t,a)); //把算符r,子前缀表达式a,b连接为新子前缀表达式c push(s,c);}}//forpop(s,new);if(!StackEmpty(s)) return ERROR;return OK;}//NiBoLan_to_BoLan分析:基本思想见书后注释3.23.请读者用此程序取代作者早些时候对3.23题给出的程序.4.15void StrAssign(Stringtype &T,char chars&#;)//用字符数组chars给串T赋值,Stringtype的定义见课本{for(i=0,T[0]=0;chars[i];T[0]++,i++) T[i+1]=chars[i];}//StrAssign4.16char StrCompare(Stringtype s,Stringtype t)//串的比较,s>t时返回正数,s=t时返回0,s<t时返回负数{for(i=1;i<=s[0]&&i<=t[0]&&s[i]==t[i];i++);if(i>s[0]&&i>t[0]) return 0;else if(i>s[0]) return -t[i];else if(i>t[0]) return s[i];else return s[i]-t[i];}//StrCompare4.17int String_Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T 替换为V,并返回置换次数{for(n=0,i=1;i<=S[0]-T[0]+1;i++){for(j=i,k=1;T[k]&&S[j]==T[k];j++,k++);if(k>T[0]) //找到了与T匹配的子串:分三种情况处理{if(T[0]==V[0])for(l=1;l<=T[0];l++) //新子串长度与原子串相同时:直接替换S[i+l-1]=V[l];else if(T[0]<V[0]) //新子串长度大于原子串时:先将后部右移{for(l=S[0];l>=i+T[0];l--)S[l+V[0]-T[0]]=S[l];for(l=1;l<=V[0];l++)S[i+l-1]=V[l];}else //新子串长度小于原子串时:先将后部左移{for(l=i+V[0];l<=S[0]+V[0]-T[0];l++)S[l]=S[l-V[0]+T[0]];for(l=1;l<=V[0];l++)S[i+l-1]=V[l];}S[0]=S[0]-T[0]+V[0];i+=V[0];n++;}//if}//forreturn n;}//String_Replace4.18typedef struct {char ch;int num;} mytype;void StrAnalyze(Stringtype S)//统计串S中字符的种类和个数{mytype T[MAXSIZE]; //用结构数组T存储统计结果for(i=1;i<=S[0];i++){c=S[i];j=0;while(T[j].ch&&T[j].ch!=c) j++; //查找当前字符c是否已记录过if(T[j].ch) T[j].num++;else T[j]={c,1};}//forfor(j=0;T[j].ch;j++)printf("%c: %d\n",T[j].ch,T[j].num);}//StrAnalyze4.19void Subtract_String(Stringtype s,Stringtype t,Stringtype &r)//求所有包含在串s中而t中没有的字符构成的新串r{r[0]=0;for(i=1;i<=s[0];i++){c=s[i];for(j=1;j<i&&s[j]!=c;j++); //判断s的当前字符c是否第一次出现if(i==j){for(k=1;k<=t[0]&&t[k]!=c;k++); //判断当前字符是否包含在t中if(k>t[0]) r[++r[0]]=c;}}//for}//Subtract_String4.20int SubString_Delete(Stringtype &s,Stringtype t)//从串s中删除所有与t相同的子串,并返回删除次数{for(n=0,i=1;i<=s[0]-t[0]+1;i++){for(j=1;j<=t[0]&&s[i+j-1]==t[i];j++);if(j>m) //找到了与t匹配的子串{for(k=i;k<=s[0]-t[0];k++) s[k]=s[k+t[0]]; //左移删除s[0]-=t[0];n++;}}//forreturn n;}//Delete_SubString4.21typedef struct{char ch;LStrNode *next;} LStrNode,*LString; //链串结构void StringAssign(LString &s,LString t)//把串t赋值给串s{s=malloc(sizeof(LStrNode));for(q=s,p=t->next;p;p=p->next){r=(LStrNode*)malloc(sizeof(LStrNode));r->ch=p->ch;q->next=r;q=r;}q->next=NULL;}//StringAssignvoid StringCopy(LString &s,LString t)//把串t复制为串s.与前一个程序的区别在于,串s业已存在.{for(p=s->next,q=t->next;p&&q;p=p->next,q=q->next){p->ch=q->ch;pre=p;}while(q){p=(LStrNode*)malloc(sizeof(LStrNode));p->ch=q->ch;pre->next=p;pre=p;}p->next=NULL;}//StringCopychar StringCompare(LString s,LString t)//串的比较,s>t时返回正数,s=t时返回0,s<t 时返回负数{for(p=s->next,q=t->next;p&&q&&p->ch==q->ch;p=p->next,q=q->next);if(!p&&!q) return 0;else if(!p) return -(q->ch);else if(!q) return p->ch;else return p->ch-q->ch;}//StringCompareint StringLen(LString s)//求串s的长度(元素个数){for(i=0,p=s->next;p;p=p->next,i++);return i;}//StringLenLString * Concat(LString s,LString t)//连接串s和串t形成新串,并返回指针{p=malloc(sizeof(LStrNode));for(q=p,r=s->next;r;r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;}//for //复制串sfor(r=t->next;r;r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;}//for //复制串tq->next=NULL;return p;}//ConcatLString * Sub_String(LString s,int start,int len)//返回一个串,其值等于串s从start 位置起长为len的子串{p=malloc(sizeof(LStrNode));q=p;for(r=s;start;start--,r=r->next); //找到start所对应的结点指针rfor(i=1;i<=len;i++,r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;} //复制串tq->next=NULL;return p;}//Sub_String4.22void LString_Concat(LString &t,LString &s,char c)//用块链存储结构,把串s插入到串t的字符c之后{p=t.head;while(p&&!(i=Find_Char(p,c))) p=p->next; //查找字符cif(!p) //没找到{t.tail->next=s.head;t.tail=s.tail; //把s连接在t的后面}else{q=p->next;r=(Chunk*)malloc(sizeof(Chunk)); //将包含字符c的节点p分裂为两个for(j=0;j<i;j++) r->ch[j]='#'; //原结点p包含c及其以前的部分for(j=i;j<CHUNKSIZE;j++) //新结点r包含c以后的部分{r->ch[j]=p->ch[j];p->ch[j]='#'; //p的后半部分和r的前半部分的字符改为无效字符'#'}p->next=s.head;s.tail->next=r;r->next=q; //把串s插入到结点p和r之间}//elset.curlen+=s.curlen; //修改串长s.curlen=0;}//LString_Concatint Find_Char(Chunk *p,char c)//在某个块中查找字符c,如找到则返回位置是第几个字符,如没找到则返回0{for(i=0;i<CHUNKSIZE&&p->ch[i]!=c;i++);if(i==CHUNKSIZE) return 0;else return i+1;}//Find_Char4.23int LString_Palindrome(LString L)//判断以块链结构存储的串L是否为回文序列,是则返回1,否则返回0{InitStack(S);p=S.head;i=0;k=1; //i指示元素在块中的下标,k指示元素在整个序列中的序号(从1开始)for(k=1;k<=S.curlen;k++){if(k<=S.curlen/2) Push(S,p->ch[i]); //将前半段的字符入串else if(k>(S.curlen+1)/2){Pop(S,c); //将后半段的字符与栈中的元素相匹配if(p->ch[i]!=c) return 0; //失配}if(++i==CHUNKSIZE) //转到下一个元素,当为块中最后一个元素时,转到下一块{p=p->next;i=0;}}//forreturn 1; //成功匹配}//LString_Palindrome4.24void HString_Concat(HString s1,HString s2,HString &t)//将堆结构表示的串s1和s2连接为新串t{if(t.ch) free(t.ch);t.ch=malloc((s1.length+s2.length)*sizeof(char));for(i=1;i<=s1.length;i++) t.ch[i-1]=s1.ch[i-1];for(j=1;j<=s2.length;j++,i++) t.ch[i-1]=s2.ch[j-1];t.length=s1.length+s2.length;}//HString_Concat4.25int HString_Replace(HString &S,HString T,HString V)//堆结构串上的置换操作,返回置换次数{for(n=0,i=0;i<=S.length-T.length;i++){for(j=i,k=0;k<T.length&&S.ch[j]==T.ch[k];j++,k++);if(k==T.length) //找到了与T匹配的子串:分三种情况处理{if(T.length==V.length)for(l=1;l<=T.length;l++) //新子串长度与原子串相同时:直接替换S.ch[i+l-1]=V.ch[l-1];else if(T.length<V.length) //新子串长度大于原子串时:先将后部右移{for(l=S.length-1;l>=i+T.length;l--)S.ch[l+V.length-T.length]=S.ch[l];for(l=0;l<V.length;l++)S[i+l]=V[l];}else //新子串长度小于原子串时:先将后部左移{for(l=i+V.length;l<S.length+V.length-T.length;l++)S.ch[l]=S.ch[l-V.length+T.length];for(l=0;l<V.length;l++)S[i+l]=V[l];}S.length+=V.length-T.length;i+=V.length;n++;}//if}//forreturn n;}//HString_Replace4.26Status HString_Insert(HString &S,int pos,HString T)//把T插入堆结构表示的串S的第pos个字符之前{if(pos<1) return ERROR;if(pos>S.length) pos=S.length+1;//当插入位置大于串长时,看作添加在串尾S.ch=realloc(S.ch,(S.length+T.length)*sizeof(char));for(i=S.length-1;i>=pos-1;i--)S.ch[i+T.length]=S.ch[i]; //后移为插入字符串让出位置for(i=0;i<T.length;i++)S.ch[pos+i-1]=T.ch[pos]; //插入串TS.length+=T.length;return OK;}//HString_Insert4.27int Index_New(Stringtype s,Stringtype t)//改进的定位算法{i=1;j=1;while(i<=s[0]&&j<=t[0]){if((j!=1&&s[i]==t[j])||(j==1&&s[i]==t[j]&&s[i+t[0]-1]==t[t[0]])){ //当j==1即匹配模式串的第一个字符时,需同时匹配其最后一个i=i+j-2;j=1;}else{i++;j++;}}//whileif(j>t[0]) return i-t[0];}//Index_New4.28void LGet_next(LString &T)//链串上的get_next算法{p=T->succ;p->next=T;q=T;while(p->succ){if(q==T||p->data==q->data){p=p->succ;q=q->succ;p->next=q;}else q=q->next;}//while}//LGet_next4.29LStrNode * LIndex_KMP(LString S,LString T,LStrNode *pos)//链串上的KMP匹配算法,返回值为匹配的子串首指针{p=pos;q=T->succ;while(p&&q){if(q==T||p->chdata==q->chdata){p=p->succ;q=q->succ;}else q=q->next;}//whileif(!q){for(i=1;i<=Strlen(T);i++)p=p->next;return p;} //发现匹配后,要往回找子串的头return NULL;}//LIndex_KMP4.30void Get_LRepSub(Stringtype S)//求S的最长重复子串的位置和长度{for(maxlen=0,i=1;i<S[0];i++)//串S2向右移i格{for(k=0,j=1;j<=S[0]-i;j++)//j为串S2的当前指针,此时串S1的当前指针为i+j,两指针同步移动{if(S[j]==S[j+i]) k++; //用k记录连续相同的字符数else k=0; //失配时k归零if(k>maxlen) //发现了比以前发现的更长的重复子串{lrs1=j-k+1;lrs2=mrs1+i;maxlen=k; //作记录}}//for}//forif(maxlen){printf("Longest Repeating Substring length:%d\n",maxlen);printf("Position1:%d Position 2:%d\n",lrs1,lrs2);}else printf("No Repeating Substring found!\n");}//Get_LRepSub分析:i代表"错位值".本算法的思想是,依次把串S的一个副本S2向右错位平移1格,2格,3格,...与自身S1相匹配,如果存在最长重复子串,则必然能在此过程中被发现.用变量lrs1,lrs2,maxlen来记录已发现的最长重复子串第一次出现位置,第二次出现位置和长度.题目中未说明"重复子串"是否允许有重叠部分,本算法假定允许.如不允许,只需在第二个for语句的循环条件中加上k<=i即可.本算法时间复杂度为O(Strlen(S)^2).4.31void Get_LPubSub(Stringtype S,Stringtype T)//求串S和串T的最长公共子串位置和长度{if(S[0]>=T[0]){StrAssign(A,S);StrAssign(B,T);}else{StrAssign(A,T);StrAssign(B,S);} //为简化设计,令S和T中较长的那个为A,较短的那个为Bfor(maxlen=0,i=1-B[0];i<A[0];i++){if(i<0) //i为B相对于A的错位值,向左为负,左端对齐为0,向右为正{jmin=1;jmax=i+B[0];}//B有一部分在A左端的左边else if(i>A[0]-B[0]){jmin=i;jmax=A[0];}//B有一部分在A右端的右边else{jmin=i;jmax=i+B[0];}//B在A左右两端之间.//以上是根据A和B不同的相对位置确定A上需要匹配的区间(与B重合的区间)的端点:jmin,jmax.for(k=0,j=jmin;j<=jmax;j++){if(A[j]==B[j-i]) k++;else k=0;if(k>maxlen){lps1=j-k+1;lps2=j-i-k+1;maxlen=k; }}//for}//forif(maxlen){if(S[0]>=T[0]){。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

关键活动 定义:
假设第 i 条弧为 <j, k>, 则活动i 的时间余量为:
活动i 最迟开始时间减活动i 最早开始时间
即:l(i)- e(i)
如果完成活动i 的时间余量: l(i)- e(i) =0 则把活动i 称为关键活动
19
求关键活动的步骤:
① 求事件的最早发生时间ve;
ve(k) = Max{ve(j) + dut(<j, k>)}
关键路径
AOV网(Activity On Vertex) 顶点表示活动, 弧表示优先关系
C4 C2 C1 C12 C9 C10 C6 C11 C8 C3 C7 C5
只表示活动之间定性的拓扑关系。 不表示活动之间定量的时序关系。
11
AOE网(Activity On Edge)
1. 工程完成时间? 顶点表示事件,弧表示活动 2. 关键子工程? 权表示持续活动时间
第七章 图
7.1 图的抽象数据类型定义
7.2 图的存储表示
7.3 图的遍历 7.4 最小生成树 7.5 拓扑排序 关键路径 7.6 最短路径问题
1
7.5 拓扑排序
如何判断一个图是否存在环(回路)?
无向有环图
A B D 有向无环图 A
C E
F D
B
C E
F
对无向图---深度优先遍历。 对有向图----拓扑排序。
2 4
a
5
4
vl(汇点)=18 P vl(g)=18-2=16 vl(h)=18-4=14
2 d f vl(e)= min(vl(g)-8,vl(h)-7) =min(16-8,14-7) =7 vl(b)= min(vl(e)-1) = min(7-1)=6
16
活动 i 的 最早开始时间 e(i)
20
求顶点的最早发生时间ve和最迟发生时间vl b 1 g 2 6 8 a
4 5
d c
1
e
7
h 4 f
P
4
2
p a b c d e f g h k
① ②
ve vl
0 0 0 0 0 0 15 14 18 6 4 5 5 7 0 11 0 7 0 18 18 18 18 18 18 18 18 18 0 6 6 8 8 10 16 14 7
1 c
2
e
7
P 4
h
4 f
―关键活动”:构成最长路径的所有活动(弧).
―关键活动”的权值增加将使有向 图上的最长路径的长度增加。 13
如何求关键活动?
―事件(顶点)‖ 的 最早发生时间 ve(j) ―事件(顶点)‖ 的 最迟发生时间 vl(k) ―活动(弧)‖ 的 最早开始时间 e(j) ―活动(弧)‖ 的 最迟开始时间 l(k) 完成第i项活动的时间余量
Status CriticalPath ( ALGraph G ) {//输出G的各项关键活动。 if (!TopologicalOrder (G, T)) return ERROR; vl[0..G.vexnum-1]=ve[G.vexnum-1]; //初始化事件最迟发生时间 while ( ! StackEmpty (T) ) //按拓扑逆序求各顶点的vl 值 for (Pop(T,j), p=G.vertices[j].firstarc; p; p=p->nextarc) { k=p->adjvex; dut=*(p->info); //dut<j, k> if(vl[k]–dut<vl[j]) vl[j]=vl[k]–dut; } // for for (j=0; j < G.vexnum; ++j ) //求e、l和关键活动 for(p=G.vertices[j].firstarc; p; p=p->nextarc){ k=p->adjvex; dut=*(p->info); e=ve[j]; l=vl[k]–dut; tag=( e = = l ) ? ‗*‘ : ‗ ‘ ; printf ( j, k, dut, e, l, tag ); // 输出关键活动 } // for 25 } //CriticalPath
C4 C2 C1 C12 C3 C7
C5
C9
C10 C6 C11
C8
3
何谓“拓扑排序”?
对有向图进行如下操作: 按照有向图给出的次序关系,将图 中顶点排成一个线性序列,对于有向 图中没有限定次序关系的顶点,则可 以人为加上任意的次序关系。 由此所得顶点的线性序列称之为拓 扑有序序列
4
例如:对于下列有向图
活动的开始顶点的最早发生时间 假设第 i 条弧为 <j, k>,则:e(i) = ve(j);
① b ④ 6 1 ⑨8
g
11
2 P
a
5

4② c
1

e
事件j的 最早发生时间
⑦7
4 h ⑩

d
2

4 f
e(1)=ve(a)=0 e(4)= ve(b)=6
17
e(8) =ve(f)=7 e(9)=ve(e)=7
14
―事件(顶点)” 的最早发生时间 ve(k) ve(k) = 从源点到顶点k的最长路径长度; ve(k) = Max{ve(j) + dut(<j, k>)}
<j, k>为与事件k关联的弧,dut(<j, k>)为弧权值 6 a 5 d 4 c 2 4 b 1 1 e 8 g 4 h 2
7
f ve(e)= max(ve(b)+1,ve(c)+1) = max(6+1,4+1) =7 ve(h)= max(ve(e)+7,ve(f)+4) = max(7+7,7+4)=14 15
2
课程编号 课程名称
课程编号 课程名称
C1 程序设计基础 C7 编译原理 AOV网(Activity On Vertex) 操作系统 C2 离散数学 C8 (C1,C2,C3,C4,C5,C7,C9,C10,C11,C6,C12,C8) C3 数据结构 C9 高等数学 顶点表示活动, 弧表示优先关系 C4 汇编语言 C10 线性代数 (C9,C10,C11,C6,C1,C12,C4,C2,C3,C5,C7,C8) C5 语言的设计和分析 C11 普通物理 C6 计算机原理 C12 数值分析
ve(源点)=0 P ve(b)=6 ve(c)=4 ve(d)=5
“事件(顶点)” 的最迟发生时间 vl(j)
vl(j) = 汇点的最迟发生时间- 从顶点j到汇点的最短路径长度;
vl(j) = Min{vl(k) – dut(<j, k>)}
<j, k>为与事件j关联的弧,dut(<j, k>)为弧权值 6 b 1 1 c 4 e 8 7 h g
如何进行拓扑排序?
一、从有向图中选取一个没有前驱 的顶点,并输出之; 二、从有向图中删去此顶点以及所 有以它为尾的弧;
三、重复上述两步,可能得到两种结果: 1. 图空——拓扑排序成功! 2. 图不空,但找不到无前驱的顶点——有环!
7
a
a
b h c d g f
c d
e
g
b f
e
h
1。没有前驱的顶点 入度为零的顶点 2。删除顶点及以它为尾的弧 弧头顶点的入度减1
23
拓扑排序求事件最早发生事件Ve和拓扑逆序栈T Order( Status TopologicalSort ( ALGraph ,Stack &T) { G){ FindInDegree(G,indegree); //计算各顶点的入度 InitStack(S); count=0; Ve[0,…, G.vexnum-1]=0; //初始化
6 4 5 1 1 2 8 7 4 2 4
0 0 6
2 3 6
③e 0 ④l 0 ⑤
4
6
5 7
8 8
7 7 15 14
7 10 16 14
22
算法的实现要点:
显然,求ve的顺序应该是按拓扑有序的次序;
而 求vl的顺序应该是按拓扑逆序的次序;
因为 拓扑逆序序列即为拓扑有序序列的 逆序列, 因此 应该在拓扑排序的过程中, 另设一个“栈”记下拓扑有序序列。
为避免每次都要搜索入度为零的顶点, 在算法中设置一个“栈”,以保存“入度为零” 的 9
Status TopologicalSort( ALGraph G){
FindInDegree(G,indegree); InitStack(S); count=0; //计算各顶点的入度
for ( i=0; i<G.vexnum; ++i) if (!indegree[i]) Push(S, i); //入度为零的顶点入栈 while (!EmptyStack(S)) { Pop(S, v); ++count; printf(v); for (w=FirstAdj(v); w; w=NextAdj(G,v,w)){ --indegree(w); // 弧头顶点的入度减1 if (!indegree[w]) Push(S, w); } // 入度为零的顶点入栈 }//while if (count<G.vexnum) printf(―图中有回路”) } 10
需要设一个数组inDegree[w],记录顶点的入度数
8
算法描述
初始化 inDegree[w]; while(取一个新的入度为零的顶点v){ printf(v); ++m; //对输出顶点计数 for( w=FirstAdj(v); w; w=nextAdj(v,w)) inDegree[w]--; } if (m<n) printf(―图中有回路”);
相关文档
最新文档