数据库系统l试题库及答案第2章线性表.docx

数据库系统l试题库及答案第2章线性表.docx

《数据库系统l试题库及答案第2章线性表.docx》由会员分享，可在线阅读，更多相关《数据库系统l试题库及答案第2章线性表.docx（20页珍藏版）》请在冰豆网上搜索。

数据库系统l试题库及答案第2章线性表

第2章线性表

2.1知识点：

线性表的逻辑结构

一、填空题

1.线性表是一个有限序列，结点间的关系是的。

2.线性表的存储方式分为和。

3.线性表中的数据元素可以是简单的数据类型，也可以由若干组成。

4.每个操作在层次上尚不能用具体的某种程序语言写出具体的算法，而算法只有在

确立之后才可以实现。

二、选择题

1.（）线性表L=（a,a匚…向氏）,下列说法正确的是（）。

A.每个元素都有一个直接前驱和一个直接后继。

B.线性表中至少要有一个元素。

C.表中诸元素的排列顺序必须是由小到大或由大到小。

D.

除第

一个和取后一个兀素外

其余每个兀素都有

-个且仅有

「个直接前驱和直接后继。

2.

（

）

在线性表的下列运算中，

不改变数据兀素之间结构关系的运算是（）。

A.

插入

B•删除

C.排序

D

.定位

3.

（

）

线性表是具有n个（

）的有限序列（

n>=0）。

A.

表兀素B•字符C

.数据兀素D

.数据项

E.信息项

4.

（）

以下不属于线性结构的是

（）。

A.栈B.队列C.串D.二维数组E.二叉树

三、判断题

1.（）同一线性表的数据元素可以具有不同的特性。

2.（）线性表的长度n就是表中数据元素的个数，当n=0时，称为空表。

3.（）基本操作的实现可以在逻辑结构分析之后进行。

2.2知识点：

线性表的顺序存储结构

一、填空题

1.在线性表的顺序存储结构中，元素间的逻辑关系是通过决定的。

2.在顺序表中插入或删除一个元素，需要平均移动元素，具体移动的元素个数与

有关。

3.向一个长度为n的顺序表的第i个元素（1

4.从一个长度为n的顺序表中删除第i个元素（1

5.在顺序表中访问任意一结点的时间复杂度均为，因此，顺序表也称为的数据结构。

6.线性表的顺序存储是用一组连续的空间单元实现数据元素的存储，逻辑上相邻的元素

的物理位置相邻。

7.向一个长度为n的顺序表中任意位置插入一个元素所需移动的平均次数为。

8.从一个长度为n的顺序表中删除任意一个元素所需移动的平均次数为。

二、选择题

1.（）1.数据在计算机存储器内表示时，物理地址与逻辑地址相同并连续，称之为（）。

A.存储结构B.逻辑结构C.顺序存储结构D.链式存储结构

2.

（）

A.110

3.

（

A.

B.

顺序表第一个元素的存储地址是100,每个元素长度为2，则第5个元素的地址是（）°

B.108C.100D.120

在n个结点的顺序表中，算法的时间复杂度是O

（1）的操作是（）°

4.

C.

D.

（

）

访问第i个结点（Ki

删除第i个结点（Kiwn）将n个结点从小到大排序

）若某线性表中最常用的操作是取第i个元素和找第i个元素的前驱元素，则采用（）

存储方式最节省时间。

A.单链表B.双链表C.单向循环

5.（）下述哪一条是顺序存储结构的优点（

A.存储密度大B.插入运算方便

C•删除运算方便D•按照序号定位

6.（）若长度为n的线性表采用顺序存储结构，在其第

度为（）（1<=i<=n+1）°

D.

顺序表

i个位置插入一个新元素的算法的时间复杂

A.O（0）

•0

（1）

C.0（n）

1.

2.

3.

4.

、判断题

（）

（）

（）

（）

（）

从长度为n的顺序表中删除任何一个元素，时间复杂度都是顺序表中任意一个数据元素的地址都可以通过计算得到。

存放顺序表的数据元素的地址空间可以连续也可以不连续。

在顺序表中按值进行查找的时间复杂度是O（n）°

顺序存储方式的特点是存储密度大且插入和删除运算效率高。

0（n）°

5.

四、简答题

