第二章作业题3-链表（2）

2-1

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

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

 

2-2

在双向循环链表结点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;

 

2-3

在双向链表存储结构中，删除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;

 

2-4

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

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

 

2-5

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

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

 

2-6      ????????????????????????????????????????????????

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

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

 

2-7

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

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

2-8

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

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

 

2-9

在循环双链表的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-10

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

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

前三个需要遍历链表才能获取最后一个结点。

带头结点的双循环链表可以很快找到尾结点

2-11

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

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

 

2-12

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

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

 

2-13

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

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

 

2-14

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

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

 

2-15

在双向循环链表中，在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-16

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

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

 

2-17

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

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

 

2-18

已知指针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-19

设有一个双向循环链表，每个结点中除有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-20

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

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