《数据结构》习题集：第2章 线性表

第2章线性表

一、选择题

1.表长为N 的顺序表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均

次数为（E ），删除一个元素需要移动的元素个数为（A）。

A. (N-1)/2

B. N

C. N+1

D. N-1

E. N/2

F. (N+1)/2

G. (N-2)/2

2.线性表是具有N 个（C）的有限序列。

A、表元素

B、字符

C、数据元素

D、数据项

E、信息

3.“线性表的逻辑顺序和物理顺序总是一致的。”这个结论是（B）。

A、正确的

B、错误的

C、不一定，与具体结构有关。

4.线性表采用链式存储结构时，要求内存中可用存储单元的地址（D）。

A、必须是连续的

B、部分地址必须是连续的

C、一定是不连续的

D、连续或不连续都可以。

5.带头结点的单链表为空的判定条件是（B）。

A、head==NULL

B、head->next==NULL

C、head->next==head

D、head!=NULL

6.不带头结点的单链表head 为空的判定条件是（A）。

A、head==NULL

B、head->next==NULL

C、head->next==head

D、head!=NULL

7.非空的循环单链表head 的尾结点P 满足（C）。

A、P->NEXT=NULL

B、p=NULL

C、p->next==head

D、p==head

8.在一个具有n 个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是（B）。

A、O(1)

B、O(n)

C、O(n2)

D、O(nlog2n)

9.在一个单链表中，若删除P 所指结点的后继结点，则执行（A）。

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;

10.在一个单链表中，若在Ｐ所指结点之后插入Ｓ所指结点，则执行（B）。

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;

11.在一个单链表中，已知q 是p 的前趋结点，若q 和p 之间插入结点s，则执行（C）。

A、s-next=p->next;p->next=s;

B、p->next=s->next;s->next=p;

C、q->next=s;s->next=p;

D、p->next=s;s->next=q;

12.假设双链表结点的类型如下：

typedef struct linknode{

int data; ／／数据域

struct linknode *llink; ／／指向前趋结点的指针域

struct linknode *rlink; ／／指向后继结点的指针域

}bnode

现将一个q 所指新结点作为非空双向链表中的p 所指结点的前趋结点插入到该双链表中，能正确完成此要求的语句段是（D）。

A、q->rlink=p;q->llink=p->llink;p->llink=q;p->llink->rlink=q;

B、p->llink=q;q->rlink=p;p->llink->rlink=q;q->llink=p->llink

C、q->llink=p->rlink;q->rlink=p;p->llink->rlink=q;p->llink=q;

D、以上都不对

13.如上题结点结构，如在此非空循环双向链表的结点p 之后插入结点s 的操作序列是（D）。

A、p->rlink=s;s->llink=p;p->rlink->llink=s;s->rlink=p->rlink;

B、p->rlink->s;p->rlink->llink=s;s->llink=p;s->rlink=p->rlink;

C、s->llink=p;s->rlink=p->rlink;p->rlink=s;p->rlink->llink=s;

D、s->llink=p;s->rlink=p->rlink;p->rlink->llink=s;p->rlink=s;

14.在一个长度为n 的单链表上，设有头和尾两个指针，执行（A，C，D）操作与链表的长度无关。

A、删除单链表中的第一个元素

B、删除单链表中最后一个元素

C、在单链表第一个元素前插入一个新元素

D、在单链表最后一个元素后插入一个新元素

15.线性结构中的一个结点代表一个（A）

A、数据元素

B、数据项

C、数据

D、数据结构

16.非空线性表L=(a1,a2,…,ai,…,an)，下列说法正确的是（D）

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

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

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

D、除第一个元素和最后一个元素外其余每个元素都有一个且仅有一个直接前驱和直接后继

17.顺序表是线性表的（B）

A、链式存储结构

B、顺序存储结构

C、索引存储结构

D、散列存储结构

18.对于顺序表，以下说法错误的是（A）

A、顺序表是用一维数组实现的线性表，数组的下标可以看成是元素的绝对地址

B、顺序表的所有存储结点按相应数据元素间的逻辑关系决定的次序依次排列

C、顺序表的特点是:逻辑结构中相邻的结点在存储结构中仍相邻

