数据结构串和数组的习题答案

合集下载

数据结构课后习题及答案

填空题（10 ＊1’ = 10' ）一、概念题2。

2.当对一个线性表经常进行的是插入和删除操作时，采用链式存储结构为宜。

2。

3。

当对一个线性表经常进行的是存取操作，而很少进行插入和删除操作时，最好采用顺序存储结构。

2。

6。

带头结点的单链表L中只有一个元素结点的条件是L—〉Next->Next==Null。

3。

6。

循环队列的引入,目的是为了克服假溢出.4。

2。

长度为0的字符串称为空串。

4。

5.组成串的数据元素只能是字符。

4。

8.设T和P是两个给定的串，在T中寻找等于P的子串的过程称为模式匹配，又称P为模式。

7.2。

为了实现图的广度优先搜索，除一个标志数组标志已访问的图的结点外，还需要队列存放被访问的结点实现遍历。

5.7。

广义表的深度是广义表中括号的重数7。

8.有向图G可拓扑排序的判别条件是有无回路。

7.9。

若要求一个稠密图的最小生成树，最好用Prim算法求解。

8。

8.直接定址法法构造的哈希函数肯定不会发生冲突。

9。

2。

排序算法所花费的时间，通常用在数据的比较和交换两大操作。

1。

通常从正确性﹑可读性﹑健壮性﹑时空效率等几个方面评价算法的（包括程序）的质量。

1。

2.对于给定的n元素，可以构造出的逻辑结构有集合关系﹑线性关系树形关系﹑图状关系四种。

1。

3。

存储结构主要有顺序存储﹑链式存储﹑索引存储﹑散列存储四种。

1。

4。

抽象数据类型的定义仅取决于它的一组逻辑特性,而与存储结构无关，即不论其内部结构如何变化，只要它的数学特性不变,都不影响其外部使用。

1。

5.一个算法具有五大特性:有穷性﹑确定性﹑可行性，有零个或多个输入﹑有一个或多个输入。

2.8.在双向链表结构中，若要求在p指针所指的结点之前插入指针为s所指的结点,则需执行下列语句:s—〉prior= p—〉prior; s-〉next= p; p-〉prior- next= s；p-〉prior= s；。

2.9。

在单链表中设置头结点的作用是不管单链表是否为空表，头结点的指针均不空,并使得对单链表的操作（如插入和删除)在各种情况下统一。

数据结构习题及答案

第一章概论一、填空题1. 数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和运算等的学科。

2. 数据结构被形式地定义为（D, R ），其中D 是数据元素的有限集合，R 是D 上的关系有限集合。

3. 数据结构包括数据的逻辑结构、数据的存储结构和数据的运算这三个方面的内容。

4. 数据结构按逻辑结构可分为两大类，它们分别是线性结构和非线性结构。

5. 线性结构中元素之间存在一对一关系，树形结构中元素之间存在一对多关系，图形结构中元素之间存在多对多关系。

6．在线性结构中，第一个结点没有前驱结点，其余每个结点有且只有 1个前驱结点；最后一个结点没有后续结点，其余每个结点有且只有1个后续结点。

7. 在树形结构中，树根结点没有前驱结点，其余每个结点有且只有 1 个前驱结点；叶子结点没有后续结点，其余每个结点的后续结点数可以任意多个。

8. 在图形结构中，每个结点的前驱结点数和后续结点数可以任意多个。

9．数据的存储结构可用四种基本的存储方法表示，它们分别是顺序、链式、索引和散列。

10. 数据的运算最常用的有5种，它们分别是插入、删除、修改、查找、排序。

11. 一个算法的效率可分为时间效率和空间效率。

二、单项选择题（ B ）1. 非线性结构是数据元素之间存在一种：A ）一对多关系B ）多对多关系C ）多对一关系D ）一对一关系（ C ）2. 数据结构中，与所使用的计算机无关的是数据的结构；A) 存储 B) 物理 C) 逻辑 D) 物理和存储（ C ）3. 算法分析的目的是：A) 找出数据结构的合理性 B) 研究算法中的输入和输出的关系C) 分析算法的效率以求改进 D) 分析算法的易懂性和文档性（ A ）4. 算法分析的两个主要方面是：A) 空间复杂性和时间复杂性 B) 正确性和简明性C) 可读性和文档性 D) 数据复杂性和程序复杂性（ C ）5. 计算机算法指的是：A) 计算方法 B) 排序方法 C) 解决问题的有限运算序列 D) 调度方法（ B ）6. 计算机算法必须具备输入、输出和等5个特性。

数据结构习题集答案（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））。

数据结构（第二版）习题谜底第4章[基础]

数据结构(第二版)习题答案第4章第4章字符串、数组和特殊矩阵4.1稀疏矩阵常用的压缩存储方法有（三元组顺序存储）和（十字链表）两种。

4.2设有一个10 × 10的对称矩阵 A采用压缩方式进行存储，存储时以按行优先的顺序存储其下三角阵，假设其起始元素 a00的地址为 1，每个数据元素占 2个字节，则 a65的地址为（ 53 ）。

4.3若串S =“software”，其子串的数目为（ 36 ）。

4.4常对数组进行的两种基本操作为（访问数据元素）和（修改数组元素）。

4.5 要计算一个数组所占空间的大小，必须已知（数组各维数）和（每个元素占用的空间）。

4.6对于半带宽为 b的带状矩阵，它的特点是：对于矩阵元素 aij，若它满足（|i-j|>b），则 aij = 0。

4.7字符串是一种特殊的线性表，其特殊性体现在（该线性表的元素类型为字符）。

4.8试编写一个函数，实现在顺序存储方式下字符串的 strcompare （S1，S2）运算。

【答】：#include <stdio.h>#include <string.h>#define MAXSIZE 100typedef struct{char str[MAXSIZE];int length;}seqstring;/* 函数 strcompare()的功能是：当 s1>s2时返回 1，当 s1==s2时返回 0，当 s1<s2时返回-1*/int strcompare(seqstring s1,seqstring s2){ int i,m=0,len;len=s1.length<s2.length ?s1.length:s2.length;for(i=0;i<=len;i++)if(s1.str[i]>s2.str[i]){m=1;break;}else if(s1.str[i]<s2.str[i]){m=-1;break;}return m;}int main(){ seqstring s1,s2;int i,m;printf("input char to s1:\n");gets(s1.str);s1.length=strlen(s1.str);printf("input char to s2:\n");gets(s2.str);s2.length=strlen(s2.str);m=strcompare(s1,s2);if(m==1) printf("s1>s2\n");else if(m==-1) printf("s2>s1\n");else if(m==0) printf("s1=s2\n");}4.9试编写一个函数，实现在顺序存储方式下字符串的replace（S，T1，T2）运算。

数据结构习题与答案

第 1 章绪论课后习题讲解1. 填空⑴（）是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

【解答】数据元素⑵（）是数据的最小单位，（）是讨论数据结构时涉及的最小数据单位。

【解答】数据项，数据元素【分析】数据结构指的是数据元素以及数据元素之间的关系。

⑶从逻辑关系上讲，数据结构主要分为（）、（）、（）和（）。

【解答】集合，线性结构，树结构，图结构⑷数据的存储结构主要有（）和（）两种基本方法，不论哪种存储结构，都要存储两方面的内容：（）和（）。

【解答】顺序存储结构，链接存储结构，数据元素，数据元素之间的关系⑸算法具有五个特性，分别是（）、（）、（）、（）、（）。

【解答】有零个或多个输入，有一个或多个输出，有穷性，确定性，可行性⑹算法的描述方法通常有（）、（）、（）和（）四种，其中，（）被称为算法语言。

【解答】自然语言，程序设计语言，流程图，伪代码，伪代码⑺在一般情况下，一个算法的时间复杂度是（）的函数。

【解答】问题规模⑻设待处理问题的规模为n，若一个算法的时间复杂度为一个常数，则表示成数量级的形式为（），若为n*log25n，则表示成数量级的形式为（）。

【解答】Ο(1)，Ο(nlog2n)【分析】用大O记号表示算法的时间复杂度，需要将低次幂去掉，将最高次幂的系数去掉。

2. 选择题⑴顺序存储结构中数据元素之间的逻辑关系是由（）表示的，链接存储结构中的数据元素之间的逻辑关系是由（）表示的。

A 线性结构B 非线性结构C 存储位置D 指针【解答】C，D【分析】顺序存储结构就是用一维数组存储数据结构中的数据元素，其逻辑关系由存储位置（即元素在数组中的下标）表示；链接存储结构中一个数据元素对应链表中的一个结点，元素之间的逻辑关系由结点中的指针表示。

⑵假设有如下遗产继承规则：丈夫和妻子可以相互继承遗产；子女可以继承父亲或母亲的遗产；子女间不能相互继承。

