数据结构习题17答案.docx
《数据结构习题17答案.docx》由会员分享，可在线阅读，更多相关《数据结构习题17答案.docx（19页珍藏版）》请在冰豆网上搜索。
数据结构习题17答案
第一章绪论
一.选择题
1．BD2．CA3．B4．C5．A6．D7．A8．A9．A10．C
二.解答题
第二章线性表
一.选择题
1．A2．B3．A4．D5．A6．C7．A8．B9．A
二.填空题
1．.物理位置相邻指针
2．.直接前驱直接后继
3．顺序链式
三.算法设计题
1．
intcount（Linklisth,intx）
{
intnum=0;
Linknode*p;
p=h->next;
while（p&&p->data<=x）//p指针向后移动，直至p指向第一个值大于x的结点
p=p->next;
while（p）
if（p->next&&p->data==p->next->data）
//若p没有指向链表中同一数值的最后一个结点，则向后移动
p=p->next;
else
//若p指向数值相同的结点中的最后一个，则num加1，p指针后移，继续执行while循环
{
num++;
p=p->next;
}
returnnum;
}
voiddelevenl（Linklist&h,intx）
{
Linknode*p,*r;
p=h->next;r=h;
while（p&&p->data{
if（p->data%2==0）
{
r->next=p->next;
free（p）;
p=r->next;
}
else
{
r=p;
p=p->next;
}
}
}
2．voidconverse（Linklist&h）
{
Linknode*p,*q;
p=h->next;
h->next=NULL;
while（p）
{
q=p->next;
p->next=h->next;
h->next=p;
p=q;
}
}
3．voiddecompose（LinklistLa,Linklist&Lb,Linklist&Lc）
{
Linknode*p;
Lc=（Linknode*）malloc（sizeof（Linknode））;
Lc->next=NULL;
p=La->next;
Lb=La;
Lb->next=NULL;
while（p）
{
La=p->next;
if（p->data>0）
{
p->next=Lc->next;
Lc->next=p;
}
else
{
p->next=Lb->next;
Lb->next=p;
}
p=La;
}
}
4．intsubset（LinkListla,LinkListlb）
{LinkNode*pa,*pb;
pa=la->next;
while（pa）
{pb=lb->next;
while（pb&&（pb->data!
=pa->data））pb=pb->next;
if（!
pb）return0;
pa=pa->next;
}
return1;
}
算法时间复杂度O（A.Length*B.Length）
5．voidpriorset（DuLinkList&la）
{p=la;q=la->next;
while（q!
=la）{q->prior=p;p=q;q=q->next;}
q->prior=p;
}
第三章栈和队列
一.选择题
1．CC2．C3．B4．D5．C6．A7．C8．D
二.解答题
1．双向栈
栈底1
……….
………
栈底2
//双向栈类型定义
#defineSTACK_SIZE100;
Typedefstruct{
SElemType*base_one,*base_two;//栈底指针
SElemType*top_one,*top_two;//栈顶指针
intstacksize;
}SqStack;
StatusInitStack（SqStack&S）{
//初始化双向栈
S.base_one=S.top_one=（SElemType*）malloc（STACK_SIZE*sizeof（SElemType））;//第一个栈底和栈顶指向数组起点
S.base_two=S.top_two=S.base_one+STACK_SIZE-1;//第二个栈底和栈顶指向数组终点
S.stacksize=STACK_SIZE;
returnOK;
}//InitStack
StatusPush（SqStack&S,inti,SElemTypee）{
//入栈操作，i=0时将e存入前栈，i=1时将e存入后栈
if（S.top_twoif（i==0）
*S.top_one++=e;
else
*S.top_two--=e;
returnOK;
}//Push
SElemTypePop（SqStack&S,inti）{
//出栈操作，i=0出前栈，i=1出后栈
if（i==0）{
if（S.top_one==S.base_one）returnERROR;
S.top_one--;e=*S.top_one;
}
else{
if（S.top_two==S.base_two）returnERROR;
S.top_two++;e=*S.top_two;
}
returne;
}//Pop
2．#defineM3
structStack{
Qelemtypedata[M];
inttop;
};
structQueue{
Stacks1;
Stacks2;
};
voidInitQueue（Queue&Q）//初始化队列
{
Q.s1.top=0;
Q.s2.top=0;
}
intIsEmpty（Queue&Q）//判断队列是否为空
{
if（Q.s1.top==0&&Q.s2.top==0）
return1;
if（Q.s2.top==0&&Q.s1.top!
=0）
{
while（Q.s1.top!
=0）
Q.s2.data[Q.s2.top++]=Q.s1.data[--Q.s1.top];
}
return0;
}
intIsFull（Queue&Q）
{
if（Q.s1.top==M&&Q.s2.top!
=0）
return1;
if（Q.s1.top==M&&Q.s2.top==0）
{
while（Q.s1.top!
=0）
Q.s2.data[Q.s2.top++]=Q.s1.data[--Q.s1.top];
return0;
}
if（Q.s1.top!
=M）
return0;
}
voidInQueue（Queue&Q,Qelemtypee）
{
if（IsFull（Q））
{
cout<<"OVERFLOW"<return;
}
Q.s1.data[Q.s1.top++]=e;
}
voidDeQueue（Queue&Q,Qelemtype&e）
{
if（IsEmpty（Q））
{
cout<<"UNDERFLOW"<return;
}
e=Q.s2.data[--Q.s2.top];
}
3．
（1）不能
（2）可以原因略
4．structQueueNode
{
Qelemtypedata;
QueueNode*next;
};
structLinkQueue
{
QueueNode*rear;
};
voidInitQueue（LinkQueue&Q）//置空队
{
Q.rear=newQueueNode;
Q.rear->next=Q.rear;
}
intEmptyQueue（LinkQueueQ）//判队空
{
returnQ.rear==Q.rear->next;
}
voidEnQueue（LinkQueue&Q,Qelemtypee）//元素入队
{
QueueNode*p;
//新建一个结点，并置其值为e
p=newQueueNode;
p->data=e;
//将结点插入队列末尾
p->next=Q.rear->next;
Q.rear->next=p;
//修改队尾指针
Q.rear=p;
}
voidDeQueue（LinkQueue&Q,Qelemtype&e）//元素出队
{
QueueNode*p;
if（EmptyQueue（Q））//若队中无元素，则无法执行出队操作
{
cout<<"error"<return;
}
p=Q.rear->next->next;//让p指向队头元素
e=p->data;
if（p==Q.rear）//如队中只有一个元素，则要rear指向头结点，头结点的next指针指向自身
{
Q.rear=Q.rear->next;
Q.rear->next=Q.rear;
}
else//若队中不只一个元素，则删除p所指向的结点。
Q.rear->next->next=p->next;
deletep;//释放被删除结点的存储空间
}
5．
typedefstruct
{
chardata[10];
inttop;
}stack;
intdescion（char*str）
{
stacks;
inti;
s.top=0;
for（i=0;str[i];i++）
{
switch（str[i]）
{
case'I':
s.data[s.top++]=str[i];break;//若为I，则如栈
case'O':
if（s.top==0）return0;s.top--;//若为O，则从栈中弹出一个I
}
}
if（s.top==0）return1;
elsereturn0;
}
第四章串
一.选择题
1．B2．B3．D4．A5．D
二.填空题
1．0123011123201112231234532211
2．空格数0
3．11
三.解答题
StatusIsHuiwen（char*S）
{i=0;
while（s[i]!
=’\0’）i++;
i=i-1;j=0;
while（jif（s[j]!
=s[i]）return0;
else{j++;i--;}
return1;
}
第五章数组和广义表
一.选择题
1．B2．B3．C4．D5．B6．B7．B8．A
二.填空题
1．1038
2．（）（（））22
3．Head（Tail（Tail（Head（Tail（Head（A））））））
三.解答题
1．
2．
第六章树和二叉树
一．选择题
CDDACADDEDBCCBBCACCC
二．填空题
1
346412AFG
22K-12K-12K-1
35
48
5h
三．
二叉树如下先序序列：
ABCDEFGHIJ先序线索二叉树略。
四1所有结点只有右子树的二叉树
2所有结点只有左子树的二叉树
3只有根结点的二叉树
五intDepth（BiTreet）（后序遍历）
{if（！
t）
d=0；
else
{dl=Depth（t->lchild）;
dr=Depth（t->rchild）;
d=1+（dl>dr?
dl:
dr）;}
returnd;
}
六//根据二叉树的先序序列和中序序列创建二叉链表
voidcreateBiTree（charpre[],charin[],intstart,intend,int&count,BiTree&T）
//按先序次序创建二叉链表，pre为存放先序序列的字符数组，in为存放中序序列的字符数组，
//count为二叉树的根结点在先序序列中的序号
//start和end为以pre[count]为根的二叉树在中序序列中的起始位置和结束位置
//T为二叉链表的根指针，
{
if（start>end）T=0;
else
{T=（BiTNode*）malloc（sizeof（BiTNode））;//新建根结点
if（!
T）exit（0）;
T->data=pre[count];T->lchild=T->rchild=0;
for（inti=0;in[i]!
='\0';i++）//查找根结点在中序序列in[]中的下标
if（in[i]==pre[count]）break;
count++;
if（in[i]=='\0'）cout<<"inputerror"<else{
createBiTree（pre,in,start,i-1,count,T->lchild）;//根据先序序列和中序序列创建左子树
createBiTree（pre,in,i+1,end,count,T->rchild）;//根据先序序列和中序序列创建右子树
}
七、
哈夫曼树
a:
10b:
110c:
010d:
1110e:
011f:
:
00g:
1111
等长编码至少需要3位二进制位。
八voidpreintraverse（BiTreeT,int&n）
{if（T）
{n++;
if（n<=k）{cout<data;
intraverse（T->lchild,n）;
intraverse（T->rchild,n）;}
}
}
九、voidCountLeaf（BiTreet，int&count）（先序遍历）
{if（t）
{if（（t->lchild==NULL）&&（t->rchild==NULL））
count++;
CountLeaf（t->lchild，&count）;
CountLeaf（t->rchild,&count）;
}
}
第7章图
一、选择题
CABA
二、1
A
B
C
D
入度
1
1
2
1
出度
2
1
1
1
度
3
2
3
2
2
三、
事件
A
B
C
D
E
F
最早发生时间ve[i]
0
3
2
6
6
8
最迟发生时间vl[i]
0
4
2
6
7
8
活动
a1
a2
a3
a4
a5
a6
a7
a8
最早开始时间
0
0
3
3
2
2
6
6
最迟开始时间
1
0
4
4
2
5
6
7
关键活动为a2a5a7,加速这些关键活动可使整个工程提前完成。
四、拓扑有序序列
ABCDEF
ABCEDF
ACBDEF
ACBEDF
ACEBDF
第9章查找
一填空题
1顺序
212430（1+2*2+3*4+4*3）/10=2.9
39
二、选择题
1B2C3AB4B
三、
1、二叉排序树如下：
2、H（33）=0H（41）=2H（20）=5H（24）=6
H（30）=2冲突d1=2H1=（H（K）+d1）%11=4
H（13）=6冲突d1=6H1=（H（K）+d1）%11=1
H（01）=3
H（63）=2冲突d1=2H1=（H（K）+d1）%11=4冲突
d2=（2+（7*63）%10+1）%11=4H2=（H（K）+d2）%11=（2+4）%11=6冲突
d3=（4+（7*63）%10+1）%11=6H3=（H（K）+d3）%11=（2+6）%11=8
33
13
41
01
30
20
24
63
012345678910
等概率情况下查找成功的平均查找长度=（1*5+2*2+1*4）/8=13/8
升级会员 