第二章作业题2-链表-计算机17级（期末复习带详解版）

解析在后面 

这次的题关于循环链表和双向链表的部分真的很难，不会的不少，我再想想吧

 

 

p1-1：

链表访问节点的时间复杂度为O(N)

p1-3：

时间复杂度为O(1)，如果是两个链表都是有序的，合成一个有序链表的时间复杂度为O(M + N)

x2-3：

带了头结点，那么就是B

x2-4：

最小肯定是N，最大应该是2N（N+N）吧

x2-6：

这个题要注意

链表插入和删除操作的时间复杂度都是O（N），看上去和顺序表没什么差距，但是如果已知了要插入或删除的位置，那么此时单链表的插入删除操作时间复杂度就是O（1），因为链表只需要移动指针赋值即可，而顺序表则需要移动大量的元素，所以此题的a，b，d都是O（1），c要遍历，肯定就是O（N）

x2-10:

这个题也要仔细哦，要插入到长度为m的单链表，需要找到表尾，这个过程的时间复杂度为o(m)，连接的时间复杂度为0(1),所以总的时间复杂度为0(m)

x2-11：

在单链表中，增加一个头结点的最终目的是为了

方便运算（即处理空表和非空表的情况）

x2-19：

循环单链表就是头指针指向尾指针

x2-20：

双向链表的插入操作

x2-21：

双向链表的删除操作

x2-22：

22,23,25,28，29都是一类题！！！

涉及到删除最后一个结点的，就要选择带头指针的，只有尾指针就解决不了了，因为删除最后一个结点需要找到他的直接前驱结点，肯定要遍历的，那就需要头指针。一般是选择带表头附加结点的双循环链表（时间更短），也可以选择给出表头指针的单循环链表

剩下的一般用带表尾指针的循环单链表即可

这种只在头尾进行插入删除的操作，比较适合用循环单链表，且仅有尾指针

x2-23：

这个记住就好了。。。

x2-24：

开个表合并这个肯定是带尾指针的单循环链表，这是最简单的算法

x2-25：重点说一下这个题，关于删除最后一个结点，b，c，d都需要遍历一边，并没有太大差别

但在最后一个结点后面插入，c就方便的多了，而d一定要注意，他可没说循环

删除最后一个结点最好的操作就是双向循环链表

x2-27：

不会！！！

x2-28：

于22,23,25,28，29，31,32类似

x2-30：
选b，这种情况肯定需要遍历全部元素

x2-35：

循环链表的主要优点是能从表中的任意结点出发都能扫描到整个链表

x2-36：

这就是循环链表的操作，

p->next=ha; return ha;

注意最后返回是头指针。

x2-37：

双向链表的插入操作

x2-38：

双链表的优点之一是

顺序访问相邻结点更加灵活

即算法效率更高，以空间换时间

 

后面的不用看

 

 

 

 

1-1

在具有N个结点的单链表中，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。 (1分)

T         F

 

作者: DS课程组

单位: 浙江大学

1-2

若用链表来表示一个线性表，则表中元素的地址一定是连续的。 (1分)

T         F

 

作者: 陈越

单位: 浙江大学

1-3

将长度分别为m,n的两个单链表合并为一个单链表的时间复杂度为O(m+n)。 (1分)

T         F

 

作者: 干红华

单位: 浙江大学

1-4

(neuDS)单链表不是一种随机存取的存储结构。 (1分)

T         F

 

2-1

设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(2分)

1. h=t; t->next=h->next;
2. t->next=h->next; h=t;
3. h=t; t->next=h;
4. t->next=h; h=t;

作者: DS课程组

单位: 浙江大学

2-2

在单链表中，若p所指的结点不是最后结点，在p之后插入s所指结点，则执行 (2分)

1. s->next=p; p->next=s;
2. s->next=p->next; p=s;
3. s->next=p->next; p->next=s;
4. p->next=s; s->next=p;

作者: DS课程组

单位: 浙江大学

2-3

带头结点的单链表h为空的判定条件是： (2分)

1. h == NULL;
2. h->next == NULL;
3. h->next == h;
4. h != NULL;

作者: DS课程组

单位: 浙江大学

2-4

将两个结点数都为N且都从小到大有序的单向链表合并成一个从小到大有序的单向链表，那么可能的最少比较次数是： (2分)

