数据结构期末复习要点(严蔚敏版)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的子串

数据结构(严蔚敏)完整第4章ppt课件

// 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。
第四章串
完整版课件
1
【课前思考】
1. "串就是线性表"的结论是否正确？
从数据结构的观点来说，串是一种特殊的线性表;但就数据类型而言，串不是线性表。
2. 串和线性表的主要差别是什么？
希望你带着这个问题开始这一章的学习，并能在学完这一章的内容之后能得出正确的结论。
完整版课件
2
【学习目标】
1. 理解“串”类型定义中各基本操作的特点，并能正确利用它们进行串的其它操作。 2. 理解串类型的各种存储表示方法。 3. 理解串匹配的各种算法。
} ADT String
完整版课件
11
StrAssign (&T, chars)
初始条件：chars 是字符串常量。操作结果：把 chars 赋为 T 的值。
完整版课件
12
StrCopy (&T, S) 初始条件：串 S 存在。操作结果：由串 S 复制得串 T。
完整版课件
13
DestroyString (&S)
完整版课件
37
#define MAXSTRLEN 255 // 用户可在255以内定义最大串长
typedef unsigned char Sstring [MAXSTRLEN + 1];
// 0号单元存放串的长度
完整版课件
38
或：
typedef struct { /* 串结构定义 */
char ch[MAXLEN］;
此串的串值，即字符序列即可。但在
多数非数值处理的程序中，串也以变

严蔚敏《数据结构》(C语言版)笔记和习题(含考研真题)详解

严蔚敏《数据结构》（C语言版）笔记和习题（含考研真题）详解第1章绪论一、什么是数据结构数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科。

二、基本概念和术语1数据数据是对客观事物的符号表示，是计算机科学中所有能输入到计算机中并能被计算机程序处理的符号的总称。

2数据元素数据元素是数据的基本单位。

3数据对象数据对象是性质相同的数据元素的集合，是数据的一个子集。

4数据结构数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

（1）数据结构的基本结构根据数据元素之间关系的不同特性，通常有下列四类基本结构：①集合。

数据元素属于“同一个集合”，并无其他复杂关系。

②线性结构。

数据元素之间存在一个对一个的关系。

③树形结构。

数据元素之间存在一个对多个的关系。

④图状结构或网状结构。

数据元素之间存在多个对多个的关系。

【注意】区分这四种基本结构可以根据元素间的对应关系。

如图1-1所示为上述四类基本结构的关系图。

图1-1 四类基本结构的关系图（2）数据结构的形式定义数据结构的形式定义为：Data_Structure=(D,S)其中：D表示数据元素的有限集，S表示D上关系的有限集。

（3）数据结构在计算机中的表示数据结构包括数据元素的表示和关系，在计算机中称为数据的物理结构（又称存储结构）。

其中，关系有两种表示方法：顺序映象和非顺序映象。

这两种表示方法对应两种存储结构：顺序存储结构和链式存储结构。

a．顺序映象：用相对位置来表示数据元素之间的逻辑关系。

b．非顺序映象：用指针表示数据元素之间的逻辑关系。

5数据类型数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

6抽象数据类型抽象数据类型（ADT）由一个值域和定义在该值域上的一组操作组成。

【注意】抽象数据类型是对数据类型架构的一种全局体现，使我们能够更加清晰地看待某一数据类型。

7多形数据类型多形数据类型是指其值的成分不确定的数据类型。

数据结构严蔚敏C语言版学习复习提纲

期末复习复习第一章绪论数据：计算机处理的信息总称数据项：最小单位数据元素：最基本单数据对象：元素集合数据结构：相互之间存在一种或多种特定关系的数据元素集合。

概念：数据元素之间的关系线性结构：一对逻辑结构非线性结构数据结构树：一对多图：多对多顺序存储结构链表存储结构存储结构。

索引。

基。

散列。

础知数据运算识算法描述：指令的有限有序序列有穷性确定性算法特性可行性算法输入输出时间复杂度算法分析空间复杂度、计算机算法必须具备输入、输出、可行性、确定性、有穷性５个特性。

1 2、算法分析的两个主要方面是空间复杂度和时间复杂度。

3、数据元素是数据的基本单位。

4、数据项是数据的最小单位。

5、数据结构是带结构的数据元素的集合。

6、数据的存储结构包括顺序、链接、散列和索引四种基本类型。

线性表复习第二章定义逻辑关系：前趋后继节省空间基本特点随机存取插、删效率低顺序存储结构插入基本运算删除一个数据一个指针多占空特查找费插、删效率无法查找前趋结单链运算特点：单链表+前趋指针域链表存储双向结构链表插入运算删除特点：单链表的尾结点指针循环指向附加头结点。

链表运算：联接1 、一个指向后继结点的指针、在双链表中，每个结点有两个指针域，包括一个指向前驱结点的指针 2、线性表采用顺序存储，必须占用一片连续的存储单元、线性表采用链式存储，便于进行插入和删除操作3 、线性表采用顺序存储和链式存储优缺点比较。

4 5、简单算法复习栈和队列第三章．栈的概念：在一端操作的线性表LIFO栈的特点：先进后出存储结初始化push 进栈运算算法pop出栈队列概念：在两端操作的线性表FIFO队列特点：先进先出假溢出顺序队列front=rear队空：循环队列front=(rear+1)%MAXSIZE队满：队列front∧队空：链队列rear初始化判空顺序：进队基本运算链队：出队取队首元素1栈和队列的异同点。

、、2栈和队列的基本运算出栈和出队、3 、4基本运算复习串第四章．n(≥)个字符组成的有限序列1定义：由”c……cS=”cc n231串长度、空白串、空串。

数据结构期末复习要点(严蔚敏版)

数据结构期末复习要点第一章绪论1、掌握基本概念和术语，看教材P4—P6部分内容；2、看P10—P11关于类C的语法描述，算法设计写代码时可用到；3、掌握算法的特征（5个）和要求（5个）（P13—P14），能够结合具体算法分析算法的时间复杂度和空间复杂度（比如线性表的插入、删除操作，查找、排序等操作），理解O(n)、O(1)等时间复杂度的具体含义（P14—P17）。

第二章线性表1、看教材P21—P26，掌握有关线性表顺序存储的内容：（1）顺序表的随机存取（P21计算地址的公式）；（2）顺序表的表示（P22的Typedef）；（3）顺序表为空、为满的判定，插入和删除操作的特征以及时间复杂度的分析（P23—P25）；（4）有关顺序表的编程题。

2、看教材P27—P30，掌握有关线性表链式存储的内容：（1）单链表的表示（P28的Typedef）；（2）单链表为空的判定（带头结点、不带头结点）；（3）单链表插入、删除操作的特征（操作点的确定以和指针的修改）以及时间复杂度分析（P29—P30）；（4）有关单链表的编程。

3、为节约时间，循环链表、双向链表以及多项式加法可以不看；4、算法设计题要求写代码，在本章体现的可能性比较大。

第三章栈和队列1、顺序栈的表示，栈操作的特点以及为空、为满的判定（P46—P47）；2、栈的应用举例看个标题就足够了；3、链队列的表示以及入队、出队操作（P61—P62）；4、循环队列为空、为满的判定（P65的代码中）；5、离散事件模拟这节不用看；6、第四章只需要看P70就够了，掌握串的特点（元素受限），串长度、空串、串的位置、串相等几个概念即可。

第六章树和二叉树1、看教材P120，了解有关树的概念和术语；2、了解二叉树的链式存储结构（P127），掌握二叉树的性质（P123—P125），并会做题（参考课件或指导书相关内容）；3、掌握二叉树的各种遍历算法（P128—P129或课件）：（1）能够根据二叉树写出各种遍历序列；（2）能够由两种遍历序列（必须包含中序序列）恢复二叉树；（3）理解二叉树遍历算法的递归代码，能够读懂代码含义。

数据结构习题集答案（C语言版严蔚敏）第四章串

第四章串4.10void 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连接为新子前缀表达式cpush(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_nextLStrNode * 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; //作记录}}//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]){lpsS=lps1;lpsT=lps2;}else{lpsS=lps2;lpsT=lps1;} //将A,B上的位置映射回S,T上的位置printf("Longest Public Substring length:%d\n",maxlen);printf("Position in S:%d Position in T:%d\n",lpsS,lpsT);}//ifelse printf("No Repeating Substring found!\n");}//Get_LPubSub分析:本题基本思路与上题同.唯一的区别是,由于A,B互不相同,因此B不仅要向右错位,而且还要向左错位,以保证不漏掉一些情况.当B相对于A的位置不同时,需要匹配的区间的计算公式也各不相同,请读者自己画图以帮助理解.本算法的时间复杂度是o（strlrn（s）*strlen（t））。

数据结构(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

数据结构严蔚敏期末复习题

一．是非题（共分，每题分）1. 数据结构可用三元式表示（D，S，P）。

其中：D是数据对象，S是D上的关系，P是对D的基本操作集。

(f)2 简单地说,数据结构是带有结构的数据元素的集合。

(t)3 判断带头结点的非空循环单链表（头指针为L）中指针p所指结点是最后一个元素结点的条件是：p->next==L。

(t)4线性表的链式存储结构具有可直接存取表中任一元素的优点。

(f)5 线性表的顺序存储结构优于链式存储结构。

(f)6. 在单链表P指针所指结点之后插入S结点的操作是：P->next= S ; S-> next = P->next;。

(f)7 对于插入、删除而言，线性表的链式存储优于顺序存储。

(t)8. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。

(f)9. 栈和队列是操作上受限制的线性表。

(t)10. 栈和队列是与线性表完全不同的一种数据结构。

(f)11. 队列是一种操作受限的线性表，凡对数据元素的操作仅限一端进行。

(f)12. 栈和队列也是线性表。

如果需要，可对它们中的任一元素进行操作。

(f)13. 栈是限定仅在表头进行插入和表尾进行删除运算的线性表。

(f)14. 二叉树中每个结点有两个子结点，而对一般的树，则无此限制，所以，二叉树是树的特殊情形。

(f)15 二叉树是一棵结点的度最大为二的树。

(f)16 赫夫曼树中结点个数一定是奇数。

(t)17 在二叉树的中序遍历序列中，任意一个结点均处在其左孩子结点的后面。

(t)18 假设B是一棵树，B′是对应的二叉树。

则B的后根遍历相当于B′的后序遍历。

(f)19. 通常，二叉树的第i层上有2i-1个结点。

(f)20. 中序线索二叉树的优点是便于在中序下查找直接前驱结点和直接后继结点。

(t)21 二叉树的先序遍历序列中，任意一个结点均处在其孩子结点的前面。

(t)22 由树结点的先根序列和后根序列可以唯一地确定一棵树。

(t)23 邻接多重表可以用以表示无向图，也可用以表示有向图。

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

数据结构期末复习要点
第一章绪论
1、掌握基本概念和术语，看教材P4—P6部分内容；
2、看P10—P11关于类C的语法描述，算法设计写代码时可用到；
3、掌握算法的特征（5个）和要求（5个）（P13—P14），能够结合具体算法分析算法的时间复杂度和空间复杂度（比如线性表的插入、删除操作，查找、排序等操作），理解O(n)、O(1)等时间复杂度的具体含义（P14—P17）。

第二章线性表
1、看教材P21—P26，掌握有关线性表顺序存储的内容：
（1）顺序表的随机存取（P21计算地址的公式）；
（2）顺序表的表示（P22的Typedef）；
（3）顺序表为空、为满的判定，插入和删除操作的特征以及时间复杂度的分析（P23—P25）；
（4）有关顺序表的编程题。

2、看教材P27—P30，掌握有关线性表链式存储的内容：
（1）单链表的表示（P28的Typedef）；
（2）单链表为空的判定（带头结点、不带头结点）；
（3）单链表插入、删除操作的特征（操作点的确定以和指针的修改）以及时间复杂度分析（P29—P30）；（4）有关单链表的编程。

3、为节约时间，循环链表、双向链表以及多项式加法可以不看；
4、算法设计题要求写代码，在本章体现的可能性比较大。

第三章栈和队列
1、顺序栈的表示，栈操作的特点以及为空、为满的判定（P46—P47）；
2、栈的应用举例看个标题就足够了；
3、链队列的表示以及入队、出队操作（P61—P62）；
4、循环队列为空、为满的判定（P65的代码中）；
5、离散事件模拟这节不用看；
6、第四章只需要看P70就够了，掌握串的特点（元素受限），串长度、空串、串的位置、串相等几个概念即可。

第六章树和二叉树
1、看教材P120，了解有关树的概念和术语；
2、了解二叉树的链式存储结构（P127），掌握二叉树的性质（P123—P125），并会做题（参考课件或指导书相关内容）；
3、掌握二叉树的各种遍历算法（P128—P129或课件）：
（1）能够根据二叉树写出各种遍历序列；
（2）能够由两种遍历序列（必须包含中序序列）恢复二叉树；
（3）理解二叉树遍历算法的递归代码，能够读懂代码含义。

4、线索二叉树、树和森林的遍历略看即可，涉及不多；树与等价问题没讲不用看；
5、掌握Huffman树的相关内容（P144—P148）：
（1）给定字符及频率构造Huffman树，设计Huffman编码；
（2）掌握前缀编码的概念，能判定一组编码是否前缀编码。

6、回溯法和树的计数这两节不用看；
7、注意：要能够分析递归程序的执行结果（不局限于二叉树的递归算法）。

第七章图
1、看教材P157—P159，熟悉图的定义和术语；
2、看教材P161—P164，掌握图的邻接矩阵和邻接表两种存储结构：
（1）掌握存储结构的特点（是否对阵、求边数、求结点度等）；
（2）能够画出给定图的存储结构，或者根据存储结构画出图的逻辑结构；
（3）能够写出在两种存储结构上进行深度优先和广度优先遍历的序列；
（4）十字链表和邻接多重表不用看了。

3、看教材P173—P176，掌握构造最小生成树的Prim算法和Kruskal算法，能够按照考研指导书P199和P201所示的步骤构造最小生成树；
4、对于拓扑排序算法和关键路径算法，前者可能要求写出拓扑排序序列，后者无法以大题考查，略看即可；
5、知道求最短路径的两个算法的名称和能解决的问题即可，不必太费时间。

第九章查找
1、理解顺序查找的过程，分析索引顺序查找的性能，不用看静态树表查找；
2、看教材P218—P221，掌握折半查找算法：
（1）折半查找的前提；
（2）折半查找的过程；
（3）折半查找的判定树；
（4）折半查找的ASL。

3、掌握二叉排序树算法：
（1）BST的定义和构造（P227—P229）；
（2）BST的查找分析（P231）；
（3）平衡二叉树（A VL）的定义和BBST的判定（P233）。

4、了解B-树（P238—P239）和B+树（P246）的定义，不看键树；
5、掌握哈希表的构造和哈希查找的过程：
（1）哈希函数掌握“除留余数法”（P255）；
（2）冲突处理函数掌握“开放定址法”中的线性探测再散列和二次探测再散列（P257），能够将给定的关键字填入哈希表的适当位置；
（3）分析查找过程中关键字的比较次数。

第十章内部排序
1、看教材P263—P264，掌握学习排序算法的总体思路：
（1）算法思想（排序原则和排序过程）；
（2）算法性能（时间和空间复杂度）；
（3）算法稳定性（取决于算法本身）；
（4）算法的特殊性（适用前提、排序结果）；
（5）注意横向分析比较各种排序算法。

2、掌握直接插入排序的算法思想（读懂代码、模拟流程），能够进行性能分析（P265—P266）；
3、折半插入排序、2-路插入排序、表插入排序和希尔排序略看即可；
4、能够模拟起泡排序的执行过程，分析起泡排序的时间性能，把握起泡排序的结果特征（P273）；
5、看教材P273—P276，掌握快速排序的基本思想（选取枢轴，逆序交换，递归完成），分析快速排序的时间性能（最好、最坏），把握快速排序的适用场合（何时最佳），调整快速排序的执行环境（三者取中法）；
6、理解简单选择排序和树形选择排序的基本思想，重点掌握堆排序算法（P277——P282）：
（1）堆的定义（小顶堆和大顶堆）和堆排序（初始建堆+重建堆）；
（2）能够用完全二叉树的形式完成初始建堆和重建堆（筛选）；
（3）明确何时创建什么样的堆（降序创建小顶堆，升序创建大顶堆）；
（4）分析堆排序的特点和性能。

7、理解归并排序的特点和性能（稳定的、先进的）（P283—P284）；
8、了解基数排序的基本思想（以“分配”和“收集”代替关键字的比较），分析基数排序的性能（P286—P287）。