第二章 线性表习题.docx
《第二章 线性表习题.docx》由会员分享，可在线阅读，更多相关《第二章 线性表习题.docx（12页珍藏版）》请在冰豆网上搜索。
第二章线性表习题
第二章线性表 习题
判断题
1.线性表的链接存储，表中元素的逻辑顺序与物理顺序一定相同。
（ ）
选择题
1.一个线性表第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是（）
（A）110（B）108（C）100（D）120
3.向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动（）个元素。
（A）64（B）63（C）63.5 （D）7
4.线性表采用链式存储结构时，其地址（）。
（A）必须是连续的（B）部分地址必须是连续的
（C）一定是不连续的（D）连续与否均可以
5.在一个单链表中，若p所指结点不是最后结点，在p之后插入s所指结点，则执行（）
（A）s->next=p;p->next=s;（B）s->next=p->next;p->next=s;
（C）s->next=p->next;p=s;（D）p->next=s;s->next=p;
6.在一个单链表中，若删除p所指结点的后续结点，则执行（）
（A）p->next=p->next->next;（B）p=p->next;p->next=p->next->next;
（C）p->next=p->next;（D）p=p->next->next;
7.下列有关线性表的叙述中，正确的是（ ）
（A）线性表中的元素之间隔是线性关系
（B）线性表中至少有一个元素
（C）线性表中任何一个元素有且仅有一个直接前趋
（D）线性表中任何一个元素有且仅有一个直接后继
8.线性表是具有n个（）的有限序列（n≠0）
（A）表元素（B）字符（C）数据元素 （D）数据项
填空题
1.已知P为单链表中的非首尾结点，在P结点后插入S结点的语句为：
（）。
2.顺序表中逻辑上相邻的元素物理位置（一定）相邻，单链表中逻辑上相邻的元素物理位置（）相邻。
3.线性表L＝（a1，a2，...，an）采用顺序存储，假定在不同的n＋1个位置上插入的概率相同，则插入一个新元素平均需要移动的元素个数是（）
算法设计题
1、试编写一个求已知单链表的数据域的平均值的函数（数据域数据类型为整
型）。
解答：
#include"stdio.h"
#include"malloc.h"
typedefstructnode
{intdata;
structnode*link;
}NODE;
intaver（NODE*head）
{inti=0,sum=0,ave;NODE*p;
p=head;
while（p!
=NULL）
{p=p->link;++i;
sum=sum+p->data;}
ave=sum/i;
return（ave）;}
2、已知带有头结点的循环链表中头指针为head,试写出删除并释放数据域值
为x的所有结点的c函数。
解答：
#include"stdio.h"
#include"malloc.h"
typedefstructnode
{
intdata;/*假设数据域为整型*/
structnode*link;
}NODE;
voiddel_link（NODE*head,intx）/*删除数据域为x的结点*/
{
NODE*p,*q,*s;
p=head;
q=head->link;
while（q!
=head）
{
if（q->data==x）
{
p->link=q->link;
s=q;
q=q->link;
free（s）;
}
else
{
p=q;
q=q->link;
}
}
}
3、某百货公司仓库中有一批电视机，按其价格从低到高的次序构成一个循环
链表，每个结点有价格、数量和链指针三个域。
现出库（销售）m台价格
为h的电视机，试编写算法修改原链表。
解答：
voiddel（NODE*head,floatprice,intnum）
{
NODE*p,*q,*s;
p=head;q=head->next;
while（q->price=head）
{
p=q;
q=q->next;
}
if（q->price==price）
q->num=q->num-num;
else
printf（"无此产品"）;
if（q->num==0）
{
p->next=q->next;
free（q）;
}
}
4、某百货公司仓库中有一批电视机，按其价格从低到高的次序构成一个循环
链表，每个结点有价格、数量和链指针三个域。
现新到m台价格为h的电视机，试编写算法修改原链表。
#include"stdio.h"
#include"malloc.h"
typedefstructnode
{
floatprice;
intnum;
structnode*next;
}NODE;
voidins（NODE*head,floatprice,intnum）
{
NODE*p,*q,*s;
p=head;q=head->next;
while（q->price=head）
{
p=q;
q=q->next;
}
if（q->price==price）
q->num=q->num+num;
else
{
s=（NODE*）malloc（sizeof（NODE））;
s->price=price;
s->num=num;
s->next=p->next;
p->next=s;
}
}
算法设计题部分
1、线性表中的元素值按递增有序排列，针对顺序表和循环链表两种不同的存储方式，分别编写C函数删除线性表中值介于a与b（a≤b）之间的元素。
顺序表：
算法思想：
从0开始扫描线性表，用k记录下元素值在a与b之间的元素个数，对于不满足该条件的元素，前移k个位置，最后修改线性表的长度。
voiddel（elemtypelist[]，int*n，elemtypea，elemtypeb）
{
inti=0，k=0；
while（i{
if（list[i]>=a&&list[i]<=b）k++;
else
list[i-k]=list[i];
i++;
}
*n=*n-k;/*修改线性表的长度*/
}
循环链表:
voiddel（NODE*head,elemtypea,elemtypeb）
{
NODE *p,*q;
p=head;q=p->link;/*假设循环链表带有头结点*/
while（q!
=head&&q->data{
p=q;
q=q->link;
}
while（q!
=head&&q->data{
r=q;
q=q->link;
free（r）;
}
if（p!
=q）
p->link=q;
}
算法设计题部分
设A=（a0,a1,a2,...,an-1）,B=（b0,b1,b2,...,bm-1）是两个给定的线性表,它们的结点个数分别是n和m,且结点值均是整数。
若n=m，且ai=bi（0≤i若n若存在一个j，jB。
试编写一个比较A和B的C函数，该函数返回-1或0或1，分别表示AB。
#defineMAXSIZE100
intlistA[MAXSIZE],listB[MAXSIZE];
intn,m;
intcompare（inta[],intb[]）
{
inti=0;
while（a[i]==b[i]&&ii++;
if（n==m&&i==n）return（0）;
if（nif（n>m&&i==m）return
（1）;
if（iif（a[i]elseif（a[i]>b[i]）return
（1）;
}
算法设计题部分
试编写算法,删除双向循环链表中第k个结点。
voiddel（DUNODE **head,inti）
{
DUNODE*p;
if（i==0）
{
*head=*head->next;
*head->prior=NULL;
return（0）;
}
else
{for（j=0;j=NULL;j++）
p=p->next;
if（p==NULL||j>i）return
（1）;
p->prior->next=p->next;
p->next->prior=p->proir;
free（p）;
return（0）;
}
算法设计题部分
线性表由前后两部分性质不同的元素组成（a0,a1,...,an-1,b0,b1,...,bm-1）,m和n为两部分元素的个数,若线性表分别采用数组和链表两种方式存储,编写算法将两部分元素换位成（b0,b1,...,bm-1,a0,a1,...,an-1）,分析两种存储方式下算法的时间和空间复杂度。
顺序存储:
voidconvert（elemtypelist[],intl,inth）/*将数组中第l个到第h个元素逆置*/
{
inti;
elemtypetemp;
for（i=h;i<=（l+h）/2;i++）
{
temp=list[i];
list[i]=list[l+h-i];
list[l+h-i]=temp;
}
}
voidexchange（elemtypelist[],intn,intm）;
{
convert（list,0,n+m-1）;
convert（list,0,m-1）;
convert（list,m,n+m-1）;
}
该算法的时间复杂度为O（n+m）,空间复杂度为O
（1）
链接存储:
（不带头结点的单链表）
typedefstructnode
{
elemtypedata;
structnode*link;
}NODE;
voidconvert（NODE**head,intn,intm）
{
NODE*p,*q,*r;
inti;
p=*head;
q=*head;
for（i=0;iq=q->link;/*q指向an-1结点*/
r=q->link;
q->link=NULL;
while（r->link!
=NULL）
r=r->link;/*r指向最后一个bm-1结点*/
*head=q;
r->link=p;
}
该算法的时间复杂度为O（n+m）,但比顺序存储节省时间（不需要移动元素,只需改变指针）,空间复杂度为O
（1）
算法设计题部分
用循环链表作线性表（a0,a1,...,an-1）和（b0,b1,...,bm-1）的存储结构,头指针分别为ah和bh，设计C函数，把两个线性表合并成形如（a0,b0,a1,b1,…）的线性表，要求不开辟新的动态空间,利用原来循环链表的结点完成合并
操作,结构仍为循环链表,头指针为head,并分析算法的时间复杂度。
typedefstructnode
{
elemtypedata;
structnode*link;
}NODE;
NODE *union（NODE *ah,NODE*bh）
{
NODE *a,*b,*head,*r,*q;
head=ah;
a=ah;
b=bh;
while（a->link!
=ah&&b->link!
=bh）
{
r=a->link;
q=b->link;
a->link=b;
b->link=r;
a=r;
b=q;
}
if（a->link==ah）/*a的结点个数小于等于b的结点个数*/
{
a->link=b;
while（b->link!
=bh）
b=b->link;
b->link=head;
}
if（b->link==bh）/*b的结点个数小于a的结点个数*/
{
r=a->link;
a->link=b;
b->link=r;
}
return（head）;
}
该算法的时间复杂度为O（n+m）,其中n和m为两个循环链表的结点个数.
算法设计题部分
试写出将一个线性表分解为两个带有头结点的循环链表，并将两个循环链表的长度放在各自的头结点的数据域中的C函数。
其中,线性表中序号为偶数的元素分解到第一个循环链表中,序号为奇数的元素分解到第二个循环链表中。
typedefstructnode
{
elemtypedata;
structnode*link;
}NODE;
voidanalyze（NODE*a）
{
NODE *rh，*qh，*r,*q,*p；
inti=0，j=0；/*i为序号是奇数的结点个数j为序号是偶数的结点个数*/
p=a；
rh=（NODE*）malloc（sizeof（NODE））；/*rh为序号是奇数的链表头指针*/
qh=（NODE*）malloc（sizeof（NODE））;/*qh为序号是偶数的链表头指针*/
r=rh;
q=qh;
while（p!
=NULL）
{
r->link=p;
r=p;
i++;
p=p->link;
if（p!
=NULL）
{
q->link=p;
q=p;
j++;
p=p->link;
}
}
rh->data=i;
r->link=rh;
qh->data=j;
q->link=qh;
}
算法设计题部分
试写出把线性链表改为循环链表的C函数。
typedefstructnode
{
elemtypedata;
structnode*link;
}NODE;
voidchange（NODE *head）
{
NODE *p;
p=head;
if（head!
=NULL）
{
while（p->link!
=NULL）
p=p->link;
p->link=head;
}
}
算法设计题部分
己知非空线性链表中x结点的直接前驱结点为y,试写出删除x结点的C函数。
typedefstructnode
{
elemtypedata;
structnode*link;
}NODE;
voiddel（NODE*x,NODE*y）
{
NODE*p,*q;
elemtyped1;
p=y;
q=x;
while（q->next!
=NULL）/*把后一个结点数据域前移到前一个结点*/
{
p->data=q->data;
q=q->link;
p=q;
}
p->link=NULL;/*删除最后一个结点*/
free（q）;
}
Answer：
FBCDBAAC
1.s->next=p->next;p->next=s;
2.不一定;
3.n/2
升级会员 