1. 1
2. N
3. 2N
4. NlogN

作者: DS课程组

单位: 浙江大学

2-5

线性表若采用链式存储结构时，要求内存中可用存储单元的地址 (1分)

1. 必须是连续的
2. 连续或不连续都可以
3. 部分地址必须是连续的
4. 一定是不连续的

作者: DS课程组

单位: 浙江大学

2-6

在具有N个结点的单链表中，实现下列哪个操作，其算法的时间复杂度是O(N)？ (2分)

1. 在地址为p的结点之后插入一个结点
2. 删除开始结点
3. 遍历链表和求链表的第i个结点
4. 删除地址为p的结点的后继结点

作者: DS课程组

单位: 浙江大学

2-7

对于一个具有N个结点的单链表，在给定值为x的结点后插入一个新结点的时间复杂度为 (2分)

1. O(1)
2. O(N/2)
3. O(N)
4. O(N​2​​)

作者: DS课程组

单位: 浙江大学

2-8

链表不具有的特点是： (1分)

1. 插入、删除不需要移动元素
2. 方便随机访问任一元素
3. 不必事先估计存储空间
4. 所需空间与线性长度成正比

作者: DS课程组

单位: 浙江大学

2-9

(neuDS)在一个含有n个结点的有序单链表中插入一个新结点，使单链表仍然保持有序的算法的时间复杂度是（ ）。 (2分)

1. O(1)
2. O(log​2​​n)
3. O(n)
4. O(n​2​​)

作者: 徐婉珍

单位: 广东东软学院

2-10

将长度为n的单链表连接在长度为m的单链表之后的算法的时间复杂度为（ ）。 (2分)

1. O(1)
2. O(m)
3. O(n)
4. O(n+m)

作者: 杨斌

单位: 枣庄学院

2-11

(neuDS)在单链表中，增加一个头结点的最终目的是为了( )。 (2分)

1. 使单链表至少有一个结点
2. 方便运算的实现
3. 标识表结点中首结点的位置
4. 说明单链表是线性表的链式存储

作者: 徐婉珍

单位: 广东东软学院

2-12

在单链表中，要删除某一指定结点，必须先找到该结点的（）。 (2分)

1. 直接前驱
2. 自身位置
3. 直接后继
4. 直接后继的后继

作者: 严冰

单位: 浙江大学城市学院

2-13

以下关于链式存储结构的叙述中，（）是不正确的。 (2分)

1. 结点除自身信息外还包括指针域，因此存储密度小于顺序存储结构
2. 逻辑上相邻的结点物理上不必邻接
3. 可以通过计算直接确定第i个结点的存储地址
4. 插入、删除运算操作方便，不必移动结点

作者: 严冰

单位: 浙江大学城市学院

2-14

线性链表不具有的特点是（）。 (2分)

1. 随机访问
2. 不必事先估计所需存储空间大小
3. 插入与删除时不必移动元素
4. 所需空间与线性长度成正比

作者: 严冰

单位: 浙江大学城市学院

2-15

线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。 (2分)

1. 必须是连续的
2. 部分地址必须是连续的
3. 一定是不连续的
4. 连续或不连续都可以

作者: 严冰

单位: 浙江大学城市学院

2-16

对线性表，在下列情况下应当采用链表表示的是（）。 (2分)

1. 经常需要随机地存取元素
2. 经常需要进行插入和删除操作
3. 表中元素需要占据一片连续的存储空间
4. 表中的元素个数不变

作者: 严冰

单位: 浙江大学城市学院

2-17

不带表头附加结点的单链表为空的判断条件是头指针head满足条件（）。 (2分)

1. head==NULL
2. head->next==NULL
3. head->next== head
4. head!=NULL

作者: 严冰

单位: 浙江大学城市学院

2-18

可以用带表头附加结点的链表表示线性表，也可以用不带头结点的链表表示线性表，前者最主要的好处是（）。 (2分)

1. 可以加快对表的遍历
2. 使空表和非空表的处理统一
3. 节省存储空间
4. 可以提高存取表元素的速度

作者: 严冰

单位: 浙江大学城市学院

2-19

对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有：(2分)

1. p->next == h
2. p->next == NULL
3. p == NULL
4. p == h

作者: DS课程组

