数据库系统l试题库及答案 第2章 线性表文档格式.docx
《数据库系统l试题库及答案 第2章 线性表文档格式.docx》由会员分享，可在线阅读，更多相关《数据库系统l试题库及答案 第2章 线性表文档格式.docx（16页珍藏版）》请在冰豆网上搜索。
A.访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）
B.在第i个结点后插入一个新结点（1≤i≤n）
C.删除第i个结点（1≤i≤n）
D.将n个结点从小到大排序
4.（）若某线性表中最常用的操作是取第i个元素和找第i个元素的前驱元素，则采用（）
存储方式最节省时间。
A.单链表B.双链表C.单向循环D.顺序表
5.（）下述哪一条是顺序存储结构的优点（）。
A．存储密度大B．插入运算方便
C．删除运算方便D．按照序号定位
6.（）若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂度为（）（1<
=i<
=n+1）。
A．O（0）B．O
（1）C．O（n）D．O（n
）
1.（）从长度为n的顺序表中删除任何一个元素，时间复杂度都是O（n）。
2.（）顺序表中任意一个数据元素的地址都可以通过计算得到。
3.（）存放顺序表的数据元素的地址空间可以连续也可以不连续。
4.（）在顺序表中按值进行查找的时间复杂度是O（n）。
5.（）顺序存储方式的特点是存储密度大且插入和删除运算效率高。
四、简答题
1．已知线性表的存储结构为顺序表，阅读下列算法，并回答问题：
voidf30（SqList&
L）{
inti，j;
for（i=j=0;
i<
L.length;
i++）
if（L.elem[i]>
=0）{
if（i!
=j）L[j]=L.elem[i];
j++；
}
L.length=j;
（1）设线性表L=（21，-7，-8，19，0，-11，34，30，-10），写出执行f30（&
L）后的L状态；
（2）简述算法f30的功能。
四、算法设计题
1.设计一个算法从一给定的有序顺序表L中删除元素值在x到y（x<
=y）之间的所有元素，要求以较
高的效率来实现。
要求算法的空间复杂度为O
（1）。
2.设有一个顺序表L，含有2n个整数，其中n个为负数，n个为正数，设计一个算法将L中所有元素按正负数相间排列。
要求本算法的时间复杂度为O（n），空间复杂度为O
（1）。
3.假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合（即同一表中的元素值各不相同），要求分别设计求A和B交、并、差集的算法，要求结果线性表中的元素依值递增有序排列。
试对顺表实现以上算法。
4.假设一个顺序表L中所有元素为整数，设计一个算法调整该顺序表，使其中所有小于0的元素放在所有大于等于0的元素的前面。
5.设顺序表A中前m个有序，后n个有序，试设计一算法使得整个顺序表有序。
2.3知识点：
线性表的链式存储结构
1.在链式存储中，元素之间的逻辑关系是通过___________决定的。
2.在单链表中，除了首元结点外，任一结点的存储位置由指示。
3.在n个结点的单链表中要删除已知结点*p，需找到它的，其时间复杂度为。
4.在双链表中，每个结点有两个指针域，一个指向,另一个指向。
5.在一个单链表中的p所指结点之后插入一个s所指结点时，执行的操作是。
6.对于一个具有n个结点的单链表，在p结点后插入一个新结点的时间复杂度是；
在给定值x的结点后插入一个新结点的时间复杂度是。
7.头结点地址指针为L的循环单链表，空表的判别标志是。
8.在一个单链表中删除p所指结点时，应执行以下操作：
q=p->
next;
p->
data=q->
data;
;
free（p）;
9.带头结点的单链表head为空的判定条件是。
10.在一个单链表head中，已知p指向某个非终端节点，若要删除其后的一个结点则执行的运算是。
1.（）链表是一种采用（）存储结构存储的线性表。
A.顺序B.链式C.星式D.网状
2.（）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。
A.必须是连续的B.部分地址必须是连续的
C.一定是不连续的D.连续或不连续都可以
3.（）线性表Ｌ在（）情况下适用于使用链式结构实现。
A.需经常修改Ｌ中的结点值B.需不断对Ｌ进行删除插入
C.Ｌ中含有大量的结点D.Ｌ中结点结构复杂
4.（）单链表的存储密度（）。
A.大于1B.等于1C.小于1D.不能确定
5.（）单链表不具备的特点是（）。
A.可随机访问任一节点B.插入删除不需要移动元素
C.不必事先估计存储空间D.所需空间与其长度成正比
6.（）设r指向单链表的最后一个结点，要在最后一个结点之后插入s所指的结点，需执
行的三条语句是（）；
r=s;
r->
next=null;
。
A.r->
next=s;
B.s->
next=r;
C.s->
D.s=r;
7.（）在一个单链表中,q为p的前驱结点，要删除p所指结点时，应执行以下操作（）。
A.q=p->
B.p->
next=q->
C.p->
next=q;
D.q->
next=p->
next
8.（）完成在双循环链表结点p之后插入s的操作是（）。
A.p->
next=s;
s->
prior:
=p;
next->
=s;
prior=s;
prior=p;
next:
=p->
prior=s;
D.s->
9.（）某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采
用（）存储方式最节省运算时间。
A.单链表B.仅有头指针的单循环链表C.双链表D.仅有尾指针的单循环链表
10.（）以下说法错误的是（）。
A．求表长、定位两种运算在采用顺序存储结构时的时间复杂度为O（n）
B．顺序存储的线性表可以随机存取
C．由于顺序存储要求连续的存储区域,所以在存储管理上不够灵活
D．线性表的链式存储结构优于顺序存储结构
11.在一个双链表中，删除p结点（非尾结点）之后的一个结点的操作是（）。
A．p->
B.p->
p->
C.p->
D.p->
12.在带头结点的循环单链表中，至少有一个结点的条件是（）,其尾结点p的条件是（）。
A．L->
next！
=NULLB.L->
next!
=LC.p==NULLD.p->
next=L
1.（）线性表的逻辑顺序与存储顺序总是一致的。
2.（）在单链表中存取某个元素，只要知道指向该元素的指针，因此单链表是随即存取的存储
结构。
3.（）在顺序表中存取某个元素，需要按照顺序进行，因此顺序表是顺序存取的存储结构。
4.（）单链表从任何一个结点出发，都能访问到所有结点。
1.描述以下三个概念的区别：
头指针.头结点.首元结点（第一个元素结点）。
在单链表中设置头结点的作用是什么？
2.试比较线性表的两种存储结构的优缺点。
在什么情况下用顺序表比链表好？
五、算法设计题
1．试写一算法，对单链表实现就地逆置。
2．设计一个算法，求A和B两个单链表表示的集合的交集、并集和差集，单链表中的数据递增有序排列。
要求分别按照共用原有空间和重新申请空间两种方案分别设计算法。
3．已知线性表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），同时释放被删结点空间，并分析你的算法的时间复杂度（注意，mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
1.一对一2.顺序存储链式存储3.数据项_4.逻辑结构存储结构
1.D2.D3．C4.E
1.×
2.√3.×
1.物理存储位置2.表中一半表长和该元素在表中的位置3.n-i+14.n-I5.O
（1）随机存取
6.地址必定7.（n+1）/28.n/2
1.C2.B3.A4.D5.AD6.C
2.√3.×
4.√5.×
四、答题
1．
（1）（21，19，0，34，30）
（2）功能是选出线性表中大于等于零的数。
1.voiddelete（SqList&
L,ElemTypex,ElemTypey）
{
inti=0,k=0;
while（i<
L.length）
{
if（L.elem[i]>
=x&
&
L.elem[i]<
=y）
k++;
//记录被删记录的个数
elseL.elem[i-k]=L.elem[i];
//前移k个位置
i++;
}
L.length=L.length-k;
2.voidmove（SqList&
L）
inti=0,j=L.length-1;
inttemp;
j）//使得正数都在前半部分，负数都在后半部分
j&
L.elem[i]>
0）i++;
L.elem[j]<
0）j--;
if（i<
j）//交换L.elem[i]（负数）和L.elem[j]（正数）
temp=L.elem[i];
L.elem[i]=L.elem[j];
L.elem[j]=temp;
i=1;
L.length/2）//通过交换使得正负数相间
j=L.length-2;
temp=L.elem[i];
L.elem[i]=L.elem[j];
L.elem[j]=temp;
i=i+2;
j=j-2;
3.交集:
voidintersection（SqListA,SqListB,SqList&
C）
inti=0,j=0,k=0;
A.length&
j<
B.length）
if（A.elem[i]<
B.elem[j]）i++;
elseif（A.elem[i]>
B.elem[j]）j++;
else{C.elem[k]=A.elem[i];
k++;
i++;
j++;
}//共同的元素
C.length=k;
并集:
voidUnion（SqListA,SqListB,SqList&
B.elem[j]）{C.elem[k]=A.elem[i];
k++;
B.elem[j]）{C.elem[k]=B.elem[j];
else{C.elem[k]=A.elem[i];
}//共同的元素只放一个
A.len）{C.elem[k]=A.elem[i];
i++}
while（j<
B.len）{C.elem[k]=B.elem[j];
j++}
差集:
voiddiffernce（SqListA,SqListB,SqList&
B.elem[j]）{j++;
else{i++;
A.length）{C.elem[k]=A.elem[i];
4.voidfun（SqList&
L）{
inti=,j=L.length-1;
=j）{
while（L.elem[i]<
0）i++;
while（L.elem[j]>
=0）j--;
if（i<
j）{//L.elem[i]和L.elem[j]交换
temp=L.elem[i];
L.elem[i]=L.elem[j];
L.elem[j]=temp;
5.merge（SqList&
A,intm,intn）{
inti=0,j=m,k;
while（j<
j）{
if（A.elem[j]>
A.elem[j-1]）//整个表已经递增有序，退出循环
break;
elseif（A.elem[j]<
A.elem[i]）//将A.elem[j]移到前半部分
{temp=A.elem[j]；
for（k=j-1;
k>
=i;
k--）//将A.elem[i]及之后的元素后移
A.elem[k+1]=A.elem[k]；
A.elem[i]=temp;
//将A.elem[j]插入到i处
j++;
elsei++;
本算法的时间复杂度为O（m*n），空间复杂度为O
（1）。
1.链域的指针值2.其直接前驱结点的链域的值3.前驱结点的地址O（n）4.前驱结点后继结点5.s->
6.O
（1）O（n）7.L->
next=L8.p->
9.head->
next==NULL10.q=p->
free（q）;
二、选择题
1.B2.D3.B4.C5.A6.A7.D8.D9.D10.D11.C12.BD
1.×
2.×
3.×
4.×
1.答：
首元结点是指链表中存储线性表中第一个数据元素a1的结点。
为了操作方便，通常在链表的首元结点之前附设一个结点，称为头结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表.非空表的情况以及对首元结点进行统一处理。
头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针。
若链表中附设头结点，则不管线性表是否为空表，头指针均不为空。
否则表示空表的链表的头指针为空。
这三个概念对单链表.双向链表和循环链表均适用。
是否设置头结点，是不同的存储结构表示同一逻辑结构的问题。
头结点
head
à
data
link
头指针首元结点
简而言之，
头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针；
头结点是在链表的首元结点之前附设的一个结点；
数据域内只放空表标志和表长等信息（内放头指针？
那还得另配一个头指针）
首元素结点是指链表中存储线性表中第一个数据元素a1的结点。
2.①顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；
要求内存中可用存储单元的地址必须是连续的。
优点：
存储密度大，存储空间利用率高。
缺点：
插入或删除元素时不方便。
②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
插入或删除元素时很方便，使用灵活。
存储密度小（<
1），存储空间利用率低。
顺序表适宜于做查找这样的静态操作；
链表宜于做插入.删除这样的动态操作。
若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；
若线性表的长度变化较大，且其主要操作是插入.删除操作，则采用链表。
1．StatusListOppose_L（LinkList&
LinkListp,q;
p=L->
//p指向单链表第一个结点
L->
next=NULL;
//形成空的单链表
while（p）{//采用头插入法将p结点插入到头结点的后面实现逆置
q=p;
p=p->
q->
next=L->
L->
returnOK;
2．并集：
LinkListBingji（LinkList&
Head1,LinkList&
Head2,LinkList&
Head3）
{
LNode*p1=Head1->
LNode*p2=Head2->
LNode*p3=Head3=Head1;
while（p1&
p2）
if（p1->
data<
p2->
data）
{
p3->
next=p1;
p3=p3->
next;
p1=p1->
}
else
data>
next=p2;
p2=p2->
else
next=p1;
q=p2;
free（q）;
}
p3->
next=（p1）?
p1:
p2;
free（Head2）;
returnHead3;
交集：
LinkListJiaoji（LinkList&
LinkListpa,pb,r,p;
pa=Head1->
pb=Head2->
r=Head3=Head1;
while（pa&
pb）{
if（pa->
data<
pb->
data）
{
r->
next=pa->
free（pa）;
pa=r->
}
else
if（pa->
data>
pb=pb->
else
{r->
next=pa;
r=pa;
pa=pa->
while（pa）{
free（pa）;
pa=r->
while（Head2->
next）//释放Head2链表所有的结点空间
{p=Head2->
Head2->
returnHead3;
差集：
LinkListChaji（LinkList&
r=r->
pa=pa->
next=pa->
ne
升级会员 