数据结构C语言版习题及答案第二章.docx
《数据结构C语言版习题及答案第二章.docx》由会员分享，可在线阅读，更多相关《数据结构C语言版习题及答案第二章.docx（15页珍藏版）》请在冰豆网上搜索。
数据结构C语言版习题及答案第二章
习题
2.1选择题
1、线性表的顺序存储结构是一种（A）的存储结构，线性表的链式存储结构是一种（B）的存储结构。
A、随机存取B、顺序存取C、索引存取D、散列存取
2、对于一个线性，既要求能够进行较快的插入和删除，又要求存储结构能够反映数据元素之间的逻辑关系，则应该选择（B）。
A、顺序存储方式B、链式存储方式
C、散列存储方式D、索引存储方式
3、已知，L是一个不带头结点的单链表，p指向其中的一个结点，选择合适的语句实现在p结点的后面插入s结点的操作（B）。
A、p->next=s;s->next=p->next;B、s->next=p->next;p->next=s;
C、p->next=s;s->next=p;D、s->next=p;p->next=s;
4、单链表中各结点之间的地址（CD）。
A、必须连续B、部分地址必须连续
C、不一定连续D、连续与否都可以
5、在一个长度为n的顺序表中向第i个元素（0A、n-iB、n-i+1C、n-i-1D、i
2.2填空题
1、顺序存储的长度为n的线性表，在任何位置上插入和删除操作的时间复杂度基本上都一样。
插入一个元素大约移动表中的（n/2）个元素，删除一个元素时大约移动表中的（（n-1）/2）个元素。
2、在线性表的顺序存储方式中，元素之间的逻辑关系是通过（物理顺序）来体现的；在链式存储方式，元素之间的逻辑关系是通过（指针）体现的。
3、对于一个长度为n的单链表，在已知的p结点后面插入一个新结点的时间复杂度为（o
（1）），在p结点之前插入一个新结点的时间复杂度为（o（n）），在给定值为e的结点之后插入一个新结点的时间复杂度为（o（n））。
4、在双向链表中，每个结点包含两个指针域，一个指向（前驱）结点，另一个指向（后继）结点。
5、对于循环链表来讲，逐个访问各个结点的结束判断条件是（设P为指向结点的指针，L为链表的头指针，则p->next==L）。
2.3读下面的程序段，画出执行过程的示意图及所完成的功能。
1、#defineN6
voidmain（）
{ListSqL;
intA[N];
inti,elem;
InitList（L）;//初始化函数
for（intj=0;jscanf（"%d",&A[j]）;
for（intm=0;mInsertList（L,m,A[m]）;
PrintList（L）;//输出函数}
1题示意图
2题示意图
功能：
先初始化一个顺序表，然后根据数组A中元素的顺序创建顺序表，并输出顺序表的全部元素。
2、Lnode*CreateList（）
{Lnode*L,*S;
intx,y;
L=malloc（sizeof（Lnode））;
L->data=x;
s=malloc（sizeof（Lnode））;
s->data=y;
L->next=s;
s->next=NULL;
returnL;
}
功能：
创建一个两个结点的不带头结点的单链表，两个结点的值分别为X和Y，L为单链表的头指针。
2.4算法题
1、编写在两种存储方式下，删除线性表中多余的值相同元素的算法。
解：
顺序存储方式下：
voiddel（ListSq&L）
{inti=0;
while（i{intj=i+1;
while（jif（L.e[i]==L.e[j]）
{for（intk=j+1;kL.e[k-1]=L.e[k];
L.len--;
}
elsej++;
i++;
}}
链式存储方式下：
voiddel（Lnode*L）
{Lnode*p=L->next;
while（p->next!
=NULL）
{Lnode*q=p->next;
Lnode*r=p;
while（q!
=NULL）
if（q->data==p->data）
{r->next=q->next;free（q）;q=r->next;}
else{r=q;q=q->next;}
p=p->next;
}}
2、已知，顺序表的元素类型为整型，编写将该顺序表分成两个顺序表的算法，一个存放所的奇数元素，另一个存放所的偶数元素。
解：
voidfenSq（ListSqL,ListSq&La,ListSq&Lb）
{intj=0,k=0;
for（inti=0;iif（L.e[i]%2==0）
{Lb.e[j]=L.e[i];j++;}
else{La.e[k]=L.e[i];k++;}
La.len=k;
Lb.len=j;
}
3、编写一个统计单循环链表的结点个数的算法。
解：
intcount（Lnode*L）
{Lnode*p=L->next;
intn=0;
while（p!
=L）
{n++;p=p->next;}
returnn;
}
4、编写删除有序单链表中元素值大于min并且小于max的全部元素的算法。
如果给定的表是无序的，如何改写上面的算法。
解：
voiddel4（Lnode*L,Elemtypemin,Elemtypemax）
{Lnode*q,*s,*p;
p=L->next;q=L;
while（p!
=NULL&&p->date<=min）
{q=p;p=p->next;}
if（p!
=NULL）//表示存在大于min的结点，最后一个小于等于min的结点为q结点
{
while（p!
=NULL&&p->datep=p->next;
if（p!
=NULL）//表示存在大于等于max的结点，既p结点
while（q->next!
=p）//删除q的后继结点到p的前驱结点为止的所有结点
{s=q->next;q->next=s->next;free（s）;}
else
{s=q->next;q->next=NULL;//q以后的结点全部要删除
while（s!
=NULL）
{p=s->next;free（s）;s=p;}}}
5、用顺序表来求集合的并集、交集和差集，也可以用链表来实现以上操作。
（作为上机实践题目）
#include
typedefintElemtype;
#definemaxlen100
#defineN30
structListSq
{
Elemtypee[maxlen];
intlen;
};
//顺序表的创建算法
voidCreate_Sq（ListSq&L,ElemtypeA[],intn）
{
inti;
for（i=0;iL.e[i]=A[i];
L.len=n;
}
//顺序表的输出算法
voidPrintList（ListSqL）
{
printf（"当前集合为:
\n"）;
for（inti=0;iprintf（"%d\t",L.e[i]）;
printf（"\n"）;
}
voidbingji（ListSqL1,ListSqL2,ListSq&L3）
{
for（intk=0;kL3.e[k]=L1.e[k];
L3.len=L1.len;
for（inti=0;i{intj=0;
while（（j=L1.e[j]））
j++;
if（j>=L1.len）
{
L3.e[L3.len]=L2.e[i];
L3.len++;
}
}
}
voidjiaoji（ListSqL1,ListSqL2,ListSq&L3）
{
intk=0;
for（inti=0;i{
intj=0;
while（（j=L2.e[j]））
j++;
if（jL3.e[k++]=L1.e[i];
}
L3.len=k;
}
voidchaji（ListSqL1,ListSqL2,ListSq&L3）
{
intk=0;
for（inti=0;i{
intj=0;
while（（j=L2.e[j]））
j++;
if（j>=L2.len）
L3.e[k++]=L1.e[i];
}
for（intm=0;m{
intn=0;
while（（n=L1.e[n]））
n++;
if（n>=L1.len）
L3.e[k++]=L2.e[m];
}
L3.len=k;
}
//主函数
voidmain（）
{
ListSqL1,L2,L3;
L3.len=0;
intA[N];
intm,n,c;
printf（"请输入线性表L1的元素个数:
\n"）;
scanf（"%d",&m）;
printf（"请输入线性表L1的元素:
\n"）;
for（intj=0;jscanf（"%d",&A[j]）;
Create_Sq（L1,A,m）;
PrintList（L1）;
printf（"请输入线性表L2的元素个数:
\n"）;
scanf（"%d",&n）;
printf（"请输入线性表L2的元素:
\n"）;
for（intw=0;wscanf（"%d",&A[w]）;
Create_Sq（L2,A,n）;
PrintList（L2）;
while
（1）
{
printf（"请按提示进行输入：
\n"）;
printf（"实现两个集合的并集，请输入1：
\n"）;
printf（"实现两个集合的交集，请输入2：
\n"）;
printf（"实现两个集合的差集，请输入3：
\n"）;
printf（"退出，请输入4：
\n"）;
scanf（"%d",&c）;
switch（c）
{
case1:
{
bingji（L1,L2,L3）;
PrintList（L3）;
break;
}
case2:
{
jiaoji（L1,L2,L3）;
PrintList（L3）;
break;
}
case3:
{
chaji（L1,L2,L3）;
PrintList（L3）;
break;
}
case4:
return;
default:
printf（"输入有误！
\n"）;
}
}
}
6、用循环单链表来实现约瑟夫问题。
（作为上机实践题目）
#include
#include
typedefstructLnode{
intdata;
Lnode*next;
}*Link;
voidCreateList（Link&L,intn）
//建立一个n个结点的循环单链表
{
inti;Lnode*p,*s;
s=（Lnode*）malloc（sizeof（Lnode））;
s->data=1;
L=p=s;
for（i=2;i<=n;i++）
{
s=（Lnode*）malloc（sizeof（Lnode））;
s->data=i;
p->next=s;
p=s;
}
p->next=L;
}
voidDeleteList（Link&L,Lnode*p,Lnode*q）//从循环单链表中删除结点p
{
q->next=p->next;//修改结点的指针域
free（p）;//释放p结点所占存储空间
}
voidjosephus（Link&L,ints,intm）
{
Lnode*p,*q;
p=L;
for（inti=1;i<=s-1;i++）p=p->next;
q=p->next;
while（q->next!
=p）q=q->next;
while（p->next!
=p）
{
for（intj=1;j{
q=p;p=p->next;
}
printf（"%d,",p->data）;
DeleteList（L,p,q）;
p=q->next;
}
printf（"%d",p->data）;
printf（"\n"）;
}
voidmain（）
{
LinkL=NULL;
intm,n,s;
printf（"请输入围圈人数、报数的开始位置和报数的上限\n"）;
scanf（"%d,%d,%d",&n,&s,&m）;
if（（m>1000）||（n>1000））printf（"输入值m或n不合法！
\n"）;
else
if（s>n）printf（"输入值s和n不合法！
\n"）;
else
{
CreateList（L,n）;
printf（"\n"）;
josephus（L,s,m）;
}
}
7、某百货公司对仓库中的库存电视进行管理时，按其价格从低到高的次序构成一个循环单链表来保存信息，每个结点包含价格、数量和指针三个域。
现新到m台价格为h的电视机，编写修改原信息链表的算法。
（作为上机实践题目）
#include
#include
structElemtype
{
floatjiage;
intshuliang;
};
structLnode
{
Elemtypedata;
structLnode*next;
};
//单链表的后插入创建算法
voidRcreate（Lnode*L,ElemtypeA[],intn）
{
inti;
Lnode*p,*s;
p=L;
for（i=0;i{
s=（Lnode*）malloc（sizeof（Lnode））;
s->data=A[i];
s->next=p->next;
p->next=s;
p=s;
}
}
//单链表的输出算法
voidprintList（Lnode*L）
{Lnode*p;
if（L->next==L）
printf（"单链表为空！
\n"）;
else
{
p=L->next;
printf（"当前仓库中库存的电视相关信息为:
\n"）;
printf（"价格\t\t数量\n"）;
while（p->next!
=L）
{
printf（"%f\t",p->data.jiage）;
printf（"%d\n",p->data.shuliang）;
p=p->next;
}
printf（"%f\t",p->data.jiage）;
printf（"%d\n",p->data.shuliang）;
}
}
voidInsert（Lnode*L,Elemtypeelem）
{
Lnode*s;
s=（Lnode*）malloc（sizeof（Lnode））;
s->data=elem;
if（L->next==L）
{
s->next=L->next;
L->next=s;
}
else
{
Lnode*p=L,*q=L->next;
while（（q!
=L）&&q->data.jiagedata.jiage）
{
p=q;
q=q->next;
}
s->next=q;
p->next=s;
}
}
//主函数
voidmain（）
{Lnode*L;
intn;
ElemtypeA[50],elem;
printf（"请输入仓库中库存的电视的台数：
\n"）;
scanf（"%d",&n）;
printf（"按价格从低到高输入电视信息：
\n"）;
for（intj=0;j{
scanf（"%f,",&A[j].jiage）;
scanf（"%d",&A[j].shuliang）;
}
L=（Lnode*）malloc（sizeof（Lnode））;
L->next=L;
Rcreate（L,A,n）;
printList（L）;
printf（"请输入新到的电视相关信息！
\n"）;
printf（"请输入价格:
"）;
scanf（"%f",&elem.jiage）;
printf（"请输入数量:
"）;
scanf（"%d",&elem.shuliang）;
printf（"\n"）;
Insert（L,elem）;
printList（L）;
}
升级会员 