单位: 浙江大学

2-20

在双向循环链表结点p之后插入s的语句是： (3分)

1. p->next=s; s->prior=p; p->next->prior=s ; s->next=p->next;
2. p->next->prior=s; p->next=s; s->prior=p; s->next=p->next;
3. s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;
4. s->prior=p; s->next=p->next; p->next->prior=s; p->next=s;

作者: DS课程组

单位: 浙江大学

2-21

在双向链表存储结构中，删除p所指的结点，相应语句为：(3分)

1. p->prior=p->prior->prior; p->prior->next=p;
2. p->next->prior=p; p->next=p->next->next;
3. p->prior->next=p->next; p->next->prior=p->prior;
4. p->next=p->prior->prior; p->prior=p->next->next;

作者: DS课程组

单位: 浙江大学

2-22

某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用什么存储方式最节省运算时间？ (2分)

1. 单链表
2. 仅有尾指针的单循环链表
3. 仅有头指针的单循环链表
4. 双链表

作者: DS课程组

单位: 浙江大学

2-23

若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用哪种存储方式最节省运算时间？ (2分)

1. 单链表
2. 双链表
3. 单循环链表
4. 带头结点的双循环链表

作者: DS课程组

单位: 浙江大学

2-24

将线性表La和Lb头尾连接，要求时间复杂度为O(1)，且占用辅助空间尽量小。应该使用哪种结构？ (2分)

1. 单链表
2. 单循环链表
3. 带尾指针的单循环链表
4. 带头结点的双循环链表

作者: DS课程组

单位: 浙江大学

2-25

(neuDS)在链表中若经常要删除表中最后一个结点或在最后一个结点之后插入一个新结点，则宜采用（）存储方式。 (2分)

1. 顺序表
2. 用头指针标识的循环单链表
3. 用尾指针标识的循环单链表
4. 双向链表

作者: 徐婉珍

单位: 广东东软学院

2-26

非空的循环单链表head的尾结点（由p所指向）满足（）。 (2分)

1. p->next == NULL
2. p == NULL
3. p->next == head
4. p == head

作者: 严冰

单位: 浙江大学城市学院

2-27

在循环双链表的p所指结点之前插入s所指结点的操作是（）。 (2分)

1. p->prior = s; s->next = p; p->prior->next = s; s->prior = p->prior;
2. p->prior = s; p->prior->next = s; s->next = p; s->prior = p->prior;
3. s->next = p; s->prior = p->prior; p->prior = s; p->right->next = s;
4. s->next = p; s->prior = p->prior; p->prior->next = s; p->prior = s;

作者: 严冰

单位: 浙江大学城市学院

2-28

若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用（）存储方式最节省运算时间。 (2分)

1. 单链表
2. 给出表头指针的单循环链表
3. 双链表
4. 带表头附加结点的双循环链表

作者: 严冰

单位: 浙江大学城市学院

2-29

某线性表最常用的操作是在最后一个结点之后插入一个结点或删除第一个结点，故采用（）存储方式最节省运算时间。 (2分)

1. 单链表
2. 仅有头结点的单循环链表
3. 双链表
4. 仅有尾指针的单循环链表

作者: 严冰

单位: 浙江大学城市学院

2-30

在一个长度为n（n>1）的单链表上，设有头和尾两个指针，执行（）操作与链表的长度有关。 (2分)

1. 删除单链表中的第一个元素
2. 删除单链表中的最后一个元素
3. 在单链表第一个元素前插入一个新元素
4. 在单链表最后一个元素后插入一个新元素

作者: 严冰

单位: 浙江大学城市学院

2-31

如果对线性表的运算只有4种，即删除第一个元素，删除最后一个元素，在第一个元素前面插入新元素，在最后一个元素的后面插入新元素，则最好使用（）。 (2分)

1. 只有表尾指针没有表头指针的循环单链表
2. 只有表尾指针没有表头指针的非循环双链表
3. 只有表头指针没有表尾指针的循环双链表
4. 既有表头指针也有表尾指针的循环单链表

作者: 严冰

单位: 浙江大学城市学院

2-32

如果对线性表的运算只有2种，即删除第一个元素，在最后一个元素的后面插入新元素，则最好使用（）。 (2分)

