数据结构习题集有答案解析Word文件下载.docx

数据结构习题集有答案解析Word文件下载.docx

《数据结构习题集有答案解析Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构习题集有答案解析Word文件下载.docx（18页珍藏版）》请在冰豆网上搜索。

{ints=0;

for（inti=1;

{intp=1;

j++）p*=j;

s+=p;

（1）

T（n）=O（n）

T（n）=O（n2）

1.4算法设计

有3枚硬币，其中有1枚是假的，伪币与真币重量略有不同。

如何借用一架天平，找出伪币？

以流程图表示算法。

上机练习题

要求：

给出问题分析、算法描述、源程序及运行截图，在线提交。

1.设a,b,c为3个整数，求其中位于中间值的整数。

第2章线性表

1.设计算法：

在顺序表中删除值为e的元素，删除成功，返回1；

否则，返回0。

intSqlist<

T>

:

DeleteElem（Te）

{for（i=1;

=length;

i++）//按值顺序查找*i可从0开始

if（elem[i-1]==e）//找到，进行删除操作

{for（j=i;

length;

j++）//ai至an依次前移

Elem[j-1]=elem[j];

length--;

//表长减一

return1;

//删除成功，返回1

}

return0;

//未找到，删除不成功，返回0

2.分析顺序表中元素定位算法intSqList<

Locate（Te）的时间复杂度。

设表长为n，等概率下，每个元素被定位的概率为：

p=1/n

定位成功第i个元素，需比较i次

3.对于有头结点的单链表，分别写出定位成功时，实现下列定位语句序列。

（1）定位到第i个结点ai；

p=head;

j=0;

while（p&

&

i）{p=p->

next;

j++;

（2）定位到第i个结点的前驱ai-1；

i-1）{p=p->

（3）定位到尾结点；

while（p->

next）p=p->

（4）定位到尾结点的前驱。

while（p->

next->

4.描述一下三个概念的区别：

头指针，头结点，首元结点。

并给予图示。

头指针：

是一个指针变量，里面存储的是链表中首结点的地址，并以此来标识一个链表。

头结点：

附加在第一个元素结点之前的一个结点，头指针指向头结点。

首元结点：

指链表中的第一个元素结点。

5.对于无头结点单链表，给出删除第i个结点的算法描述。

template<

calssT>

TLinkList<

Delete（inti）

template<

Delete（inti）{//在单链表上删除第i个数据元素

if（head==NULL）throw“表空!

”;

//空表，不能删

elseif（i==1）{//删除第1个元素

p=Head;

x=p->

data;

//保存被删元素值

Head=p->

next;

deletep;

else{//元素定位到第ai-1

j=1;

//定位查找起始位置

while{p->

next&

i-1}{

p=p->

j++;

if（!

p->

next||j>

i-1）;

//定位失败

throw“删除位置不合理”;

else{//定位成功，进行结点删除

q=p->

x=p>

p->

next=q->

deleteq;

retrunx;

//返回被删除元素值

}//#

6.用教材定义的顺序表的基本操作实现下列操作：

intDeleteElem（SqListL,Te）

#include“SqList.h“

intDeleteElem（SqListL,Te）{//

i=L.LocateElem（e）;

//按值查找

if（!

i）//未找到

return0;

else//找到

delete（i）;

//删除被找到的元素

7.已知L是有表头结点的单链表，且P结点既不是首元结点，也不是尾结点，试写出实现下列功能的语句序列。

（1）在P结点后插入S结点；

（2）在P结点前插入S结点；

（3）在表首插入S结点；

（4）在表尾插入S结点.

【解】

（1）s->

next=p->

next=s;

（2）q=L;

while（q->

next!

=p）q=q->

s->

next=p或q->

q->

（3）s->

next=L->

L->

（3）q=L;

=NULL）q=q->

next=q->

q->

编程实现：

删除单链表中值为e的元素。

第3章栈与队列

1.铁路进行列车调度时,常把站台设计成栈式结构的站台，如右图所示。

试问：

若进站的六辆列车顺序如上所述,那么是否能够得到325641和154623的出站序列,如果不能,说明为什么不能;

如果能,说明如何得到（即写出"

进栈"

或"

出栈"

的序列）。

325641可以

154623不可以。

2.简述以下算法的功能（栈的元素类型为int）。

（1）statusalgo_1（SqStackS）{

　　　　inti,n,A[255];

　　　　n=0;

　　　　while（!

S.StackEmpty（））{n++;

A[n]=S.Pop（）;

　　　　for（i=1;

=n;

i++）S.Push（A[i]）;

　　　}

（2）statusalgo_2（SqStackS,inte）{

　　　　SqStackT;

intd;

S.tackEmpty（））{

　　　　　d=S.Pop（）;

　　　　　if（d!

=e）T.Push（d）;

}

T.StackEmpty（））{

　　　　　d=T.Pop（）;

　　　　　T.Push（d）;

（1）借助一个数组，将栈中的元素逆置。

（2）借助栈T，将栈S中所有值为e的数据元素删除之。

3.编写一个算法，将一个非负的十进制整数N转换为B进制数，并输出转换后的结果。

当N=248D，B分别为8和16时，转换后的结果为多少？

#include“stack.h”

intNumTrans（intN,intB）{//十进制整数N转换为B进制数

stack<

int>

S;

//建立一个栈

while（N!

=0）{//N非零

i=N%B;

//从低到高，依次求得各位

N=N/B;

S.push（i）;

}//各位入栈

while（!

S.StackEmpty（））{//栈不空

{i=S.pop（）;

If（i>

9）i=’A’+10-i;

cout<

<

S.pop（）;

}//依次出栈，得到从高到低的输出结果

}//#

4借且栈，设计算法：

假设一个算术表达式中包含“（”、“）”括号，对一个合法的数学表达式来说，括号“（”和“）”应是相互匹配的。

若匹配，返回1；

以字符串存储表达式，也可以边输入边判断。

顺序扫描表达式，左括号，入栈；

右括号，如果此时栈空，表示多右括号，不匹配；

如果栈不空，出栈一个左括号。

扫描结束，如果栈空，表示括号匹配；

否则，括号不匹配，多左括号。

intblank_match（char*exp）{用字符串存表达式

SqStack<

char>

s;

//创建一个栈

char*p=exp;

//工作指针p指向表达式首

while（*p!

=’=’）{//不是表达式结束符

switch（p）{

case’（’:

//左括号，入栈

s.push（ch）;

break;

case’）’//右括号

if（s.StackEmpty（））return0;

//栈空，不匹配，多右括号

else{s.Pop（）;

}//左括号出栈

}//switch

p++;

//取表达式下一个字符

}//while

s.StackEmpty（））//表达式结束，栈不空

//不匹配，多左括号

else

//匹配

}//#

5.简述栈和队列的逻辑特点，各举一个应用实例。

6.写出下列中缀表达式的后缀表达式。

（1）-A+B-C+D

（2）（A+B）*D+E/（F+A*D）+C

（3）A&

B||!

（E>

F）

（1）A-B+C-D+

（2）AB+D*EFAD*+/+C+

（3）AB&

EF!

||

7.计算后缀表达式：

45*32+-的值。

15

8.将下列递推过程改写为递归过程。

voidrecursion（intn）{

inti=n;

while（i>

1）{

i;

i--;

voidrecurision（intj）

{if（j>

1）

{cour<

j;

recurision（j-1）;

9..将下列递归过程改写为非递归过程。

voidtest（int&

sum）{

intx;

cin>

>

x;

if（x==0）sum=0;

else{

test（sum）;

sum+=x;

cout<

sum;

voidtest（int&

sum）

{stackS;

//借助一个栈

intx;

cin>

while（x）{

S.push（x）;

sum=0;

while（x=S.pop（））{

}//

10.简述以下算法的功能（栈和队列的元素类型均为int）。

　　voidalgo（Queue&

Q）

　　{

　　　StackS;

//创建一个栈

　　　while（!

Q.QueueEmpty（））　　{

　　　　d=DeQueue（Q）;

S.Push（d）;

S.StackEmpty（））　{

　　　　d=S.Pop（）;

Q.EnQueue（d）;

　　}

利用栈，将队列中的元素逆置

12.假设以数组se[m]存放循环队列的元素，同时设变量rear和front分别作为队首、队尾指针，且队首指针指向队首前一个位置，队尾指针指向队尾元素处，初始时，rear==fornt==-1。

写出这样设计的循环队列入队、出队的算法。

采用教材队空与队满判别方法。

为了区分队空与队满条件，牺牲一个元素空间。

即：

rear==front，为队空；

rear==（front+1）%m，为队满。

voidEnQueue（TSe[],Te,intm）{//入队

if（rear+1）%m 

=fornt）{//队满，不能插入

throw“队满，不能插入!

”

else{

rear=（rear+1）%m 

;

//队尾指针后移

se[rear]=e;

//元素入队

return;

TDnQueue（TSe[],intm）{//出队

if（rear= 

=fornt）//队空，不能出队!

throw“队空，不能出队!

else{

front=（front+1）%m 

//指针后移，指向队首元素

e=se[front];

//取队首元素

returne;

1.借助栈，实现单链表上的逆置运算。

第4章串

1.试问执行以下函数会产生怎样的输出结果?

　　voiddemonstrate（）

　　{

　　　StrAssign（s,'

THISISABOOK'

）;

　　　StrRep（s,StrSub（s,3,7）,'

ESEARE'

　　　StrAssign（t,StrConcat（s,'

S'

））;

　　　StrAssign（u,'

XYXYXYXYXYXY'

）;

　　　StrAssign（v,StrSub（u,6,3））;

　　　StrAssign（w,'

W'

　　　cout<

“'

t=”<

t<

endl;

“v=”<

v;

“u=”<

StrRep（u,v,w）;

}//demonstrate

t=THESEAREBOOKS

v=YXY

w=XWXWXW

2.设字符串S=‘aabaabaabaac'

，P=‘aabaac'

1）给出S和P的next值和nextval值；

2）若S作主串，P作模式串，试给出KMP算法的匹配过程。

1）S的next与nextval值分别为012123456789和002002002009，

p的next与nextval值分别为012123和002003

2）利用KMP算法的匹配过程：

第一趟匹配：

aabaabaabaac

aabaac（i=6,j=6）

第二趟匹配：

（aa）baac

第三趟匹配：

（成功）（aa）baac

3.算法设计

串结构定义如下：

structSString

char*data；

//串首址

intlen;

//串长

intStrSize；

//存放数组的最大长度.

};

（1）编写一个函数，计算一个子串在一个字符串中出现的次数，如果不出现，则为0。

intstr_count（SStringS,SStringT）

intstr_count（SStringS,SStringT）{

inti,j,k,count=0;

for（i=0;

S.data[i];

i++）{

for（j=i,k=0;

（S.data[j]==T.data[k];

j++,k++）

if（k==T.len-1）

count++;

returncount;

（2）编写算法，从串s中删除所有和串t相同的子串。

intSubString_Delete（SString&

s,SStringt）

//从串s中删除所有与t相同的子串,并返回删除次数

for（n=0,i=0;

=s.len-t.len;

i++）

for（j=0;

t.len&

s[i+j]==t[i];

j++）;

if（j>

t.len）//找到了与t匹配的子串

for（k=i;

s.len-t.len;

k++）

s[k]=s[k+t.len];

//左移删除

s.len-=t.len;

n++;

//被删除次数增1 

}//for

returnn;

}//Delete_SubString

（2）编写一个函数，求串s和串t的一个最长公共子串。

voidmaxcomstr（SString*s,SString*t）

voidmaxcomstr（SString*s,SString*t）{

intindex=0,len1=0,i,j,k,len2;

i=0;

//作为扫描s的指针

while（i<

s.len）{

j=0;

//作为扫描t的指针

while（j<

t.len）{

if（s.data[i]==t.data[j]）{//序号为i，长度为len2的子串

len2=1;

//开始计数

for（k=1;

s.data[i+k]==t.data[j+k]&

s.data[i+k]!

=NULL;

k++）

len2++;

if（len2>

len1）{//将较大长度者给index和len1

index=i;

len1=len2;

j+=len2;

}//if

elsej++;

}//while

”最长公共子串：

”

len1;

i++;

）

s.data[index+1];

}//#

1.已知下列字符串

　　a='

THIS'

f='

ASAMPLE'

c='

GOOD'

d='

NE'

b='

'

　　s=StrConcat（a,StrConcat（StrSub（f,2,7）,StrConcat（b,StrSub（a,3,2））））,

　　t=StrRep（f,StrSub（f,3,6）,c）,

　　u=StrConcat（StrSub（c,3,1）,d）,g='

IS'

　　v=StrConcat（s,StrConcat（b,StrConcat（t,StrConcat（b,u））））,

　　试问:

s,t,v,StrLength（s）,StrIndex（v,g）,StrIndex（u,g）各是什么?

已知：

s='

（XYZ）+*'

，t='

（X+Z）*Y'

。

试利用下列运算，将s转化为t。

联接：

StrConcat（&

S,T）

求子串：

（char*）StrSub（S,i,len）

置换：

StrRep（&

S,T,R）

char*data；

intStrSize；

求：

串S所含不同字符的总数和每种字符的个数，不区分英文字母的大小写。

第5章数组与压缩矩阵

1.假设有二维数组A6×

8，每个元素用相邻的6个字节存储，存储器按字节编址。

已知A的起始存储位置（基地址）为1000，计算：

（1）数组A的体积（即存储量）;

（2）数组A的最后一个元素a57的第一个字节的地址;

　（3）按行存储时，元素a14的第一个字节的地址;

　（4）按列存储时，元素a47的第一个字节的地址。

（1）6×

8×

6=288Byte

（2）1000+288-6=1282；

（3）1000+（1×

8+4）×

6=1072

（4）1000+（7×

6+4）×

6=1276

2.假设按低下标优先存储整数数组A9×

3×

5×

8时，第一个元素的字节地址是100，每个整数占四个字节。

问下列元素的存储地址是什么？

（1）a0000　

（2）a8247

（1）100

（2）100+8×

8+2×

8+4×

8+7=4500

3．一个稀疏矩阵如图所示

（1）给出三元组存储示意图；

（2）给出带行指针向量的链式存储示意图；

（3）十字链表存储示意图。

（2）

4.算法设计：

一个按行优先存储的n*n矩阵，就地转置。

voidtrans（ElemTypeA[],intn）{

inti,j;

ElemTypetmp;

for（i=0;

n;

i++）

for（j=0;

j<

j++）{

A[i*n+j]A[j*n+i];

5.算法设计：

设定整数数组B[m][n]的数据