数据结构习题参考答案.docx
- 文档编号:8491255
- 上传时间:2023-01-31
- 格式:DOCX
- 页数:92
- 大小:116.04KB
数据结构习题参考答案.docx
《数据结构习题参考答案.docx》由会员分享,可在线阅读,更多相关《数据结构习题参考答案.docx(92页珍藏版)》请在冰豆网上搜索。
数据结构习题参考答案
参考答案
第1章
一、选择题
1.B2.C3.B4.C
二、填空题
1.数据、数据
2.基本单位
3.数据项、数据项
4.相互关系、组织形式
5.逻辑关系、逻辑关系、数学模型
6.存储结构、存储结构
7.数据的运算、数据的运算、数据的运算
8.集合、集合
9.线性结构
10.树型结构
11.多对多
12.非线性结构、线性结构、非线性结构
13.顺序存储
14.链接存储
15.稠密索引、稀疏索引、稠密索引、稀疏索引、稠密索引、稀疏索引
16.散列存储
17.有限序列
18.有穷
19.确定、相同
20.可行、有限、具体实现
21.正确性、可读性、健壮性、效率
22.运行时间、所占据空间
23.存储空间
三、判断题
1.错误:
树型结构也可以用顺序方式进行存储。
2.错误:
数据元素是数据的基本单位,数据项是数据的最小单位。
3.错误:
算法用各种计算机语言描述表现为一个程序,但是不等于程序,程序逻辑不一定能满足有穷性。
4.正确。
5.正确。
6.正确。
7.正确。
8.正确。
四、综合题
1.该算法的时间复杂度为:
O(m×n)。
2.该算法的时间复杂度为:
O(
)
3.该算法的时间复杂度为:
O(m×n×t)。
4.该算法的时间复杂度为:
log3(n)。
5.该算法的时间复杂度为:
O(
)。
第2章
一、选择题
1.A2.C3.A4.D5.D
6.A7.B8.D9.B10.C
11.C12.C13.D14.D
二、填空题
1.一对一
2.直接前驱、直接后继
3.有限序列、长度、空表
4.顺序存储结构、逻辑顺序、地址相邻
5.任意、任意、不连续、逻辑关系
6.数据域、指针域、链域
7.非顺序、非顺序映像
8.循环链表
9.双向链表
10.所指向的结点本身
11.P->next=p->next->next
12.P->next->prior=P->prior
13.线性表
14.双链表
15.n-i+1
16.n-i
17.S->next=P->next;P->next=S
18.p->prior->next=S;
s->prior=p->prior;
s->next=p;
p->prior=s;
19.head(tail(tail((head(tail(head(A))))))
20.O(n)
21.(L==L->Next)&&(L==L->Prior)
22.线性
23.顶
三、判断题
1.错误:
链表存储中,结点之间可以连续也可以不连续,但结点内部是连续的。
2.错误:
头指针指向头结点而不是数据结点。
3.错误:
顺序存储的线性表可以随机存取。
4.正确。
5.错误。
6.错误:
顺序存储结构是静态存储结构,链式存储结构是动态存储结构。
7.错误:
先行表的长度是线性表中结点的个数。
8.错误:
注意最后一个结点。
9.错误:
也可以有顺序存储的形式。
四、综合题
1.将带头结点单链表逆置的算法如下:
voidreverse_list(linklist*head)
{
/*逆置带头结点的单链表*/
linklist*s,*p;
p=head->next;/*p指向线性表的第一个元素*/
head->next=NULL;/*初始空表*/
while(p!
=NULL)
{
s=p;
p=p->next;
s->next=head->next;
head->next=s;/*将s结点插入逆表*/
}
}/*reverse_list*/
2.把这两个单链表合并成一个按升序排列的单链表,并用hc指向它的头结点的算法如下所示:
linklist*combine_list(linklist*ha,linklist*hb)
{
/*ha,hb分别是两个按升序排列的,带有头结点的单链表的头指针,设计一个算法,把这两个单链表合并成一个按升序排列的单链表,并用hc指向它的头结点*/
linklist*hc,*pa,*pb,*pc,*p,*q,*r;
hc=(linklist*)malloc(sizeof(linklist));/*建立hc头结点*/
p=hc;
pa=ha->next;
free(ha);/*释放ha头结点*/
pb=hb->next;
free(hb);/*释放hb头结点*/
while(pa!
=NULL&&pb!
=NULL)
{
q=(linklist*)malloc(sizeof(linklist));/*产生新结点*/
if(pb->data
{
q->data=pb->data;
pb=pb->next;
}
else
{
q->data=pa->data;
pa=pa->next;
if(pa->data==pb->data)/*将相同的元素删除*/
{
r=pb;
pb=pb->next;
free(r);
}
}
p->next=q;/*将结点链入c链表*/
p=q;
}
while(pa!
=NULL)/*a链表非空*/
{
q=(linklist*)malloc(sizeof(linklist));
q->data=pa->data;
pa=pa->next;
p->next=q;
p=q;
}
while(pb!
=NULL)/*b链表非空*/
{
q=(linklist*)malloc(sizeof(linklist));
q->data=pb->data;
pb=pb->next;
p->next=q;
p=q;
}
p->next=NULL;
return(hc);/*返回*/
}
3.在带头结点的单链表中算法计算所有数据域为x的结点的个数的算法如下所示:
intcount_list(linklist*head)
{
/*在带头结点的单链表中计算所有数据域为x的结点的个数*/
linklist*p;
intn;
p=head->next;/*p指向链表的第一个结点*/
n=0;
while(p!
=NULL)
{
if(p->data==x)
n++;
p=p->next;
}
return(n);/*返回结点个数*/
}/*count_list*/
4.在带头结点的单链表中插入值为x的元素,并使该链表仍然有序的算法如下所示:
linklist*insertx_list(linklist*head,intx)
{
/*在带头结点的单链表中插入值为x的元素,使该链表仍然有序*/
linklist*s,*p,*q;
s=(linklist*)malloc(sizeof(linklist));/*建立数据域为x的结点*/
s->data=x;
s->next=NULL;
if(head->next==NULL||x
{
s->next=head->next;
head->next=s;
}
else
{
q=head->next;
p=q->next;
while(p!
=NULL&&x>p->data)
{
q=p;
p=p->next;
}
s->next=p;
q->next=s;
}/*if*/
}/**insertx_list*/
5.在带头结点的单链表中,实现p所指向的结点和p的后继结点相互交换的算法如下所示:
linklist*swapin_list(linklist*head,linklist*p)
{
/*在带头结点的单链表中,实现p所指向的结点和p的后继结点相互交换*/
linklist*q,*r,*s;
q=p->next;/*q为p的后继*/
if(q!
=NULL)/*若p有后继结点*/
{
if(p==head)/*若p指向头结点*/
{
head=head->next;
s=head->next;
head->next=p;
p->next=s;
}
else/*p不指向头结点*/
{
r=head;/*定位p所指向结点的前驱*/
while(r->next!
=p)
r=r->next;
r->next=q;/*交换p和q所指向的结点*/
p->next=q->next;
q->next=p;
}
return(head);
}
else/*p不存在后继*/
return(NULL);
}/*swapin_list*/
6.在带头结点的非递减有序单链表中,将该链表中多余的元素值相同的结点删除的算法如下所示:
linklist*deldy_list(linklist*head)
{
/*在带头结点的非递减有序单链表,将该链表中多余的元素值相同的结点删除*/
linklist*q;
if(head->next!
=NULL)/*判断链表是否为空*/
{
p=head->next;
while(p->next!
=NULL)
{
if(p->data!
=p->next->data)
p=p->next;
else
{
q=p->next;/*q指向p的后继*/
p->next=q->next;/*删除q所指向的结点*/
free(q);/*释放结点空间*/
}
}/*while*/
}/*if*/
return(head);
}/*deldy_list*/
7.在带头结点的单链表中,删除所有数据域大于min,而小于max的所有元素的算法如下所示:
linklist*dellist_maxmin(linklist*head,intmin,intmax)
{
linklist*p,*q;
q=head;
p=head->next;
while(p!
=NULL)/*结点不空*/
if((p->data<=min)||(p->data>=max))/*不满足删除条件*/
{
q=p;
p=p->next;
}
else/*满足删除条件*/
{
q->next=p->next;
free(p);
q=q->next;
}
}/*dellist_maxmin*/
8.将双链表逆置的算法invert_dblinklist的算法如下所示:
voidinvert_dblinklist(linklist*head)
{
/*将head指向的双链表逆置*/
dblinklist*p,*q;
p=head;
do
{
q=p->next;
p->next=p->prior;
p->prior=q;
p=q;
}while(p!
=head)
}/*invert_dblinklist*/
第3章
一、选择题
1.C2.C3.B4.D5.B
6.C7.C8.A9.A10.C
11.C12.A13.C14.C15.B
二、填空题
1.表尾、栈顶、栈底、空栈
2.进栈、入栈、退栈、出栈
3.栈顶元素、栈顶元素、栈顶元素、最先出栈、后进先出、LIFO
4.顺序、链式、顺序栈、链栈
5.溢出、上溢、溢出、下溢
6.链栈、特殊的单链表
7.中缀表达式
8.后缀表达式、波兰式
9.特殊的线性表、队尾、队头
10.先进先出、先进先出、FIFO
11.顺序存储结构、顺序队列
12.队头元素、队尾元素、队头指针、队尾指针
13.循环队列、取模运算
14.递归函数、自调用函数、直接递归调用、间接递归调用
15.空、满
16.链队列
17.n-1
18.不可能的
19.可能的
20.top!
=maxsize
21.x=sq[top];top=top-1
22.先进后出
23.栈顶指针
24.top==max
25.top!
=nil
26.(n+r-f)modn
27.前一个
28.队首
29.n
30.lq->front==lq->rear
31.栈顶指针
32.队尾
三、判断题
1.正确。
2.错误:
不同的入栈和出栈组合得到不同输出序列。
3.错误:
某些情况如尾递归可以转换为递推的形式。
4.正确。
5.错误:
循环队列不会产生假溢出。
6.错误。
7.正确。
四、综合题
1.所有可能的出栈次序为:
A、B、C、D
A、B、D、C
A、C、B、D
A、C、D、B
A、D、C、B
B、A、C、D
B、A、D、C
B、C、A、D
B、C、D、A
B、D、C、A
C、B、A、D
C、B、D、A
C、D、B、A
D、C、B、A
2.多队列排序的算法设计如下:
#include
#defineMAX10
#defineN100
structnode
{
intdata;
structnode*next;
};
structhnode
{
structnode*link;
}queue[MAX];
main()
{
intA[N],n,i,first=1;
structnode*p,*s,*head;
printf("数值个数n:
");
scanf("%d",&n);
for(i=0;i queue[i].link=NULL; for(i=0;i do { printf("第%d个数: ",i+1); scanf("%d",&A[i]); }while(A[i]<0||A[i]>9); for(i=0;i { s=(structnode*)malloc(sizeof(structnode));/*建立结点*/ s->data=A[i]; s->next=NULL; if(queue[A[i]].link==NULL)/*是相应队列的第一个结点*/ queue[A[i]].link=s; else/*不是相应队列的第一个结点*/ { p=queue[A[i]].link; while(p->next! =NULL) p=p->next;/*p指向该链表的最后一个结点*/ p->next=s; } } head=(structnode*)malloc(sizeof(structnode));/*建立新的总链表头结点*/ head->next=NULL; for(i=0;i { if(queue[i].link! =NULL) { if(first)/*是链入总链表的第一个链表*/ { head->next=queue[i].link; first=0; p=head; while(p->next! =NULL) p=p->next;/*p指向最后结点*/ } else/*不是链入总链表的第一个链表*/ { p->next=queue[i].link; p=queue[i].link; while(p->next! =NULL) p=p->next; } } } printf("\n显示所有元素: \n"); if(head->next! =NULL)/*p指向总链表的首结点*/ p=head->next; while(p! =NULL) { printf("%d",p->data); p=p->next; } } 3.算法设计如下: /*只有一个指针rear的链式队的基本操作*/ #include typedefcharelemtype; structnode/*定义链队列结点*/ { elemtypedata; structnode*next; }; typedefstructqueue/*定义链队列数据类型*/ { structnode*rear; }LinkQueue; voidinitqueue(LinkQueue*Q)/*初始化队列*/ { Q=(structqueue*)malloc(sizeof(structqueue)); Q->rear=NULL; } voidenqueue(LinkQueue*Q,elemtypex)/*入队算法*/ { structnode*s,*p; s=(structnode*)malloc(sizeof(structnode)); s->data=x; if(Q->rear==NULL)/*原为空队时*/ { Q->rear=s; s->next=s; } else/*原队不为空时*/ { p=Q->rear->next;/*p指向第一个结点*/ Q->rear->next=s;/*将s链接到队尾*/ Q->rear=s;/*Q->rear指向队尾*/ s->next=p; } } voiddelqueue(LinkQueue*Q)/*出队算法*/ { structnode*t; if(Q->rear==NULL) { printf("队列为空! \n"); return(0); } elseif(Q->rear->next==Q->rear)/*只有一个结点时*/ { t=Q->rear; Q->rear=NULL; } else/*有多个结点时*/ { t=Q->rear->next;/*t指向第一个结点*/ Q->rear->next=t->next;/*引成循环链*/ } free(t); } elemtypegethead(LinkQueue*Q)/*取队首元素算法*/ { if(Q->rear==NULL) printf("队列为空! \n"); else return(Q->rear->next->data); } intemptyqueue(LinkQueue*Q)/*判断队列是否为空算法*/ { if(Q->rear==NULL)return (1);/*为空,则返回true*/ elsereturn(0);/*不为空,则返回flase*/ } voiddispqueue(LinkQueue*Q)/*显示队列中元素算法*/ { structnode*p=Q->rear->next; printf("队列元素: "); while(p! =Q->rear) { printf("%c",p->data); p=p->next; } printf("%c\n",p->data); } 4.“回文”判定算法设计如下: intisPalindrome() { /*回文判定算法*/ InitStack(S); InitQueue(Q); While((c=read())! ='#') { push(S,c);/*读入字符分别保存在栈和队列中*/ EnQueue(Q,c); } While(! QmptyStack(S)&&! EmptyQueue(Q)) { if(pop(S)! =DelQueue(Q))/*正序和逆序字符的比较*/ return(FALSE); } if(! EmptyStack(S)||! EmptyQueue(Q) return(FALSE); return(TRUE); }/*isPalindrome*/ 5.表达式中括号是否正确配对的算法。 #include"stdio.h" #include"stdlib.h" #defineFALSE0 #defineTRUE1 #defineLENsizeof(structnode) structnode { chardata; structnode*next; }; typedefstructnode*stack; voidpush_stack(stack*,char); intpop_stack(stack*); voidmain() { stacks; intvalid=TRUE; charch,symble; symble=getchar(); s=NULL; push_stack(&s,'#'); while((symble! ='#')&&(valid==TRUE)) { if(symble! ='('&&symble! =')'&&symble! ='['&&symble! =']' &&symble! ='{'&&symble! ='}') { symble=getchar(); } elseif(symble=='('||symble=='['||symble=='{') { push_stack(&s,symble); symble=getchar(); } elseif(s==NULL) { valid=FAL
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构 习题 参考答案
![提示](https://static.bdocx.com/images/bang_tan.gif)