1. 只有表头指针没有表尾指针的循环单链表
2. 只有表尾指针没有表头指针的循环单链表
3. 非循环双链表
4. 循环双链表

作者: 严冰

单位: 浙江大学城市学院

2-33

在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是（）。 (2分)

1. p->next = s; s->prior = p; (p->next)->prior = s; s->next = p->next;
2. s->prior = p; s->next = p->next; p->next = s; p->next->prior = s;
3. p->next = s; p->next->prior = s; s->prior = p; s->next = p->next;
4. s->prior = p; s->next = p->next; p->next->prior = s; p->next = s;

作者: 严冰

单位: 浙江大学城市学院

2-34

带表头附加结点的双向循环链表为空的判断条件是头指针L满足条件（）。 (2分)

1. L= =NULL
2. L->right= =NULL
3. L->left = =NULL
4. L->right= =L

作者: 严冰

单位: 浙江大学城市学院

2-35

循环链表的主要优点是（）。 (2分)

1. 不再需要头指针了
2. 已知某个结点的位置后，能够很容易找到它的直接前驱
3. 在进行插入、删除运算时，能更好的保证链表不断开
4. 从表中的任意结点出发都能扫描到整个链表

作者: 严冰

单位: 浙江大学城市学院

2-36

已知指针ha和hb分别是两个单链表的头指针，下列算法将这两个链表首尾相连在一起，并形成一个循环链表（即ha的最后一个结点链接hb的第一个结点，hb的最后一个结点指向ha），返回该循环链表的头指针。请将该算法补充完整。 (4分)

typedef struct node{
ElemType data;
    struct node *next;
}LNode;
LNode *merge(LNode *ha, LNode *hb) {
LNode *p=ha;
     if (ha==NULL || hb==NULL) {
cout<<”one or two link lists are empty!”<<endl;
          return NULL;
     }
     while ( p->next!=NULL ) 
           p=p->next;
     p->next=hb;
     while ( p->next!=NULL ) 
           p=p->next;
           __________         
}

1. ha=p->next; return ha;
2. p->next=ha; return ha;
3. ha=p->next; return p;
4. p->next=ha; return p;

作者: 严冰

单位: 浙江大学城市学院

2-37

设有一个双向循环链表，每个结点中除有left、data和right三个域外，还增设了一个访问频度域freq，freq 的初值为零。每当链表进行一次查找操作后，被访问结点的频度域值便增1，同时调整链表中结点的次序，使链表按结点频度值非递增有序的次序排列。下列算法是符合上述要求的查找算法，请将该算法补充完整。 (4分)

typedef struct Node{
ElemType  data; 
   struct Node *left;  
   struct Node *right; 
intfreq;          
} DNode;
DNode *locate_DList(DNode *&L, ElemType x)
{ //在表L中查找元素x，查找成功则调整结点频度域值及结点位置，并返回结点地址；
//查找不成功则返回NULL
DNode *p=L, *q;
   if (L==NULL)  return NULL;
   while (p->data!=x && p->right!=L)  p=p->right;
   if (p->data!=x)  return NULL;
   p->freq++; 
   q=p->left;
   while (q!=L && q->freq<=p->freq)  q=q->left;  //查找插入位置
   if (q==L && q->freq<=p->freq) {  //需将p结点插在头结点L前
//将p结点先从链表中摘下来
p->left->right=p->right; 
      p->right->left=p->left;   
               //将p结点插在L结点前
      p->right=L;
      p->left=L->left;
      L->left->right=p;
      L->left=p;
      L=p;
   }
   else if (q!=p->left ) {  //若q不是p的前驱，则需调整结点位置，将p结点插在q结点后
//将p结点先从链表中摘下来
      p->left->right=p->right; 
      p->right->left=p->left;
      ______________ //将p结点插在q结点后         
   }
   return p;
}

1. p->left=q; p->right=q->right;
2. p->left=q; q->right=p;
3. p->left=q; p->right=q->right; q->right->left=p; q->right=p;
4. p->left=q; q->right=p; p->right=q->right; q->right->left=p;

作者: 严冰

单位: 浙江大学城市学院

2-38

与单链表相比，双链表的优点之一是（）。 (2分)

1. 插入、删除操作更加简单
2. 可随机访问
3. 可以省略表头指针或表尾指针
4. 顺序访问相邻结点更加灵活