则表示该遗产继承关系的最合适的数据结构应该是（）。

数据结构(c语言版)课后习题答案完整版

Push( &s, t[i]);
while( !EmptyStack( &s))
{// 每弹出一个字符与相应字符比较
temp=Pop (&s);
if( temp!=S[i]) return 0 ;// 不等则返回0
else i++;
}
return 1 ; // 比较完毕均相等则返回 1
}
（7）假设以数组Q[m]存放循环队列中的元素,同时设置一个标志tag，以tag==0和tag ==1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
t串
a b c a a b b a b c a b
next[j]
0 1 1 1 2 2 3 1 2 3 4 5
nextval[j]
0 1 1 0 2 1 3 0 1 1 0 5
（3）数组A中，每个元素A[i,j]的长度均为32个二进位,行下标从-1到9，列下标从1到11，从首地址S开始连续存放主存储器中，主存储器字长为16位。求：
（5）因为x++共执行了n-1+n-2+……＋1= n(n-1)/2，所以执行时间为O（n2）
（6）O( )
第
1．选择题
babadbcabdcddac
2．算法设计题
（6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。
ElemType Max (LinkList L ){
if(L->next==NULL) return NULL;
rear=(rear+ 1 ) %m;//队尾位置进1,队尾指针指示实际队尾位置

数据结构习题(有答案)

if (elem[i-1]= =e) //找到，进行删除操作
{ for ( j=i; j<length; j++) // ai至an依次前移
Elem[j-1] = elem[j];
length - - ; //表长减一
return 1 ; //删除成功，返回1
}
return 0 ; //未找到，删除不成功，返回0
要求：给出问题分析、算法描述、源程序及运行截图，在线提交。
1.设a, b, c为3个整数，求其中位于中间值的整数。
1.设计算法：在顺序表中删除值为e的元素，删除成功，返回1；否则，返回0。
int Sqlist<T>::DeleteElem( T e )
{ for (i=1; i<=length; i++) //按值顺序查找* i可从0开始
(2)借助栈T，将栈S中所有值为e的数据元素删除之。
3.编写一个算法，将一个非负的十进制整数N转换为B进制数，并输出转换后的结果。当N=248D，B分别为8和16时，转换后的结果为多少？
#include“stack.h”
int NumTrans( int N, int B) {//十进制整数N转换为B进制数
if ( head==NULL) throw“表空!”; //空表，不能删
else if ( i==1) { //删除第1个元素
p=Head; x=p->data; //保存被删元素值
Head= p->next ;
delete p ;
}
else { //元素定位到第ai-1
p=Head; j=1 ; //定位查找起始位置
{ int p=1;

数据结构答案(耿国华)

数据结构
SubString(sub2,s,7,1)= 空格
StrIndex(s,’A’,4)= 6 StrReplace(s,’STUDENT’,q)= I AM A WORKER
StrCat(StrCat(sub1,t),StrCat(sub2,q)) = I AM A GOOD WORKER
B
C A
先：ABC 中：CBA 后：CBA
A
B C
先：ABC 中：BAC 后：BCA
6
A
先：ABC B 中：ACB 后：CBA
B C
C
先：ABC 中：ABC 后：CBA
第6章树和二叉树习题
3.已知一棵度为k的树中有n1个度为1的结点，n2个度为2的结点，…nk个度为k的结点，则该树中有多少个叶子结点，并证明之。
3）前序和后序相同空树、只有一个结点的树
9
第6章树和二叉树习题
数据结构
补充：写出下面二叉树的前序、中序、后序遍历序列先序序列： A ABCDEFGHIJ E B 中序序列： G C F BCDAFEHJIG D H I J 后序序列： DCBFJIHGEA
10
第6章树和二叉树习题
13
解：设n为总结点数，则有
数据结构
(总结点数) n=n0+n1+n2+…nk (总边数) n-1=1*n1+2*n2+…k*nk 两式相减得：1=n0-n2-2n3-…-(k-1)nk n0=1+n2+2n3+…+(k-1)nk =1+∑(i-1)ni
i=1
7
k
第6章树和二叉树习题
4.假设一棵二叉树的先序序列和中序序列，试画出该二叉树，并写出后序遍历序列。

数据结构(C语言版)第三版习题答案

精神成就事业，态度决定一切。

附录习题参考答案习题1参考答案1.1.选择题(1). A. (2). A. (3). A. (4). B.C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A.1.2.填空题(1). 数据关系(2). 逻辑结构物理结构(3). 线性数据结构树型结构图结构(4). 顺序存储链式存储索引存储散列表（Hash）存储(5). 变量的取值范围操作的类别(6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系(7). 关系网状结构树结构(8). 空间复杂度和时间复杂度(9). 空间时间(10). Ο(n)1.3 名词解释如下：数据：数据是信息的载体是计算机程序加工和处理的对象包括数值数据和非数值数据数据项：数据项指不可分割的、具有独立意义的最小数据单位数据项有时也称为字段或域数据元素：数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理一个数据元素可由若干个数据项组成数据逻辑结构：数据的逻辑结构就是指数据元素间的关系数据存储结构：数据的物理结构表示数据元素的存储方式或者数据元素的物理关系数据类型：是指变量的取值范围和所能够进行的操作的总和算法：是对特定问题求解步骤的一种描述是指令的有限序列1.4 语句的时间复杂度为：(1) Ο(n2)(2) Ο(n2)(3) Ο(n2)(4) Ο(n-1)(5) Ο(n3)1.5 参考程序：main(){int XYZ；scanf("%d %d%d"&X&YZ)；if (X>=Y)if(X>=Z)if (Y>=Z) { printf("%d %d%d"XYZ);}else{ printf("%d %d%d"XZY);}else{ printf("%d %d%d"ZXY);}else if(Z>=X)if (Y>=Z) { printf("%d %d%d"YZX);}else{ printf("%d%d%d"ZYX);}else{ printf("%d%d%d"YXZ);}}1.6 参考程序：main(){int in;float xa[]p;printf("\nn=");scanf("%f"&n);printf("\nx=");scanf("%f"&x);for(i=0;i<=n;i++)scanf("%f "&a[i]);p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x;x=x*x;}printf("%f"p)'}习题2参考答案2.1选择题(1). C. (2). B. (3). B. (4). B. 5. D. 6. B. 7. B. 8. A. 9. A. 10. D.2.2.填空题(1). 有限序列(2). 顺序存储和链式存储(3). Ｏ(n) O(n)(4). n-i+1 n-i(5). 链式(6). 数据指针(7). 前驱后继(8). Ο(1) Ο(n)(9). s->next=p->next; p->next=s ;(10). s->next2.3. 解题思路：将顺序表A中的元素输入数组a若数组a中元素个数为n将下标为012...（n-1）/2的元素依次与下标为nn-1...（n-1）/2的元素交换输出数组a的元素参考程序如下：main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<=n-1;i++)scanf("%f "&a[i]);for(i=0;i<=(n-1)/2;i++){ t=a[i]; a[i] =a[n-1-i]; a[n-1-i]=t;} for(i=0;i<=n-1;i++)printf("%f"a[i]);}2.4 算法与程序：main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]);for(i=1;i<n;i++)if(a[i]>a[0]{ t=a[i]; a[i] =a[0]; a[0]=t;}printf("%f"a[0]);for(i=2;i<n;i++)if(a[i]>a[1]{ t=a[i]; a[i] =a[1]; a[1]=t;}printf("%f"a[0]);}2.5 算法与程序：main(){int ijkn;float xta[];printf("\nx=");scanf("%f"&x);printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]); // 输入线性表中的元素for (i=0; i<n; i++) { // 对线性表中的元素递增排序k=i;for (j=i+1; j<n; j++) if (a[j]<a[k]) k=j; if (k<>j) {t=a[i];a[i]=a[k];a[k]=t;}}for(i=0;i<n;i++) // 在线性表中找到合适的位置if(a[i]>x) break;for(k=n-1;k>=i;i--) // 移动线性表中元素然后插入元素xa[k+1]=a[k];a[i]=x;for(i=0;i<=n;i++) // 依次输出线性表中的元素printf("%f"a[i]);}2.6 算法思路：依次扫描A和B的元素比较A、B当前的元素的值将较小值的元素赋给C如此直到一个线性表扫描完毕最后将未扫描完顺序表中的余下部分赋给C即可C的容量要能够容纳A、B两个线性表相加的长度有序表的合并算法：void merge (SeqList ASeqList BSeqList *C){ int ijk；i=0；j=0；k=0；while ( i<=st && j<=st )if (A.data[i]<=B.data[j])C->data[k++]=A.data[i++]；elseC->data[k++]=B.data[j++]；while (i<=st )C->data[k++]= A.data[i++]；while (j<=st )C->data[k++]=B.data[j++]；C->last=k-1；}2.7 算法思路：依次将A中的元素和B的元素比较将值相等的元素赋给C如此直到线性表扫描完毕线性表C就是所求递增有序线性表算法：void merge (SeqList ASeqList BSeqList *C){ int ijk；i=0；j=0；k=0；while ( i<=st)while（j<=st )if (A.data[i]=B.data[j])C->data[k++]=A.data[i++]；C->last=k-1；}习题3参考答案3.1.选择题(1). D (2). C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).AB (11). D (12). B (13). D (14). C (15). C (16). D(17). D (18). C (19). C (20). C 3.2.填空题（1） FILOFIFO（2） -13 4 X * + 2 Y * 3 / -（3） stack.topstack.s[stack.top]=x（4） p>llink->rlink=p->rlinkp->rlink->llink=p->rlink（5） (R-F+M)%M（6） top1+1=top2（7） F==R（8） front==rear（9） front==(rear+1)%n（10） N-13.3 答：一般线性表使用数组来表示的线性表一般有插入、删除、读取等对于任意元素的操作而栈只是一种特殊的线性表栈只能在线性表的一端插入（称为入栈push）或者读取栈顶元素或者称为"弹出、出栈"(pop)3.4 答：相同点：栈和队列都是特殊的线性表只在端点处进行插入删除操作不同点：栈只在一端（栈顶）进行插入删除操作；队列在一端（top）删除一端(rear)插入3.5 答：可能序列有14种：ABCD; ACBD; ACDB; ABDC; ADCB; BACD; BADC; BCAD; BCDA; BDCA; CBAD; CBDA; CDBA; DCBA3.6 答：不能得到435612最先出栈的是4则按321的方式出不可能得到1在2前的序列可以得到135426按如下方式进行push(1)pop()push(2)push(3)pop()push(4)push(5)pop()pop()pop()push(6)pop()3.7 答：stack3.8 非递归:int vonvert (int noint a[]) //将十进制数转换为2进制存放在a[] 并返回位数{int r;SeStack s*p;P=&s;Init_stack(p);while(no){push(pno%2);no/=10;}r=0;while(!empty_stack(p)){pop(pa+r);r++;}return r;}递归算法:void convert(int no){if(no/2>0){Convert(no/2);Printf("%d"no%2);}elseprintf("%d"no);}3.9 参考程序：void view(SeStack s){SeStack *p; //假设栈元素为字符型char c;p=&s;while(!empty_stack(p)){c=pop(p);printf("%c"c);}printf("\n");}3.10 答：char3.11 参考程序：void out(linkqueue q){int e;while(q.rear !=q.front ){dequeue(qe);print(e); //打印}}习题4参考答案4.1 选择题：(1). A (2). D (3). C (4). C (5). B (6). B (7). D (8). A (9). B (10). D 4.2 填空题：（1）串长相等且对应位置字符相等（2）不含任何元素的串（3）所含字符均是空格所含空格数（4） 10（5） "hello boy"（6） 13（7） 1066（8）模式匹配（9）串中所含不同字符的个数（10） 364.3 StrLength (s)=14StrLength (t)=4SubStr( s87)=" STUDENT"SubStr(t21)="O"StrIndex(s"A")=3StrIndex (st)=0StrRep(s"STUDENT"q)=" I AM A WORKER"4.4 StrRep(s"Y""+");StrRep(s"+*""*Y");4.5 空串：不含任何字符；空格串：所含字符都是空格串变量和串常量:串常量在程序的执行过程中只能引用不能改变；串变量的值在程序执行过程中是可以改变和重新赋值的主串与子串：子串是主串的一个子集串变量的名字与串变量的值:串变量的名字表示串值的标识符4.6int EQUAl(ST){char *p*q;p=&S;q=&T;while(*p&&*q){if(*p!=*q)return *p-*q;p++;q++;}return *p-*q;}4.7(1)6*8*6=288(2)1000+47*6=1282(3)1000+(8+4)*8=1096(4)1000+(6*7+4)*8=13684.8习题5参考答案5.1 选择（1）C（2）B（3）C（4）B（5）C（6）D（7）C（8）C（9）B（10）C （11）B（12）C（13）C（14）C（15）C（16）B5.2 填空（1）1（2）1036；1040（3）2i（4） 1 ； n ; n-1 ; 2（5）2k-1；2k-1（6）ACDBGJKIHFE（7）p!=NULL（8）Huffman树（9）其第一个孩子; 下一个兄弟（10）先序遍历；中序遍历5.3叶子结点:C、F、G、L、I、M、K；非终端结点：A、B、D、E、J；各结点的度：结点： A B C D E F G L I J K M度： 4 3 0 1 2 0 0 0 0 1 0 0树深：4无序树形态如下：二叉树形态如下：5.5二叉链表如下:三叉链表如下:5.6先序遍历序列:ABDEHICFJG中序遍历序列:DBHEIAFJCG后序遍历序列:DHIEBJFGCA5.7(1) 先序序列和中序序列相同：空树或缺左子树的单支树；(2) 后序序列和中序序列相同：空树或缺右子树的单支树；(3) 先序序列和后序序列相同：空树或只有根结点的二叉树5.8这棵二叉树为:先根遍历序列:ABFGLCDIEJMK后根遍历序列:FGLBCIDMJKEA层次遍历序列:ABCDEFGLIJKM5.10证明：设树中结点总数为n叶子结点数为n0则n=n0 + n1 + ...... + nm （1）再设树中分支数目为B则B=n1 + 2n2 + 3n3 + ...... + m nm （2）因为除根结点外每个结点均对应一个进入它的分支所以有n= B + 1 （3）将（1）和（2）代入（3）得n0 + n1 + ...... + nm = n1 + 2n2 + 3n3 + ...... + m nm + 1 从而可得叶子结点数为：n0 = n2 + 2n3 + ...... + (m-1)nm + 15.11由5.10结论得n0 = (k-1)nk + 1又由 n=n0 + nk得nk= n-n0代入上式得n0 = (k-1)（n-n0）+ 1叶子结点数为：n0 = n (k-1) / k5.12int NodeCount(BiTree T){ //计算结点总数if(T)if (T-> lchild==NULL )&&( T --> rchild==NULL )return 1;elsereturn NodeCount(T-> lchild ) +Node ( T --> rchild )+1; elsereturn 0;}void ExchangeLR(Bitree bt){/* 将bt所指二叉树中所有结点的左、右子树相互交换 */ if (bt && (bt->lchild || bt->rchild)) {bt->lchild<->bt->rchild;Exchange-lr(bt->lchild);Exchange-lr(bt->rchild);}}/* ExchangeLR */5.14int IsFullBitree(Bitree T){/* 是则返回1否则返回0*/Init_Queue(Q); /* 初始化队列*/flag=0;In_Queue(QT); /* 根指针入队列按层次遍历*/while(!Empty_Queue (Q)){Out_Queue(Qp);if(!p) flag=1; /* 若本次出队列的是空指针时则修改flag值为1若以后出队列的指针存在非空则可断定不是完全二叉树 */else if (flag) return 0; /*断定不是完全二叉树 */ else{In_Queue(Qp->lchild);In_Queue(Qp->rchild); /* 不管孩子是否为空都入队列*/}}/* while */return 1; /* 只有从某个孩子指针开始之后所有孩子指针都为空才可断定为完全二叉树*/}/* IsFullBitree */转换的二叉树为：5.16对应的森林分别为：5.17typedef char elemtype;typedef struct{ elemtype data;int parent;} NodeType;(1) 求树中结点双亲的算法:int Parent(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标(根的双亲为-1 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) return t[i].parent; return -2;}/*Parent*/(2) 求树中结点孩子的算法:void Children(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++){if(x==t[i].data)break;/*找到x退出循环*/}/*for*/if(i>=MAXNODE) printf("x不存在\n"); else {flag=0;for(j=0;j<MAXNODE;j++)if(i==t[j].parent){ printf("x的孩子:%c\n"t[j].data);flag=1;}if(flag==0) printf("x无孩子\n");}/*Children*/5.18typedef char elemtype;typedef struct ChildNode{ int childcode;struct ChildNode *nextchild;}typedef struct{ elemtype data;struct ChildNode *firstchild;} NodeType;(1) 求树中结点双亲的算法:int ParentCL(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) {loc=i;/*记下x的下标*/break;}if(i>=MAXNODE) return -2; /* x不存在 *//*搜索x的双亲*/for(i=0;i<MAXNODE;i++)for(p=t[i].firstchild;p!=NULL;p=p->nextchild) if(loc==p->childcode)return i; /*返回x结点的双亲下标*/}/* ParentL */(2) 求树中结点孩子的算法:void ChildrenCL(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++)if(x==t[i].data) /*依次打印x的孩子*/{flag=0; /* x存在 */for(p=t[i].firstchild;p;p=p->nextchild){ printf("x的孩子:%c\n"t[p-> childcode].data);flag=1;}if(flag==0) printf("x无孩子\n");return;}/*if*/printf("x不存在\n");return;}/* ChildrenL */5.19typedef char elemtype;typedef struct TreeNode{ elemtype data;struct TreeNode *firstchild; struct TreeNode *nextsibling; } NodeType;void ChildrenCSL(NodeType *telemtype x){ /* 层次遍历方法 */Init_Queue(Q); /* 初始化队列 */In_Queue(Qt);count=0;while(!Empty_Queue (Q)){Out_Queue(Qp);if(p->data==x){ /*输出x的孩子*/p=p->firstchild;if(!p) printf("无孩子\n");else{ printf("x的第%i个孩子:%c\n"++countp->data);/*输出第一个孩子*/p=p->nextsibling; /*沿右分支*/while(p){printf("x的第%i个孩子:%c\n"++countp->data);p=p-> nextsibling;}}return;}if(p-> firstchild) In_Queue(Qp-> firstchild);if(p-> nextsibling) In_Queue(Qp-> nextsibling);}}/* ChildrenCSL */5.20(1) 哈夫曼树为:(2) 在上述哈夫曼树的每个左分支上标以1右分支上标以0并设这7个字母分别为A、B、C、D、E、F和H如下图所示：则它们的哈夫曼树为分别为:A：1100B：1101C：10D：011E：00F：010H：111习题6参考答案6.1 选择题（1）C （2）A （3）B（4）C（5）B______条边（6）B（7）A（8）A（9）B（10）A（11）A（12）A（13）B（14）A（15）B（16）A（17）C 6.2 填空（1） 4（2） 1对多 ; 多对多（3） n-1 ; n（4） 0_（5）有向图（6） 1（7）一半（8）一半（9）___第i个链表中边表结点数___（10）___第i个链表中边表结点数___（11）深度优先遍历；广度优先遍历（12）O（n2）（13）___无回路6.3（1）邻接矩阵:（2）邻接链表：（3）每个顶点的度：顶点度V1 3V2 3V3 2V4 3V5 36.4（1）邻接链表：（2）逆邻接链表：（3）顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5（1）深度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 （1）广度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量：6.7顶点（1）（2）（3）（4）（5）Low Close Cost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexV10 00 00 00 00 0V21 00 00 00 00 0V31 01 00 00 00 0V43 02 12 10 10 1V5∞ 05 13 22 30 3U{v1} {v1v2} {v1v2v3} {v1 v2 v3 v4} {v1 v2 v3 v4 v5} T {} { (v1 v2) } {(v1 v2) (v1 v3) } {(v1 v2) (v1 v3) (v2 v4) } {(v1 v2) (v1v3)(v2v4)(v4v5) }最小生成树的示意图如下：6.8拓扑排序结果： V3--> V1 --> V4 --> V5 --> V2 --> V66.9（1）建立无向图邻接矩阵算法：提示：参见算法6.1因为无向图的邻接矩阵是对称的所以有for (k=0; k<G ->e; k++) /*输入e条边建立无向图邻接矩阵*/{ scanf("\n%d%d"&i&j);G ->edges[i][j]= G ->edges[j][i]=1;}(2)建立无向网邻接矩阵算法:提示：参见算法6.1初始化邻接矩阵：#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息：不仅要输入边邻接的两个顶点序号还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边建立无向网邻接矩阵*/{ scanf("\n%d%d%d"&i&j&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示：参见算法6.16.10(1)建立无向图邻接链表算法：typedef VertexType char;int Create_NgAdjList(ALGraph *G){ /* 输入无向图的顶点数、边数、顶点信息和边的信息建立邻接表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*边数不能为负 */G->e=e;for(m=0;m< G->n ;m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e; m++){scanf("\n%d%d"&i&j); /* 输入一对邻接顶点序号*/if((i<0 || j<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/ p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/ p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;} /* for*/return 0; /*成功*/}//Create_NgAdjList(2)建立有向图逆邻接链表算法：typedef VertexType char;int Create_AdjList(ALGraph *G){ /* 输入有向图的顶点数、边数、顶点信息和边的信息建立逆邻接链表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*弧数不能为负 */G->e=e;for(m=0;m< G->n; m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e ; m++){scanf("\n%d%d"&t&h); /* 输入弧尾和弧头序号*/if((t<0 || h<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第h+1个链表中插入一个边表结点*/ p->adjvex=t;p->next= G-> adjlist [h].firstedge;G-> adjlist [h].firstedge=p;} /* for*/return 0; /*成功*/}//Create_AdjList6.11void Create_AdjM(ALGraph *G1MGraph *G2){ /*通过无向图的邻接链表G1生成无向图的邻接矩阵G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G2->n;i++) /* 置G2每个元素为0 */for(j=0;j<G2->n;j++) G2->edges[i][j]= 0;for(m=0;m< G1->n;m++)G2->vexs[m]=G1->adjlist[m].vertex; /*复制顶点信息*/num=（G1->n/2==0?G1->n/2:G1->n/2+1）; /*只要搜索前n/2个单链表即可*/for(m=0;m< num;m++){ p=G1->adjlist[m].firstedge;while(p){ /* 无向图的存储具有对称性*/G2->edges[m][ p->adjvex ]= G2->edges[p->adjvex ] [m] =1;p==p->next;}}/* for */}/*Create_AdjM */void Create_AdjL(ALGraph *G1MGraph *G2){ /*通过无向图的邻接矩阵G1生成无向图的邻接链表G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G1->n;i++) /* 建立每个单链表 */{ G2->vexs[i]=G1->adjlist[i].vertex;G2->adjlist[i].firstedge=NULL；for(j=i; j<G1->n; j++) /*对称矩阵只要搜索主对角以上的元素即可*/{ if(G1->edges[i][j]== 1){ p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;}/*if*/}/* for*/}/* for*/}/* Create_AdjL */6.13(1) 邻接矩阵中1的个数的一半;(2) 若位于[i-1j-1]或[j-1i-1]位置的元素值等于1则有边相连否则没有(3) 顶点i的度等于第i-1行中或第i-1列中1的个数6.14(1) 邻接链表中边表结点的个数的一半;(2) 若第i-1（或j-1）个单链表中存在adjvex域值等于j-1（或i-1）的边表结点则有边相连否则没有(3) 顶点i的度等于第i-1个单链表中边表结点的个数提示：参见算法6.2 和6.3习题 7参考答案7.1 选择题（1）C (2)C (3) C (4)B (5) A (6)A (7) D (8)B (9)D (10) B(11)B (12)A (13)C (14)C (15)A (16)D (17)C (18)BC (19)B (20)A7.2 填空题（1） O(n)O(log2n)（2） 12485log2(n+1)-1（3）小于大于（4）增序序列（5）m-1（6） 70; 342055（7） n/m（8）开放地址法链地址法（9）产生冲突的可能性就越大产生冲突的可能性就越小（10）关键码直接（11）②①⑦（12） 1616821（13）直接定址法数字分析法平方取中法折叠法除留余数法随机数法（14）开放地址法再哈希法链地址法建立一个公共溢出区（15）装满程度（16）索引快（17）哈希函数装填因子（18）一个结点（19）中序（20）等于7.3 一棵二叉排序树(又称二叉查找树)或者是一棵空树或者是一棵同时满足下列条件的二叉树：(1)若它的左子树不空则左子树上所有结点的键值均小于它根结点键值(2)若它的右子树不空则右子树上所有结点的键值均大于它根结点键值(3)它的左、右子树也分别为二叉排序树7.4 对地址单元d=H(K)如发生冲突以d为中心在左右两边交替进行探测按照二次探测法键值K的散列地址序列为：do=H(K)d1=(d0+12)mod md2=(d0-12)mod md3=(d0+22)mod md4=(d0-12)mod m......7.5 衡量算法的标准有很多时间复杂度只是其中之一尽管有些算法时间性能很好但是其他方面可能就存在着不足比如散列查找的时间性能很优越但是需要关注如何合理地构造散列函数问题而且总存在着冲突等现象为了解决冲突还得采用其他方法二分查找也是有代价的因为事先必须对整个查找区间进行排序而排序也是费时的所以常应用于频繁查找的场合对于顺序查找尽管效率不高但却比较简单常用于查找范围较小或偶而进行查找的情况7.6此法要求设立多个散列函数Hii=1...k当给定值K与闭散列表中的某个键值是相对于某个散列函数Hi的同义词因而发生冲突时继续计算该给定值K在下一个散列函数Hi+1下的散列地址直到不再产生冲突为止7.7散列表由两个一维数组组成一个称为基本表另一个称为溢出表插入首先在基本表上进行；假如发生冲突则将同义词存人溢出表7.8 结点个数为n时高度最小的树的高度为1有两层它有n-1个叶结点1个分支结点；高度最大的树的高度为n-l有n层它有1个叶结点n-1个分支结点7.9 设顺序查找以h为表头指针的有序链表若查找成功则返回结点指针p查找失败则返回null值pointer sqesrearch(pointer hint xpointerp){p=null；while(h)if(x>h->key)h=h->link；else{if(x==h->key)p=h；return(p)；}}虽然链表中的结点是按从小到大的顺序排列的但是其存储结构为单链表查找结点时只能从头指针开始逐步进行搜索故不能用折半(二分)查找7.10 分析：对二叉排序树来讲其中根遍历序列为一个递增有序序列因此对给定的二叉树进行中根遍历如果始终能保证前一个值比后一个值小则说明该二叉树是二叉排序树int bsbtr (bitreptr T) ／*predt记录当前结点前趋值初值为-∞*／{ if (T==NULL) return(1)；else{b1=bsbtr(T->lchild)；／*判断左子树*／if (!b1|| (predt>=T->data)) return(0)；*当前结点和前趋比较*／ predt=T->data；／*修改当前结点的前趋值*／return(bsbtr(T->rchild))；／*判断右子树并返回最终结果*／}}7.11 (1)使用线性探查再散列法来构造散列表如表下所示散列表───────────────────────────────地址 0 1 2 3 4 5 6 7 8 9 10───────────────────────────────数据 33 1 13 12 34 38 27 22───────────────────────────────（2）使用链地址法来构造散列表如下图(3)装填因子a=8／11使用线性探查再散列法查找成功所需的平均查找次数为Snl=0．5(1+1／(1-a))=0．5*(1+1／(1-8／11))=7／3使用线性探查再散列法查找不成功所需的平均查找次数为：Unl=0．5(1+1／(1-a)2)=0．5*(1+1／(1-8／11)2)=65／9 使用链地址法查找成功所需的平均查找次数为：Snc=l+a／2=1+8／22=15／11使用链地址法查找不成功所需的平均查找次数为： 'Unl=a+e-a=8／1l+e-8／117.12 分析：在等查区间的上、下界处设两个指针由此计算出中间元素的序号当中间元素大于给定值X时接下来到其低端区间去查找；当中间元素小于给定值X时接下来到其高端区间去查找；当中间元素等于给定值X时表示查找成功输出其序号Int binlist(sqtable Aint stkeytype X) ／*t、s分别为查找区间的上、下界*／{ if(s<t) return(0)；／*查找失败*／else{ mid=(S+t)／2；switCh(mid){case x<A.item[midJ.key： return(binlist(Asmid-lX))；／*在低端区间上递归*／case x==A.item[mid].key： return(mid)；／+查找成功*／ case x>A.item[mid].key： return(amid+ltX))；／*在高端区间上递归*／}}}int sqsearch0 (sqtable Akeytype X) /*数组有元素n个*／{ i=l；A.item[n+1].key=X；／t设置哨兵*／while (A.item[n+1].key!=X) i++；return (i% (n／1))；／*找不到返回0找到返回其下标*／}查找成功平均查找长度为：(1+2+3+...+n)／n：(1+n)／2查找不成功平均查找长度为：n+17.14散列函数：H(key)=100+(key个位数+key十位数) mod l0；形成的散列表：100 101 102 103 104 105 106 107 108 10998 75 63 46 49 79 61 53 17查找成功时的平均长度为：(1+2+1+1+5+1+1+5+5+3)/10=2.5次由于长度为10的哈希表已满因此在插人第11个记录时所需作的比较次数的期望值为10查找不成功时的平均长度为10习题 8参考答案8．1 选择题（1）B (2)A (3)D (4)C (5)B (6)A (7)B (8)C (9)A (10)C(11)D (12)C (13) C （14）D （15）C (16)B (17) D （18）C （19）B （20）D8.2填空题（1）快速归并（2） O（log2n）O(nlog2n)（3）归并（4）向上根结点（5） 1918162030（6）（7）4913275076386597（8）88（9）插入选择（每次选择最大的）（10）快速归并(11)O(1)O(nlog2n)(12)稳定(13)3(14)(15205040)(15)O(log2n)(16)O(n2)(17)冒泡排序快速排序(18)完全二叉树n/2(19)稳定不稳定(20)24(2015)8.3. 假定给定含有n个记录的文件(r1f2...rn)其相应的关键字为(k1k2...kn)则排序就是确定文件的一个序列rrr2...rn使得k1'≤k2'≤...≤kn'从而使得文件中n个记录按其对应关键字有序排列如果整个排序过程在内存中进行则排序叫内部排序假设在待排序的文件中存在两个或两个以上的记录具有相同的关键字若采用某种排序方法后使得这些具有相同关键字的记录在排序前后相对次序依然保持不变则认为该排序方法是稳定的否则就认为排序方法是不稳定的8.4．稳定的有：直接插入排序、二分法插入排序、起泡排序、归并排序和直接选择排序8.5．初始记录序列按关键字有序或基本有序时比较次数为最多8.6．设5个元素分别用abcde表示取a与b、c与d进行比较若a>bc>d(也可能是a<bc<d此时情况类似)显然此时进行了两次比较取b与d再比较若b>d则a>b>d若b<d则有c>d>b此时已进行了3次比较要使排序比较最多7次可把另外两个元素按折半检索排序插入到上面所得的有序序列中此时共需要4次比较从而可得算法共只需7次比较8.7．题目中所说的几种排序方法中其排序速度都很快但快速排序、归并排序、基数排序和Shell排序都是在排序结束后才能确定数据元素的全部序列而排序过程中无法知道部分连续位置上的最终元素而堆排序则是每次输出一个堆顶元素(即最大或最少值的元素)然后对堆进行再调整保证堆顶元素总是当前剩下元素的最大或最小的从而可知欲在一个大量数据的文件中如含有15000个元素的记录文件中选取前10个最大的元素可采用堆排序进行8.8．二分法排序8.9．void insertsort(seqlist r) &nbsp；{ ／／对顺序表中记录R[0一N-1)按递增序进行插入排序&NBSP；int ij； &nbsp；for(i=n-2；i>=0; i--) ／／在有序区中依次插入r[n-2]．．r[0] &nbsp；if(r[i].key>r[i+1].key) ／／若不是这样则r[i]原位不动&nbsp；{ &nbsp；r[n]=r[i]；j=i+l；／／r[n]是哨兵&nbsp；do{ ／／从左向右在有序区中查找插入位置&nbsp；r[j-1]= r[j]；／／将关键字小于r[i]．key的记录向右移&nbsp；j++； &nbsp；}whle(r[j].key r[j-1]=r[n]；／／将引i)插入到正确位置上&nbsp；}／／endif&nbsp；}／／insertsort． &nbsp；8.10．建立初始堆：[937 694 863 265 438 751 742129075 3011]&NBSP；&NBSP；第一次排序重建堆：[863 694 751 765 438 301 742 129 075]9378.11．在排序过程中每次比较会有两种情况出现若整个排序过程至少需作t次比较则显然会有2^t个情况由于n个结点总共有n!种不同的排列因而必须有n!种不同的比较路径于是： 2t≥n!即t≥log2n!因为log2nl=nlog2n-n／ln2+log2n／2+O(1)故有log2n!≈nlog2n从而t≧nlog2n得证8.12．依据堆定义可知：序列(1)、(2)、(4)是堆(3)不是堆从而可对其调整使之为如下的大根堆(1009580604095821020)8.13．第一趟：[265 301] [129 751] [863 937] [694 742] [076 438]&NBSP； &NBSP；第二趟：[129 265 301 751] [694 742 863 937] [076 438]&NBSP；&NBSP；第三趟：[129 265 301 694 742 751 863 937] [076 438]&NBSP；&NBSP；第四趟：[076 129 265 301 438 694 742 751 863 937]&NBSP；8.14．(1)归并排序：(1829) (2547) (1258) (1051)(18252947) (10125158)(1012182529475158)(2)快速排序：(1018251229585147)(1018251229475158)(1012182529475158)(3)堆排序：初始堆(大顶堆)：(58 47512918122510)第一次调整：(51 472529181210)(58)第二次调整：(47 2925101812)(5158)第三次调整：(29 18251012)(475158)第四次调整：(25 181210)(29475158)第五次调整：(18 1012)(2529475158)第六次调整：(12 10) (182529475158)第七次调整：(10 12182529475158)8.15．(1)直接插入排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 151=2 40 83 [63 13 84 35 96 57 39 79 61 15] 1=3 40 63 83 [13 84 35 96 57 39 79 61 15] 1=4 13 40 63 83 [84 3 5 96 57 39 79 61 15] I=5 13 40 63 83 84 [35 96 57 39 79 61 15] I=6 13 35 40 63 83 84 [96 57 39 79 61 15] 1=7 13 35 40 63 83 84 96 [57 39 79 61 15] 1=8 13 35 40 57 63 83 84 96 [ 39 79 61 15] 1=9 13 35 39 40 57 63 83 84 96 [79 61 15] I=10 13 35 39 40 57 63 79 83 84 96 [61 15] I=11 13 35 39 40 57 61 63 79 83 84 96 [15] 1=12 13 15 35 39 40 57 61 63 79 83 84 96 (2)直接选择排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 15i=1 13 [ 40 63 83 84 35 96 57 39 79 61 15] i=2 13 15 [63 83 84 35 96 57 39 79 61 40] i=3 13 15 35 [83 84 63 96 57 39 79 61 40] i=4 13 15 35 39 [84 63 96 57 83 79 61 40] i=5 13 15 35 39 40 [63 96 57 83 79 61 84] i=6 13 15 35 39 40 57 [96 63 83 79 61 84] i=7 13 15 35 39 40 57 61 [63 83 79 96 84] i=8 13 15 35 39 40 57 61 63 [83 79 96 84] i=9 13 15 35 39 40 57 61 63 79 183 96 84] i=10 13 15 35 39 40 57 61 63 79 83 [96 84] i=11 13 15 35 39 40 57 61 63 79 83 84 [96] (3)快速排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [15 40 63 13 61 35 79 57 39] 83 [96 84] 第二趟排序后 [13] 15 [63 40 61 35 79 57 39] 83 84 [96] 第三趟排序后 13 15 [39 40 61 35 57] 63 [79] 83 84 96 第四趟排序后 13 15 [35] 39 [61 40 57] 63 79 83 84 96第五趟排序后 13 15 35 39 [57 40] 61 63 79 83 84 96 第六趟排序后 13 15 35 39 40 [57] 61 63 79 83 84 96 第七趟排序后 13 15 35 39 40 57 61 63 79 83 84 96 (4)堆排序关键字 83 40 63 13 84 35 96 57 39 79 61 15排序成功的序列 96 84 83 79 63 61 57 40 39 35 15 13(5)归并排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [40 83] [13 63] [3584] [57 96] [39 79] [15 61]第二趟排序后 [13 40 63 83] [35 57 84 96] [15 39 61 79] 第三趟排序后 [13 35 40 57 63 83 84 96]] [15 39 61 79] 第四趟排序后 13 15 35 39 40 57 61 63 79 83 84 96。

数据结构习题精编：串和数组

数据结构习题精编：串和数组一、选择题1．下面关于串的的叙述中，不正确的是A．串是字符的有限序列B．空串是由空格构成的串C．模式匹配是串的一种重要运算D．串既可以采用顺序存储，也可以采用链式存储2．下面关于串的的叙述中，正确的是A．空串就是空白串B．串相等指的是串的长度相等C．串的长度必须大于零D．串是一种特殊的线性表3．字符串是一种特殊的线性表，它与一般线性表的区别是A．字符串是一种线性结构B．字符串可以进行复制操作C．字符串可以顺序存储也可以链式存储D．字符串由字符构成并且通常作为整体参与操作4．串s="Data Structure"中长度为3的子串的数目是A．9B．11C．12D．145．若串S="software"，则S的子串的数目是A．8 B．35 C．36 D．376．已知串S= "string"，T="this"，执行运算StrLength(StrCopy(S,T))的结果是A．2 B．4 C．6 D．107．若串S="SCIENCESTUDY"，则调用函数StrCopy(P,SubString(S,1,7))后得到A．P="STUDY" B．P="SCIENCE" C．S="STUDY" D．S="SCIENCE" 8．若字符串采用链式存储，每个字符占用一个字节，每个指针在占用四个字节，则该字符串的存储密度为A．20%B．25%C．50%D．75%9．为查找某一特定单词在文本中出现的位置，可应用的串运算是A．串联接B．求子串C．串比较D．子串定位10．当目标串的长度为n，模式串的长度为m时，朴素的模式匹配算法最好情况下字符的比较次数A．m B．n C．n-m D．n+m11．当目标串的长度为n，模式串的长度为m时，朴素的模式匹配算法最坏情况下字符的比较次数A．m B．n C．(n-m+1)*m D．n*m12．已知串S="aaab",其Next数组的元素值依次为A．0、1、2、3 B．1、1、2、3 C．1、2、1、1 D．1、2、3、1 13．串"ababaaababaa" 的next数组为A．011234223456 B．012121111212 C．0123012322345 D．012345678999 14．字符串"ababaabab" 的nextval 为A．(0,1,0,1,0,0,0,1,1) B．(0,1,0,1,0,1,0,1,1)C．(0,1,0,1,0,2,1,0,1) D．(0,1,0,1,0,4,1,0,1)15．二维数组A[10][20]采用按行为主序的存储方式，每个元素占4个存储单元，若A[0][0]的存储地址为300，则A[8][10]的地址为A．660 B．732 C．980 D．113216．二维数组A[5][6]采用按列为主序的存储方式，每个元素占3个存储单元，若A[0][0]的存储地址是100，则A[4][3]的存储地址是A．157 B．166 C．169 D．18117．二维数组A按行优先顺序存储，其中每个元素占1个存储单元。

数据结构第六版习题一答案

数据结构第六版习题一答案数据结构第六版习题一答案在学习数据结构的过程中，习题是帮助我们巩固知识、提高理解能力的重要方式之一。

本文将为大家提供数据结构第六版习题一的答案，希望能够帮助大家更好地理解和应用数据结构。

1. 问题描述：给定一个数组arr，长度为n，数组中的元素为整数。

请设计一个算法，找出数组中出现次数超过n/2的元素。

解答：可以使用摩尔投票算法来解决这个问题。

首先选取数组中的第一个元素作为候选元素，然后遍历数组，如果当前元素与候选元素相同，则计数器加1，否则计数器减1。

当计数器减到0时，将当前元素设置为新的候选元素。

遍历完数组后，候选元素即为出现次数超过n/2的元素。

2. 问题描述：给定一个链表，判断链表是否存在环。

解答：可以使用快慢指针的方法来解决这个问题。

定义两个指针，一个快指针每次移动两步，一个慢指针每次移动一步。

如果链表存在环，那么快指针一定会追上慢指针，即它们会在某个节点相遇。

如果链表不存在环，那么快指针会先到达链表的末尾。

所以，我们可以通过判断快指针是否为空来确定链表是否存在环。

3. 问题描述：给定一个二叉树，判断它是否是平衡二叉树。

解答：可以使用递归的方法来解决这个问题。

首先定义一个函数来计算二叉树的高度，然后在判断平衡二叉树时，递归地计算左子树和右子树的高度差。

如果高度差大于1，或者左子树和右子树中存在不平衡的情况，则二叉树不是平衡二叉树。

如果左子树和右子树都是平衡二叉树，并且高度差小于等于1，则二叉树是平衡二叉树。

4. 问题描述：给定一个有序数组arr和一个目标值target，使用二分查找算法在数组中查找目标值的位置。

解答：可以使用二分查找算法来解决这个问题。

首先初始化左指针left为0，右指针right为数组长度减1。

然后进行迭代，直到左指针大于右指针为止。

在每一次迭代中，计算中间位置mid，如果中间元素等于目标值，则返回mid。

如果中间元素大于目标值，则将右指针更新为mid-1。

《数据结构及其应用》笔记含答案第四章_串、数组和广义表

第4章串、数组和广义表一、填空题1、零个或多个字符组成的有限序列称为串。

二、判断题1、稀疏矩阵压缩存储后，必会失去随机存取功能。

（√）2、数组是线性结构的一种推广，因此与线性表一样，可以对它进行插入，删除等操作。

（╳）3、若采用三元组存储稀疏矩阵，把每个元素的行下标和列下标互换，就完成了对该矩阵的转置运算。

（╳）4、若一个广义表的表头为空表，则此广义表亦为空表。

（╳）5、所谓取广义表的表尾就是返回广义表中最后一个元素。

（╳）三、单项选择题1、串是一种特殊的线性表，其特殊性体现在（B）。

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

3、串“ababaaababaa”的next数组为（C）。

A．012345678999 B．012121111212 C．011234223456 D．01230123223454、串“ababaabab”的nextval为（A）。

A．010104101B．010102101 C．010100011 D．0101010115、串的长度是指（B）。

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

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

A．808 B．818 C．1010 D．1020解释：以行序为主，则LOC[5,5]=[（5-1）*100+（5-1）]*2+10=818。

数据结构(C语言版)习题及答案第四章

数据结构(C语言版)习题及答案第四章习题4.1选择题1、空串与空格串是（B）。

A、相同B、不相同Ｃ、不能确定2、串是一种特殊的线性表，其特殊性体现在（B）。

A、可以顺序存储B、数据元素是一个字符C、可以链式存储D、数据元素可以是多个字符3、设有两个串p和q，求q在p中首次出现的位置的操作是（B）。

A、连接B、模式匹配C、求子串D、求串长4、设串1=“ABCDEFG”，2=“PQRST”函数trconcat（，t）返回和t串的连接串，trub（，i，j）返回串中从第i个字符开始的、由连续j 个字符组成的子串。

trlength()返回串的长度。

则trconcat（trub（1，2，trlength（2）），trub（1，trlength（2），2））的结果串是（D）。

A、BCDEFB、BCDEFGC、BCPQRSTD、BCDEFEF5、若串=“oftware”，其子串个数是（B）。

A、8B、37C、36D、94.2简答题1、简述空串与空格串、主串与子串、串名与串值每对术语的区别？答：空串是指长度为0的串，即没有任何字符的串。

空格串是指由一个或多个空格组成的串，长度不为0。

子串是指由串中任意个连续字符组成的子序列，包含子串的串称为主串。

串名是串的一个名称，不指组成串的字符序列。

串值是指组成串的若干个字符序列，即双引号中的内容。

2、两个字符串相等的充要条件是什么？答：条件一是两个串的长度必须相等条件二是串中各个对应位置上的字符都相等。

3、串有哪几种存储结构？答：有三种存储结构，分别为：顺序存储、链式存储和索引存储。

4、已知两个串：1=”fgcdbcabcadr”,2=”abc”,试求两个串的长度，判断串2是否是串1的子串，并指出串2在串1中的位置。

答：（1）串1的长度为14，串2的长度为3。

（2）串2是串1的子串，在串2中的位置为9。

5、已知：1=〃I’matudent〃，2=〃tudent〃，3=〃teacher〃，试求下列各操作的结果：trlength(1)；答：13trconcat(2,3)；答：”tudentteachar”trdelub(1,4,10)；答：I’m6、设1=”AB”，2=”ABCD”，3=”EFGHIJK，试画出它们在各种存储结构下的结构图。

数据结构课后习题(第4-5章)

【课后习题】第4章串第5章数组和广义表网络工程2010级（）班学号：姓名：题号一二三四总分得分一、填空题（每空1分，共30分）1. 串有三种机内表示方法：、和，其中前两种属于顺序存储结构，第三种属于。

2. 若n 为主串长度，m 为子串长度，则串的BF （朴素）匹配算法最坏的情况下需要比较字符的总次数为 ,T(n)= 。

3. 是任意串的子串；任意串S 都是S 本身的子串，除S 本身外，S 的其他子串称为S 的。

4. 设数组a[1…50, 1…60]的基地址为1000，每个元素占2个存储单元，若以行序为主序顺序存储，则元素a[32,58]的存储地址为。

5. 对于数组，比较适于采用结构够进行存储。

6. 广义表的深度是指_______。

7. 将一个100100 A 的三对角矩阵，按行优先存入一维数组B[297]中，A 中元素66,66A 在B 数组中的位置k 为。

8. 注意：a i,j 的k 为 2(i-1)+j-1,(i=1时j=1,2;1<i<=n 时,j=i-1,i,i+1) 。

9. 称为空串；称为空白串。

10. 求串T 在主串S 中首次出现的位置的操作是，其中称为目标串，称为模式。

11. 对称矩阵的下三角元素a[i,j]，存放在一维数组V 的元素V[k]中（下标都是从0开始）， 12. k 与i ，j 的关系是：k= 。

13. 在n 维数组中每个元素都受到个条件的约束。

14. 同一数组中的各元素的长度。

15. 三元素组表中的每个结点对应于稀疏矩阵的一个非零元素，它包含有三个数据项，分别表示该元素的、和。

16.稀疏矩阵中有n个非零元素，则其三元组有行。

17.求下列广义表操作的结果：18.（1）GetHead【((a,b),(c,d))】=== ;19.（2）GetHead【GetTail【((a,b),(c,d))】】=== ;20.（3）GetHead【GetTail【GetHead【((a,b),(c,d))】】】=== ;21.（4）GetTail【GetHead【GetTail【((a,b),(c,d))】】】=== ;22.广义表E=(a,(b,E)),则E的长度= ，深度= ；二、判断题（如果正确，在下表对应位置打“√”，否则打“⨯”。

数据结构(字符串)练习题与答案

1、下面关于串的叙述中，正确的是（）。

A.串是一种特殊的线性表B.串中元素只能是字母C.空串就是空白串D.串的长度必须大于零正确答案：A解析：串是一种特殊的线性表，其元素为单个字符，长度可以为0。

2、两个字符串相等的条件是（）。

A.串的长度相等B.含有相同的字符集C.都是非空串D.两个串的长度相等且对应位置的字符相同正确答案：D3、若串str=“Software”，其子串的个数是（）。

A.8B.9C.36D.37正确答案：D解析：该串中所有字符不相同，长度为0的子串1个，长度为1的子串8个，长度为2的子串7个，…，长度为7的子串2个，长度为8的子串1个，总计子串数=1+8+7+…+2+1=1+8×9/2=37。

4、一个链串的节点类型定义为#define NodeSize 6typedef struct node{ char data[NodeSize];struct node *next;} LinkStrNode;如果每个字符占1个字节，指针占2个字节，该链串的存储密度为（）。

A.1/3B.1/2C.2/3D.3/4正确答案：D解析：链串节点大小指每个节点存放的字符个数，本题节点大小为6，存储密度=(6*1)/(6*1+2)=3/4。

5、串采用节点大小为1的链表作为其存储结构，是指（）。

A.链表的长度为1B.链表中只存放一个字符C.链表中每个节点的数据域中只存放一个字符D.以上都不对正确答案：C解析： C、链串节点大小指每个节点存放的字符个数。

6、对于一个链串s，查找第一个字符值为x的算法的时间复杂度为（）。

A.O(1)B.O(n)C. O(n2)D.以上都不对正确答案：B解析：在链串查找第一个字符值为x的算法的时间复杂度为O(n)。

7、设有两个串p和q，其中q是p的子串，则求q在p中首次出现位置的算法称为（）。

A.求子串B.串联接C.模式匹配D.求串长正确答案：C解析：模式匹配算法就是找子串在主串中的位置。

数据结构课后习题答案-完整版

数据结构课后习题答案-完整版下面是《数据结构课后习题答案-完整版》的内容：---第一章：数组1. 题目：给定一个整数数组，判断是否存在两个元素之和等于目标值。

答案：使用双指针法，首先将数组排序，然后设置左指针指向数组头部，右指针指向数组尾部。

如果左指针和右指针指向的元素之和小于目标值，则左指针右移；如果大于目标值，则右指针左移；如果等于目标值，则找到了两个元素之和等于目标值的情况。

2. 题目：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数的下标。

答案：使用哈希表，在遍历数组的过程中，将每个元素的值和下标存储在哈希表中。

遍历到当前元素时，检查目标值与当前元素的差值是否在哈希表中，如果存在，则找到了两个数的下标。

---第二章：链表1. 题目：给定一个链表，判断链表中是否存在环。

答案：使用快慢指针法，定义两个指针，一个指针每次向前移动一个节点，另一个指针每次向前移动两个节点。

如果存在环，则两个指针必定会相遇。

2. 题目：给定一个链表，删除链表的倒数第N个节点。

答案：使用双指针法，定义两个指针，一个指针先移动N个节点，然后两个指针同时向前移动，直到第一个指针到达链表尾部。

此时第二个指针指向的节点即为要删除的节点。

---第三章：栈和队列1. 题目：设计一个栈，使得可以在常数时间内获取栈中的最小元素。

答案：使用辅助栈来保存当前栈中的最小元素。

每次压栈操作时，将当前元素与辅助栈的栈顶元素比较，只有当前元素较小才将其压入辅助栈。

2. 题目：设计一个队列，使得可以在常数时间内获取队列中的最大元素。

答案：使用双端队列来保存当前队列中的最大值。

每次入队操作时，将当前元素与双端队列的末尾元素比较，只有当前元素较大才将其压入双端队列。

---第四章：树和二叉树1. 题目：给定一个二叉树，判断它是否是平衡二叉树。

答案：通过递归遍历二叉树的每个节点，计算每个节点的左子树高度和右子树高度的差值。

如果任意节点的差值大于1，则该二叉树不是平衡二叉树。

数据结构课后习题答案第四章

第四章串一、单项选择题1．B2. B3．B4．C5. C二、填空题1．空、字符2．由空格字符（ASCII值32）所组成的字符串空格个数3．长度、相等、子、主4．55．011223126．（1）char s[ ] (2) j++ (3) i >= j7．[题目分析]本题算法采用顺序存储结构求串s和串t的最大公共子串。

串s用i指针（1<=i<=s.len）。

t串用j指针（1<=j<=t.len）。

算法思想是对每个i（1<=i<=s.len，即程序中第一个WHILE循环），来求从i开始的连续字符串与从j（1<=j<=t.len，即程序中第二个ＷHILE循环）开始的连续字符串的最大匹配。

程序中第三个（即最内层）的WHILE循环，是当s中某字符（s［i］）与t中某字符（t［j］）相等时，求出局部公共子串。

若该子串长度大于已求出的最长公共子串（初始为０），则最长公共子串的长度要修改。

(1) i+k<=s.len && j+k<=t.len && s[i+k]==t[j+k] //所有注释同上（a）(2) con=0 (3) j+=k (4) j++ (5) i++三、应用题1．空格是一个字符，其ASCII码值是32。

空格串是由空格组成的串，其长度等于空格的个数。

空串是不含任何字符的串，即空串的长度是零。

2．(a)A+B “ mule”(b)B+A “mule ”(c)D+C+B “myoldmule”(d)SUBSTR(B,3,2) “le”(e)SUBSTR(C,1,0) “”(f)LENGTH(A) 2(g)LENGTH(D) 2(h)INDEX(B,D) 0(i)INDEX(C,”d”) 3(j)INSERT(D,2,C) “myold”(k)INSERT(B,1,A) “m ule”(l)DELETE(B,2,2) “me”(m)DELETE(B,2,0) “mule”3．朴素的模式匹配（Brute－Force）时间复杂度是Ｏ（m＊n），KMP算法有一定改进，时间复杂度达到Ｏ（m＋n）。

数据结构(C语言版)第4-5章习题答案

第4～5章串和数组自测卷答案一、填空题（每空1分，共20分）1. 不包含任何字符（长度为0）的串称为空串；由一个或多个空格（仅由空格符）组成的串称为空白串。

（对应严题集4.1①，简答题：简述空串和空格串的区别）2. 设S=“A;/document/Mary.doc”，则strlen(s)= 20 , “/”的字符定位的位置为3。

4. 子串的定位运算称为串的模式匹配；被匹配的主串称为目标串，子串称为模式。

5. 设目标T=”abccdcdccbaa”，模式P=“cdcc”，则第 6 次匹配成功。

6. 若n为主串长，m为子串长，则串的古典（朴素）匹配算法最坏的情况下需要比较字符的总次数为(n-m+1)*m。

7. 假设有二维数组A6×8，每个元素用相邻的6个字节存储，存储器按字节编址。

已知A的起始存储位置（基地址）为1000，则数组A的体积（存储量）为288 B ；末尾元素A57的第一个字节地址为1282 ；若按行存储时，元素A14的第一个字节地址为(8+4)×6+1000=1072 ；若按列存储时，元素A47的第一个字节地址为(6×7＋4)×6＋1000）＝1276 。

(注：数组是从0行0列还是从1行1列计算起呢？由末单元为A57可知，是从0行0列开始！)8. 〖00年计算机系考研题〗设数组a[1…60, 1…70]的基地址为2048，每个元素占2个存储单元，若以列序为主序顺序存储，则元素a[32,58]的存储地址为8950 。

答：不考虑0行0列，利用列优先公式：LOC(a ij)=LOC(a c1，c2)+[(j-c2)*(d1-c1+1)+i-c1)]*L得：LOC(a32,58)=2048+[(58-1)*(60-1+1)+32-1]]*2＝89509. 三元素组表中的每个结点对应于稀疏矩阵的一个非零元素，它包含有三个数据项，分别表示该元素的行下标、列下标和元素值。

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

B）任意个字母的序列 D）有限个字符的序列
C）串中所含字符的个数，且大于0
D）串中所含字符的个数
1.C 2.D 3.D
补充习题:
4.设有两个串p和q,求q在p中首次出现的位置的运算( A）连接 C）求子串 B）模式匹配 D）求串长 )存储方式最为节 ).
5.若某串的长度小于一个常数，则采用( 省空间。 A)链式 A)正确 A)正确 B)堆结构 B)不正确 C)顺序
本章要点回顾:
1.熟悉串的相关概念及串的五种基本操作的定义，并能利用这些基本操作来实现串的其它各种操作的方法;
2.熟练掌握在串的定长顺序存储结构上实现串的各种操作的
方法; 3.了解串的堆存储结构以及在其上实现串操作的基本方法;
4.理解串的模式匹配算法;
5.了解数组的两种存储表示方法，并掌握数组在以行为主的存储结构中的地址计算方法; 6.掌握对特殊矩阵进行压缩存储时的下标变换公式; 7.了解稀疏矩阵的压缩存储方法的特点和适用范围，领会以三元组表示稀疏矩阵时进行矩阵运算采用的处理方法。
{
temp=strstr(s,t); //返回t在s中第一次出现的指针 while(temp) { n=strlen(s)-strlen(temp); strncpy(head,s,n); tail=temp+strlen(t); strcat(head,tail); //把head,tail连接为新串 s=head; temp=strstr(s,t); }
}
习题5.4:
void Delete_SubString(char *&s,char *t) //从串s中删除所有与t相同的子串
{
int i,pos=0,len=strlen(t); while(Index(s,t,pos)!=-1)
{
i=Index(s,t,pos); StrDelete(s,i,len); pos=i;
12.D 13.A 14.B
补充习题:
15.两维数组是一种非线性结构。（ A)正确 B)不正确）
16.数组A三维的长度分别为b3,b2,b1；每个数组元素占一个存储单元；LOC[0，0，0]为基址。若以行序为主序，则元素 A[i][j][k]的地址为( )(其中0<=i<b3,0<=j<b2,0<=k<b1) A)LOC[0,0,0]+i*b2*b1+j*b1+k
第5章串和数组习题
补充习题:
1.串是一种特殊的线性表，其特殊性体现在( A)可以顺序存储 ) 。 B)可以用链表存储

C)数据元素是一个字符
2.串是（）。 A）少于一个字母的序列 C）不少于一个字符的序列 3.串的长度是（）。 A）串中不同字母的个数 B）串中不同字符的个数
D)数据元素可以是多个字符
B)LOC[0,0,0]+i*b3*b2+j*b1+k C)LOC[0,0,0]+b3*i+b2*j+k D)LOC[0,0,0]+b3*i*j+b2*j+k
15.B 16.A
习题5.4:
void Delete_SubString(char *&s,char *t) //从串s中删除所有与t相同的子串
6.串中任意多个连续字符组成的子序列称为该串的子串( ). 7.如果两个串含有相同的字符集，则说两者相等( B)不正确 4.B 5.C 6.A 7.B ).
补充习题:
8.存取数组中任一元素的时间都是相等的，这种存取方式为（）存取方式。
A）顺序 B）随机 C）线性 D）非线性 9.设一个一维数组第一个元素的存储单元的地址是100，每个元素的长度是6，则它的第5个元素的地址是（）。 A）130 B）105 C）106 D）124 10.设n阶方阵是一个上三角矩阵，则需要存储的元素个数是（）。 A）n2/2 B）n(n+1)/2 C）n D）n2 11.对一些特殊矩阵采用压缩存储的目的主要是为（）。
(3,1,5),(3,2,-1),(4,5,4),(5,1,-3),则其转置矩阵的三元组表中第3个三元组为（）。
A) (2,1,3)
C) (3,2,-1)
B) (3,1,5)
D) (2,3,-1)
14.若采用三元组压缩技术存储稀疏矩阵，只要把每个元素的行下标和列下标互换，就完成了对该矩阵的转置运算，这种观点（） A)正确 B)不正确
}
}
习题5.6:
解:(1) (2) (3) (4) 6*8*6 1000+(5*8+7)*6 1000+(1*8+4)*6 1000+(7*6+4)*6
习题5.9:
解: u=i-j+1 v=j-1
习题5.10:
解:当i为奇数时:k=i+j-2 当i为偶数时:k=i+j-1 合并可写成: k=i+j-(i%2)-1 or k=2(i/2)+j-1
A）表达变得简单 B）减少不必要的存储空间的开销 C）去掉矩阵中的多余元素 D）对矩阵元素的存取变得简单
8.B 9.D 10.B 11.B
补充习题:
12.三元组表不包括（ A) 行数 B) 列数）。 C) 元素值 D) 元素总数
13.设已知一个稀疏矩阵的三元组如下：(1,2,3),(1,6,1),