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

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

(2分)

A. p->next == h

B. p->next == NULL

C. p == NULL

D. p == h

作者 DS课程组 单位 浙江大学 2-2 在双向循环链表结点p之后插入s的语句是：

(3分)

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;

作者 DS课程组 单位 浙江大学 2-3 在双向链表存储结构中，删除p所指的结点，相应语句为：

(3分)

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

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

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

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

作者 DS课程组 单位 浙江大学 2-4 某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用什么存储方式最节省运算时间？

(2分)

A. 单链表

B. 仅有尾指针的单循环链表

C. 仅有头指针的单循环链表

D. 双链表

作者 DS课程组 单位 浙江大学 2-5 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用哪种存储方式最节省运算时间？

(2分)

A. 单链表

B. 双链表

C. 单循环链表

D. 带头结点的双循环链表

作者 DS课程组 单位 浙江大学 2-6 将线性表La和Lb头尾连接，要求时间复杂度为O(1)，且占用辅助空间尽量小。应该使用哪种结构？

(2分)

A. 单链表

B. 单循环链表

C. 带尾指针的单循环链表

D. 带头结点的双循环链表

作者 DS课程组 单位 浙江大学 2-7 (neuDS)在链表中若经常要删除表中最后一个结点或在最后一个结点之后插入一个新结点，则宜采用（）存储方式。

(2分)

A. 顺序表

B. 用头指针标识的循环单链表

C. 用尾指针标识的循环单链表

D. 双向链表

作者 徐婉珍 单位 广东东软学院 2-8 非空的循环单链表head的尾结点（由p所指向）满足（）。

(2分)

A. p->next == NULL

B. p == NULL

C. p->next == head

D. p == head

作者 严冰 单位 浙江大学城市学院 2-9 在循环双链表的p所指结点之前插入s所指结点的操作是（）。

(2分)

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

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

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

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

作者 严冰 单位 浙江大学城市学院 2-10 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用（）存储方式最节省运算时间。

(2分)

A. 单链表

B. 给出表头指针的单循环链表

C. 双链表

D. 带表头附加结点的双循环链表

作者 严冰 单位 浙江大学城市学院 2-11 某线性表最常用的操作是在最后一个结点之后插入一个结点或删除第一个结点，故采用（）存储方式最节省运算时间。

(2分)

A. 单链表

B. 仅有头结点的单循环链表

C. 双链表

D. 仅有尾指针的单循环链表

作者 严冰 单位 浙江大学城市学院 2-12 在一个长度为n（n>1）的单链表上，设有头和尾两个指针，执行（）操作与链表的长度有关。

(2分)

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

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

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

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

作者 严冰 单位 浙江大学城市学院 2-13 如果对线性表的运算只有4种，即删除第一个元素，删除最后一个元素，在第一个元素前面插入新元素，在最后一个元素的后面插入新元素，则最好使用（）。

(2分)

A. 只有表尾指针没有表头指针的循环单链表

B. 只有表尾指针没有表头指针的非循环双链表

C. 只有表头指针没有表尾指针的循环双链表

D. 既有表头指针也有表尾指针的循环单链表

作者 严冰 单位 浙江大学城市学院 2-14 如果对线性表的运算只有2种，即删除第一个元素，在最后一个元素的后面插入新元素，则最好使用（）。

(2分)

A. 只有表头指针没有表尾指针的循环单链表

B. 只有表尾指针没有表头指针的循环单链表

C. 非循环双链表

D. 循环双链表

作者 严冰 单位 浙江大学城市学院 2-15 在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是（）。

(2分)

A. p->next = s; s->prior = p; (p->next)->prior = s; s->next = p->next;

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

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

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

作者 严冰 单位 浙江大学城市学院 2-16 带表头附加结点的双向循环链表为空的判断条件是头指针L满足条件（）。

(2分)

A. L= =NULL

B. L->right= =NULL

C. L->left = =NULL

D. L->right= =L

作者 严冰 单位 浙江大学城市学院 2-17 循环链表的主要优点是（）。

(2分)

A. 不再需要头指针了

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

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

D. 从表中的任意结点出发都能扫描到整个链表

作者 严冰 单位 浙江大学城市学院 2-18 已知指针ha和hb分别是两个单链表的头指针，下列算法将这两个链表首尾相连在一起，并形成一个循环链表（即ha的最后一个结点链接hb的第一个结点，hb的最后一个结点指向ha），返回该循环链表的头指针。请将该算法补充完整。

typedef struct node{ ElemType data; struct node *next; }LNode; LNode *merge(LNode *ha, LNode *hb) { LNode *p=ha; if (haNULL || hbNULL) { 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; __________ } (4分)

A. ha=p->next; return ha;

B. p->next=ha; return ha;

C. ha=p->next; return p;

D. p->next=ha; return p;

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

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 (LNULL) 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 (qL && 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; } (4分)

A. p->left=q; p->right=q->right;

B. p->left=q; q->right=p;

C. p->left=q; p->right=q->right; q->right->left=p; q->right=p;

D. p->left=q; q->right=p; p->right=q->right; q->right->left=p;

作者 严冰 单位 浙江大学城市学院 2-20 与单链表相比，双链表的优点之一是（）。

(2分)

A. 插入、删除操作更加简单

B. 可随机访问

C. 可以省略表头指针或表尾指针

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

6-1 循环单链表区间删除 (15分) 本题要求实现带头结点的循环单链表的创建和单链表的区间删除。L是一个带头结点的循环单链表，函数ListCreate_CL用于创建一个循环单链表，函数ListDelete_CL用于删除取值大于min小于max的链表元素。

函数接口定义： Status ListCreate_CL(LinkList &CL); void ListDelete_CL(LinkList &CL,ElemType min,ElemType max); 裁判测试程序样例：

//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型  

typedef struct LNode
{  
    ElemType data;  
    struct LNode *next; 
}LNode,*LinkList; //循环单链表类型定义与单链表定义相同，区别在尾节点next取值

Status ListCreate_CL(LinkList &CL);  

void ListDelete_CL(LinkList &CL, ElemType min, ElemType max);

void ListPrint_CL(LinkList &CL) 
{   //输出单链表,空表时输出Empty List。 
    LNode *p=CL->next;  //p指向第一个元素结点
    if(p==CL){
      printf("Empty List");
      return;
    }
    while(p!=CL)  
    {   
        if(p->next!=CL)
            printf("%d ",p->data);   
        else
            printf("%d",p->data);      
        p=p->next; 
    } 
}    
int main() 
{  
    LinkList CL;
    ElemType min,max;
    if(ListCreate_CL(CL)!= OK) 
    {
       printf("循环链表创建失败！！！\n");
       return -1;
    }
    scanf("%d%d",&min,&max);    
    ListDelete_CL(CL,min,max);   
    ListPrint_CL(CL);  	
    return 0;
}

/* 请在这里填写答案 */

输入格式： 第一行输入一个整数n，表示循环单链表中元素个数，接下来一行共n个整数，中间用空格隔开。第三行输入min和max。

输出格式： 输出删除后循环链表的各个元素，两个元素之间用空格隔开，最后一个元素后面没有空格。

输入样例：

6 1 2 3 4 5 6 2 5 输出样例：

1 2 5 6