D、顺序表的特点是:逻辑上相邻的元素，存储在物理位置也相邻的单元中

19.对顺序表上的插入、删除算法的时间复杂性分析来说，通常以（B）为标准操作。

A、插入操作

B、结点移动

C、算术表达式

D、删除操作

20.对于顺序表的优缺点，以下说法错误的是（C）

A、无需为表示结点间的逻辑关系而增加额外的存储空间

B、可以方便地随机存取表中的任一结点

C、插入和删除运算较方便

D、由于顺序表要求占用连续的空间，存储分配只能预先进行(静态分配)

21.若某线性表中最常用的操作是取第i 个元素和找第i 个元素的前趋元素，则采用（A）存储方式最节省时间。

A、顺序表

B、单链表

C、双链表

D、单循环链表

22.循环链表主要优点是（D）

A、不再需要头指针了

B、已知某个结点的位置后，能够容易找到它的直接前趋

C、在进行插入、删除运算时，能更好地保证链表不断开

D、从表中任一结点出发都能扫描到整个链表

23.在线性表的下列存储结构中，读取元素花费时间最少的是（D）

A、单链表

B、双链表

C、循环链表

D、顺序表

二、填空题

1.在线性结构中，第一个结点（没有）前趋结点，其余每个结点有且只有（1）个前趋结点。

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

有关。

3.已知Ｌ是无表头结点的单链表，试从下列提供的答案中选择合适的语句序列，分别实现：

（１）表首插入Ｓ结点的语句序列是（FC）。

（２）表尾插入Ｓ结点的语句序列是（BIAG）。

Ａ、Ｐ->next=S;

Ｂ、P=L;

Ｃ、L=S;

Ｄ、P->next=S->next;

Ｅ、S->next=P->next;

Ｆ、S->next=L;

Ｇ、S->next=NULL;

Ｈ、while(P->next!=Q)p=p->next;

Ｉ、while(P->next!=NULL)P=P->next;

4.已知L 是带表头结点的非空单链表，试从下列提供的答案中选择合适的语句序列。

（1）删除首元结点的语句序列是（HGBJ）,

（2）删除尾元结点的语句序列是（HFDBJ）

A、P=P->next;

B、P->next=P->next->next;

C、while(P!=NULL)p=p->next;

D、while(Q->next!=NULL){P=Q;Q=Q->next;}

E、while(P->next!=Q)P=P->next;

F、Q=P;

G、Q=P->next;

H、P=L;

I、L=L->next;

J、free(Q);

5.已知L 是带表头结点的非空链表，且P 结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择

合适的语句序列。

（1）删除P 结点的直接后继结点的语句序列是（FAI）,

（2）删除P 结点的直接前趋结点的语句序列是（EGDFAI）

A、P->next=P->next->next;

B、P=P->Pnext->next;

C、while(P->next!=Q)P=P->next;

D、while(P->next->next!=Q)P=P->next;

E、Q=P;

F、Q=P->next;

G、P=L;

H、L=L->next; I、free(Q);

6.已知结点编号，在各结点查找概率相等的情况下，从n 个结点的单链表中查找一个结点，平均要访问（n/2）

个结点，从n 个结点的双链表中查找一个结点，平均要访问（n/4）个结点。（此题有误！另作说明）

7.对于一个具有n 个结点的单链表，在已知p 所指结点后插入一个新结点的时间复杂度是（O(1 )）；在值域为给

定值的结点后插入一个新结点的时间复杂度是（O(n)）。

8.单链表是（线性表）的链接存储表示。

9.单链表中设置头结点的作用是（插入和删除首元素时不必进行特殊处理）。

10.在单链表中，除首元结点外，任一结点的存储位置由（其直接前趋结点的链域）指示。

11.在非空双向循环链表中，在结点q 的前面插入结点p 的过程如下：

p->prior=q->prior;

q->prior->next=p;

p->next=q;

(q->prior=p;);

12.在双向链表中，每个结点有两个指针域，一个指向（前趋结点），另一个指向（后继结点）。

13.顺序表中逻辑上相邻的元素的物理位置（必定）相邻。单链表中逻辑上相邻的元素的物理位置（不一定）相邻。