1.已知线性表的存储结构为顺序表，阅读下列算法，并回答问题:

voidf30（SqList&L）{

inti,j;

for（i=j=0;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,

（2）简述算法f30的功能。

-11,34,30,-10）,写出执行f30（&L）后的L状态;

四、算法设计题

1.设计一个算法从一给定的有序顺序表L

高的效率来实现。

要求算法的空间复杂度为

中删除元素值在x到y（x<=y）之间的所有元素，要求以较

O

（1）°

负数相间排列。

要求本算法的时间复杂度为

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.

（

）线性表1在（）

情况下适用于使用链式结构实现。

A.

需经常修改L中的结点值

B.

需不断对L进行删除插入

C.

L中含有大量的结点

D.

L中结点结构复杂

4.

（

）单链表的存储密度（

）。

A.

大于1B.等于1

C.

小于1D.不能确定

5.

（

）单链表不具备的特点是（

）。

A.

可随机访问任一节点

B.

插入删除不需要移动兀素

C.

不必事先估计存储空间

D.

所需空间与其长度成正比

6.

（

）设r指向单链表的最后一个结点,

要在最后一个结点之后插入s所指的结点，需执

行的三条语句是（）；

r=s;r->next=null;。

A.r->next=s;B.s->next=r;C.s->next=nuII;D.s=r;

7.（）在一个单链表中,q为p的前驱结点，要删除p所指结点时，应执行以下操作（）。

A.q=p->next;B.p->next=q->next;C.p->next=q;D.q->next=p->next

8.（）完成在双循环链表结点p之后插入s的操作是（）。

A.p->next=s;s->prior:

=p;p->next->prior:

=s;s->next=p->next;

B.p->next->prior=s;p->next=s;s->prior=p;s->next:

=p->next;

C.s->prior=p;s->next=p->next;p->next=s;p->next->prior=s;

D.s->prior=p;s->next=p->next;p->next->prior=s;p->next=s;

9.（）某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采

用（）存储方式最节省运算时间。

A.单链表B.仅有头指针的单循环链表C.双链表D.仅有尾指针的单循环链表

10.（）以下说法错误的是（）。

A.求表长、定位两种运算在采用顺序存储结构时的时间复杂度为0（n）

B.顺序存储的线性表可以随机存取

C•由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活

D.线性表的链式存储结构优于顺序存储结构

11.在一个双链表中，删除p结点（非尾结点）之后的一个结点的操作是（）。

A.p->next=p->next->next;p->next->next->prior=p;

B.p->next->prior=p;p->next=p->next->next;

C.p->next=p->next->next;p->next->prior=p;

D.p->next->next=p->next;p->next->prior=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是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）

第2章线性表

2.1知识点:

线性表的逻辑结构

一、填空题

1.一对一2.顺序存储链式存储3.数据项_4.逻辑结构存储结构

二、选择题

1.D2.D3．C4.E

三、判断题

1.x2.V3.x

2.2知识点：

线性表的顺序存储结构

一、填空题

随机存取

1.物理存储位置2.表中一半表长和该元素在表中的位置3.n-i+14.n-I5.O

（1）

6.地址必定7.（n+1）/28.n/2

二、选择题

1.C2.B3.A4.D5.AD6.C

三、判断题

1.X2.V3.X4.V5.X

四、答题

1．

（1）（21，19，0，34，30）

（2）功能是选出线性表中大于等于零的数。

四、算法设计题

1.voiddelete（SqList&L,ElemTypex,ElemTypey）

{

inti=0,k=0;

while（i

{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;

while（i

{while（i0）i++;

while（i

if（i

{

temp=L.elem[i];

L.elem[i]=L.elem[j];

L.elem[j]=temp;

}

}

i=1;

while（i

{

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;

while（i

{

if（A.elem[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&C）

{

inti=0,j=0,k=0;

while（i

{

if（A.elem[i]B.elem[j]）{C.elem[k]=B.elem[j];k++;j++;}else{C.elem[k]=A.elem[i];k++;i++;j++;}//共同的元素只放一个

}

while（i

while（j

C.length=k;

}

差集:

voiddiffernce（SqListA,SqListB,SqList&C）

{

inti=0,j=0,k=0;

while（i

{

if（A.elem[i]

elseif（A.elem[i]>B.elem[j]）{j++;}

else{i++;j++;}//共同的元素只放一个

}

while（i

C.length=k;

}

4.voidfun（SqList&L）{

inti=,j=L.length-1;

while（i<=j）{

while（L.elem[i]<0）i++;

while（L.elem[j]>=0）j--;

if（i

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

if（A.elem[j]>A.elem[j-1]）//整个表已经递增有序，退出循环break;

elseif（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处

i++;

j++;

}

elsei++;

}

}

本算法的时间复杂度为O（m*n），空间复杂度为O

（1）。

2.3知识点：

线性表的链式存储结构

一、填空题

1.链域的指针值2.其直接前驱结点的链域的值3.前驱结点的地址O（n）4.前驱结点后继结点5.s->next=p->next;p->next=s;6.O

（1）O（n）7.L->next=L8.p->next=q->next;9.head->next==NULL10.q=p->next;p->next=q->next;free（q）;

二、选择题

1.B2.D3.B4.C5.A6.A7.D8.D9.D10.D11.C12.BD

三、判断题

1.x2.x3.x4.x

四、简答题

1.答：

首元结点是指链表中存储线性表中第一个数据元素a1的结点。

为了操作方便，通常在链表的首元

结点之前附设一个结点，称为头结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表.非空表的情况以及对首元结点进行统一处理。

头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针。

若链表中附设头结点，则不管线性表是否为空表，头指针均不为空。

否则表示空表的链表的头指针为空。

这三个概念对单链表.双向链表和循环链表均适用。

是否设置头结点，是

不同的存储结构表示同一逻辑结构的问题。

头结点

head

d

data

link

头指针首元结点

简而言之，

头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针；

头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息（内放头指针？

那还得另配一个头指针！

！

！

）

首元素结点是指链表中存储线性表中第一个数据元素ai的结点。

2.①顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。

优点：

存储密度大，存储空间利用率高。

缺点：

插入或删除元素时不方便。

②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

优点：

插入或删除元素时很方便，使用灵活。

缺点：

存储密度小（<1）,存储空间利用率低。

顺序表适宜于做查找这样的静态操作；链表宜于做插入•删除这样的动态操作。

若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；

若线性表的长度变化较大，且其主要操作是插入•删除操作，则采用链表。

五、算法设计题

1.StatusListOppose_L（LinkList&L）

LinkListp,q;

p=L->next;//p指向单链表第一个结点

L->next=NULL;//形成空的单链表

while（p）｛II采用头插入法将p结点插入到头结点的后面实现逆置

q=p;

p=p->next;

q->next=L->next;

L_>next=q;

}

returnOK;

}

2•并集：

LinkListBingji（LinkList&Head1,LinkList&Head2,LinkList&Head3）

{

LNode*卩仁Head1->next;

LNode*p2=Head2->next;

LNode*p3=Head3=Head1;

while（p1&&p2）

{

if（p1->datadata）

{

p3->next=p1;

p3=p3->next;

p1=p1->next;

}else

{

if（p1->data>p2->data）

{

p3->next=p2;p3=p3->next;p2=p2->next;

}

else

{p3->next=p1;p3=p3->next;p1=p1->next;q=p2;free（q）;p2=p2->next;

}

}

}

p3->next=（p1）?

p1:

p2;free（Head2）;

returnHead3;

}

交集：

LinkListJiaoji（LinkList&Head1,LinkList&Head2,LinkList&Head3）{

LinkListpa,pb,r,p;pa=Head1->next;pb=Head2->next;r=Head3=Head1;while（pa&&pb）{if（pa->datadata）

{r->next=pa->next;free（pa）;

pa=r->next;

}

elseif（pa->data>pb->data）pb=pb->next;else{r->next=pa;r=pa;pa=pa->next;}

}while（pa）{r->next=pa->next;

free（pa）;pa=r->next;

}

while（Head2->next）//释放Head2链表所有的结点空间

{p=Head2->next;Head2->next=p->next;free（p）;

}

returnHead3;

}

差集：

LinkListChaji（LinkList&Head1,LinkList&Head2,LinkList&Head3）{

LinkListpa,pb,r,p;

pa=Head1->next;

pb=Head2->next;

r=Head3=Head1;

while（pa&&pb）{if（pa->datadata）{

r->next=pa;