数据结构习题有答案讲解Word格式文档下载.docx
《数据结构习题有答案讲解Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《数据结构习题有答案讲解Word格式文档下载.docx（19页珍藏版）》请在冰豆网上搜索。
2222262（3）
11?
k1j1?
i1?
1in（n?
1）（n?
2）?
6
1.3指出下列个算法的功能，并求其时间复杂度。
（1）intsum1（intn）{intp=1,s=0;
i<
i++）{p*=i;
s+=p;
}returns;
（2）intsum2（intn）解：
{ints=0;
n?
i!
（1）
T（n）=O（n）
for（inti=1;
i++）i?
1{intp=1;
for（intj=1;
j++）p*=j;
2i!
）
T（n）=O（n,
（2）
i?
1}returns;
算法设计1.4
枚是假的，伪币与真币重量略有不同。
如何借用一架13枚硬币，其中有有开始天平，找出伪币？
以流程图表示算法。
是A=B？
C是伪币否是A=C？
B是伪币否A是伪币结束
上机练习题
要求：
给出问题分析、算法描述、源程序及运行截图，在线提交。
个整数，求其中位于中间值的整数。
3为a,b,c设1.
第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次nn1n（n?
1）11n?
n（）?
fn2n2n1i1?
对于有头结点的单链表，分别写出定位成功时，实现下列定位3.语句序列。
；
a
（1）定位到第i个结点i
p=head;
j=0;
while（p&
&
i）{p=p->
next;
j++;
i
（2）定位到第个结点的前驱；
ai-1
i-1）{p=p->
定位到尾结点；
（3）
while（p->
next）p=p->
（4）定位到尾结点的前驱。
p=p->
while（p->
next->
next）
4.描述一下三个概念的区别：
头指针，头结点，首元结点。
并给予图示。
头指针：
是一个指针变量，里面存储的是链表中首结点的地址，并以此来标识一个链表。
头结点：
附加在第一个元素结点之前的一个结点，头指针指向头结点。
首元结点：
指链表中的第一个元素结点。
头指针结点）元尾（头结点结点首）元（…...aaa^n12
i个结点的算法描述。
5.对于无头结点单链表，给出删除第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-1p=Head;
j=1;
//定位查找起始位置
while{p->
next&
i-1}{
j++;
if（!
p->
next||j>
i-1）;
//定位失败
throw“删除位置不合理”;
else{//定位成功，进行结点删除
q=p->
x=p>
p->
next=q->
deleteq;
retrunx;
//返回被删除元素值
}//#
6.用教材定义的顺序表的基本操作实现下列操作：
template<
intDeleteElem（SqListL,Te）
#include“SqList.h“template<
intDeleteElem（SqListL,Te）{//按值查找i=L.LocateElem（e）;
//
if（!
i）//未找到
return0;
else//找到
delete（i）;
//删除被找到的元素
7.已知L是有表头结点的单链表，且P结点既不是首元结点，也不是尾结点，试写出实现下列功能的语句序列。
结点；
结点后插入
（1）在PSS
（2）在P结点前插入结点；
（3）在表首插入S结点；
.
S（4）在表尾插入结点
【解】
（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;
while（q->
=NULL）q=q->
s->
next=q->
q->
的元素。
e编程实现：
删除单链表中值为
第3章栈与队列
1.铁路进行列车调度时,常把站台设计成栈式结构的站台，如右图所示。
试问：
65那么,若进站的六辆列车顺序如上所述4321的出站序和154623325641是否能够得到
如果能;
说明为什么不能如果不能列,,
的进栈即写出（说明如何得到出栈或。
）序列．
解：
325641可以
154623不可以。
2.简述以下算法的功能（栈的元素类型为int）。
{
（1）statusalgo_1（SqStackS）i,n,A[255];
intn=0;
}while（!
S.StackEmpty（））{n++;
A[n]=S.Pop（）;
（i=1;
=n;
i++）S.Push（A[i]）;
for}e）{status
（2）algo_2（SqStackS,intSqStackT;
intd;
while（!
S.tackEmpty（））{
d=S.Pop（）;
（d!
=e）T.Push（d）;
if}{（!
T.StackEmpty（））while
d=T.Pop（）;
}T.Push（d）;
}
（1）借助一个数组，将栈中的元素逆置。
（2）借助栈T，将栈S中所有值为e的数据元素删除之。
进制数，3.编写一个算法，将一个非负的十进制整数NB转换为并输出转换后的结果。
当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;
）'
//右括号
if（s.StackEmpty（））return0;
//栈空，不匹配，多右括号
else{s.Pop（）;
}//左括号出栈
}//switch
p++;
//取表达式下一个字符
}//while
表达式结束，栈不空if（!
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）{cout<
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;
while（x）{S.push（x）;
}sum=0;
while（x=S.pop（））{
}//
）。
int简述以下算法的功能（栈和队列的元素类型均为10.
利用栈，将队列中的元素逆置
voidalgo（Queue&
Q）
{
StackS;
//创建一个栈
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
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'
“'
t=”<
t<
endl;
cout<
“v=”<
v;
“u=”<
StrRep（u,v,w）;
}//demonstrate
t=THESEAREBOOKSv=YXYw=XWXWXW
2.设字符串S=‘aabaabaabaac'
，P=‘aabaac'
nextvalP1）给出S和的next值和值；
算法的匹配过程。
作模式串，试给出作主串，）若2SPKMP
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;
相同的子串。
t中删除所有和串s编写算法，从串
（2）
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;
len2++;
if（len2>
len1）{//将较大长度者给index和len1
index=i;
len1=len2;
j+=len2;
}//if
elsej++;
}//while
”最长公共子串：
for（i=0;
len1;
）
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。
试利用下列运算，将已知：
s='
（XYZ）+*'
，t='
（X+Z）*Y'
。
t为StrConcat（&
S,T）
联接：
求子串：
（char*）StrSub（S,i,len）
StrRep（&
S,T,R）
置换：
串结构定义如下：
串首址//；
char*data
串长//intlen;
.存放数组的最大长度intStrSize；
不区分英文字所含不同字符的总数和每种字符的个数，S串求：
母的大小写。
．
第5章数组与压缩矩阵
1.假设有二维数组A，每个元素用相邻的6个字节存储，存储器按86×
，计算：
字节编址。
已知A的起始存储位置（基地址）为1000A
（1）数组的体积（即存储量）;
;
A的第一个字节的地址的最后一个元素a
（2）数组57;
的第一个字节的地址a（3）按行存储时，元素14a的第一个字节的地址。
（4）按列存储时，元素47
（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.A85×
9×
3×
，每个
升级会员 