14.为了便于讨论，有时将含n(n≥0)个结点的线性结构表示成(a1，a2,…,a n)，其中每个a i 代表一个_结点_。a1 称为

_第一个_结点，a n 称为_最后一个__结点，i 称为a i 在线性表中的__位置_。对任意一对相邻结点a i、a i┼1(1≤i

15.线性结构的基本特征是：若至少含有一个结点，则除起始结点没有直接__前驱__外，其他结点有且仅有一个直

接_前驱__；除终端结点没有直接__后继__外，其它结点有且仅有一个直接__后继__.

16.所有结点按1 对1 的邻接关系构成的整体就是__线性__结构。

17.线性表的逻辑结构是__线性__结构。其所含结点的个数称为线性表的___长度___。

18.在单链表中，指针p 所指结点为最后一个结点的条件是___ p→next=NULL ;___。

三、判断题

1. 顺序存储的线性表可以随机存取。√

2. 顺序存储的线性表的插入和删除操作不需要付出很大的代价，因为平均每次操作只有近一半的元素需要移动。X

3. 线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。√

4. 在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上不一定相邻。X

5. 在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。√

6. 在单链表中，可以从头结点进行查找任何一个元素。√

7. 线性表的链式存储结构优于顺序存储结构。X

8. 在线性表的顺序存储结构中，插入和删除元素时，移动元素的个数与该元素的位置有关。√

9. 在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。X

10. 顺序存储方式只能用于存储线性结构。X

四、简答题

1.若较频繁地对一个线性表进行插入和删除操作，该线性表宜采用哪种存储结构？为什么？

答案：宜采用链式存储结构，因为它使线性表的插入和删除操作的时间复杂度为O（1），而顺序存储结构的为O（n）。

2.描述概念：头指针、头结点、首元结点的区别？

答案：首元结点是指链表中存储线性表中第一个数据元素的结点。为了操作方便，通常在链表的首元结点之前附设一个结点，称为头结点，该结点的数据域中不存线性表的数据元素，其作用是为了对链表进行操作时，可以对空表非空表的情况以及对首元结点进行统一的处理。头指针是指向链表第一个结点（头结点或首元结点）的指针。若链表中附设头结点，则不管线性表是否为空表，头指针均不为空，否则表示空表的链表的头指针为空。这三个概念对单链表、双向链表和循环链表均适用。

3.设A 是一个线性表（a1a2…an），采用顺序存储结构，则在等概率的前提下，平均每插入一个元素需要移动的

元素个数为多少？若元素插在ai 与ai+1 之间（0<=I<=n-1）的概率为2(n-i)/(n(n+1))，则平均每插入一个元素

所要移动的元素个数又是多少？

答案：在等概率前提下，平均每插入一个元素需要移动的元素个数为(0+1+2+…+n)/(n+1)=n/2。若元素插在ai 与ai+1 间（0<=i<=n-1）的概率为2(n-i)/(n(n+1))，则平均每插入一个元素所要移动的元素个数为：

（2n+1）/3

4.为什么在单循环链表中设置尾指针比设置头指针更好？

解答：单循环链表中无论设置尾指针还是头指针都可以任一结点从遍历表中其它结点，但设置尾指针时，若在表尾进行插入或删除操作时可在O(1)时间内完成，同样在表头进行插入或删除操作时也可在O(1)时间内完成。

但设置的是头指针，表尾进行插入或删除操作，需要遍历整个链表，时间复杂度为O(n)。

5.双链表和单循环链表中，若仅知道指针p 指向某个结点，不知道头指针，能否将结点*p 从相应的链表中删除？

若可以，其时间复杂度各为多少？

解答：能删除。双链表上删除p 所指向的结点的时间复杂度为O(1)，单循环链表上删除p 所指向的结点的时间复杂度为O(n)。

6.下列算法的功能是什么？

LinkedList test1(LinkedList L)

{

//L 是无头结点的单链表

ListNode *q,*p;

if(L&&L->next)

{

q=L ;

L=L->next;

p=L;

while(p->next)

p=p->next;

p->next=q;

q->next=NULL;

}

return L;

}

解答：如果长度大于1，则将首元结点删除并插入到表尾。

7.如果有n 个线性表同时共存，并且在处理过程中各表的长度会发生动态变化，线性表的总长度也会自动地改

变。在此情况下，应选择哪一种存储结构。为什么？

解答：应选用链式存储结构。因为顺序表是静态存储结构，只能预先分配存储单元，不能随着线性表长度的改变而变化。而链表则可根据需要动态的申请空间，因此适用于动态变化表长的线性表。

8.若线性表的总数基本稳定，且很少进行插入删除操作，但要求以最快的方式存取线性表的元素，应该用哪种存

储结构。为什么？

解答：应该用顺序存储结构。因为顺序存储结构存取元素操作的时间复杂度为O(1)。

9.设有多项式a(x)=9+8x+9x4+5x10

b(x)=-2x+22x7-5x10

（1）用单链表给出a(x)、b(x)的存储表示；

（2）设c (x)=a(x)+b(x)，求得c(x)并用单链表给出其存储表示。

解答：用单链表表示多项式，除指针域外需设置两个数据域，一个用来存储系数，一个用来存储指数。

五、设计题

1.编写一个函数将一个顺序表A（有多个元素且任何元素不为0）分拆成两个顺序表，使A 中大于0的元素存放

在B 中，小于0 的元素存放在C 中。

解答：void split(SqList A,SqList &B,SqList &C){//采用顺序存储结构实现

int I;

B.length=

C.length=0;

for(I=0;I

if(A.elem[i]>0){

B.elem[B.length]=A.elem[i];

B.length++;

}

else{

C.elem[C.length]=A.elem[i];

C.length++;

}

}

}

2.设顺序表L 中的数据元素递增有序。试写一算法，将e 插入到顺序表的适当位置，插入后保持该表的有序性。

解答：status ListInsert(SqList &L,ElemType e){

ElemType *p,*q,*newbase;

int j;

if(L.length>=L.listsize){

newbase=(ElemType )realloc(L.elem,(L.listsize+LISTINCRMENT)*sizeof(ElemType));

if(!newbase)

exit(OVERFLOW);

L.elem=newbase;

L.listsize=+LISTINCRMENT;

}

For(j=L.length-1;j>=0&&e

L.elem[j+1]=L.elem[j];

L.elem[j+1]=e;

++L.length;

return OK;

}

3.A、B 为元素递增有序排列的单链表（同一表中可能有相同元素），编写算法另建一单链表C，保存两个表的

公共元素，要求C 的元素值各不相同且递增有序。

解答：提示：两个表的公共元素指的是既存在于A 表中，也存在于B 表中的元素，为了操作方便，先让单链表C 带有一个头结点c，再后将其删除。

LinkList Inter_eq(LinkList a,LinkList b){

LinkList p,q,r,c;

c=(LinkList)malloc(sizeof(LNode));//建立单链表C 的头指针

r=c;

p=a;

q=b;

while(p&&q){

if(p.data

p=p.next;

else if(p.data>q.data)

q=q.next;

else //找到元素值相同的结点

{s=(LinkList)malloc(sizeof(LNode));

s.data=p.data;r.next=s;r=s; //把s 结点链到c 的末尾，r 始终指向链表C 的最后一个结点

while(p.data==p.next.data)

p=p.next; //跳过相同的值的结点

p=p.next;

while(q.data==q.next.data)

q=q/next;

q=q.next;

}

}

r.next=NULL;

s=c;c=c.next;free(c); //删除C 链表的头结点

return (c);

}

4、设有一个由正整数组成的无序单链表，编写算法实现下列功能：

（1）找出最小值结点，且显示该数值。

（2）若该数值为奇数，则将其与直接后继结点的数值交换。

（3）若为偶数，则将其直接后继结点删除。

解答：参考程序：

void outmin(LinkList L){

LinkList p=L,q=L;

int temp;

while(q){

if(p.data>q.data)p=q;

q=q.next;

}

printf(“%d”,p.data);

if(p.next){

if(p.data%2==1){

temp=p.data;

p.data=p.next.data;

p.next.data=temp;

}

else{

q=p.next;p.next=q.next;

free(q);

}

}

}