MOOC 数据结构 第三周

1.与单链表相比，双链表的优点之一是（D ）。
A.插入、删除操作更简单
B.可以进行随机访问
C.可以省略表头指针或表尾指针
D.访问前后相邻节点更方便
2.带头节点的双链表L为空表时应满足（ D）。
A.L= =NULL
B.L->prior= =L->next
C.L->prior= =NULL
D.L->next= =NULL
3.在长度为n（n≥1）的双链表中插入一个节点（非尾节点）要修改（D ）个指针域。
A.1
B.2
C.3
D.4
4.对于长度为n（n≥1）的双链表L，在p所指节点之前插入一个新节点的算法的时间复杂度为（ A）。
A.O(1)
B.O(n)
C.

D.
5.在长度为n（n≥1）的双链表中删除一个节点（非尾节点）要修改（B ）个指针域。
A.1
B.2
C.3
D.4
6.与非循环单链表相比，循环单链表的主要优点是（D ）。
A.不再需要头指针
B.已知某个节点的位置后，能够容易找到它的前驱节点
C.在进行插入、删除操作时，能更好地保证链表不断开
D.从表中任意节点出发都能扫描到整个链表
7.设有带头节点的循环单链表L，当这种链表成为空链表时，有（C ）。
A.表头节点指针域next为空
B.L的值为NULL
C.表头节点的指针域next与L的值相等
D.表头节点的指针域next与L的地址相等
8.在长度为n（n≥1）的循环双链表L中，删除尾节点的时间复杂度为（A ）。
A.O(1)
B.O(n)
C.

D.
9. 将两个含有m、n个节点的有序单链表归并成一个有序单链表，要求不破坏原有的单链表，对应算法的空间复杂度是（C）（MIN表示取最小值）。
A.O(n)
B.O(m)
C.O(m+n)
D.O(MIN(m,n))
10.知两个长度分别为m 和n 的升序单链表，若将它们合并为一个长度为m+n 的降序单链表，则时间复杂度是（D）。
A.O(n)
B.O(m×n)
C.O(m)
D.O(m+n)
11.在长度为n（n≥1）的双链表L中，删除p所指节点的时间复杂度为（A）。
A.O(1)
B.O(n)
C.

D.
12.在长度为n（n≥1）的循环单链表L中，删除尾节点的时间复杂度为( B)
A.O(1)
B.O(n)
C.

D.
13.在只有尾节点指针rear没有头节点的非空循环单链表中，删除尾节点的时间复杂度为（ B）。
A.O(1)
B.O(n)
C.

D.
14.在只有尾节点指针rear没有头节点的非空循环单链表中，删除开始节点的时间复杂度为（A ）。
A.O(1)
B.O(n)
C.

D.
15.两个长度为n的双链表，节点类型相同，若以h1为头指针的双链表是非循环的，以h2为头指针指针的双链表是循环的，则（D）。
A.对于非循环双链表来说，删除首节点的操作，其时间复杂度都是O(n)
B.对于循环双链表来说，删除首节点的操作，其时间复杂度都是O(n)
C.对于非循环双链表来说，删除尾节点的操作，其时间复杂度都是O(1)
D.对于循环双链表来说，删除尾节点的操作，其时间复杂度都是O(1)

1 .以L为头节点指针，给出单链表、双链表、循环单链表和循环双链表中，p所指节点为尾节点的条件。
单链表：p->next= =NULL
双链表：p->next= =NULL
循环单链表：p->next= =L
循环双链表：p->next= =L
2 .有一个双链表L，设计一个算法计算其中值为x的节点个数。
int count(DLinkList L,int x)
{
int sum=0;
DLinkList p=L->next ;
while(p!=NULL)
{
if(p->data = =x)
sum++;
p=p->next ;
}
return sum;
}
3 .有一个非空双链表L，设计一个算法删除第一个值为x的节点。
bool delet(DLinkList &L,int x)
{
DLinkList p=L,q,r;
int i=0;
while(p!=NULL&&(p->data)! =x)
{
p=p->next ;
}
if(p==NULL) return false;
else
{
q=p->next ;
r=p->prior ;
q->prior=r;
r->next=q;
free§;
/ p->next =q->next ;
if(p->next !=NULL)
p->next ->prior=p;
free(q);/ //如果要删除的元素在第一个就不行
return true;
}
}
4 .设计一个算法，求一个非空循环单链表L中最后一个最大节点的逻辑序号。
/#include<iostream>
#include <cstdlib>
using namespace std;
typedef struct LNode
{
int data;
int no;
struct LNode *next;
}LinkList;
void CreateList(LinkList *&L,int a[],int n)
{
int i;
LinkList *r,*s;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data =a[i];
s->no =i;
r->next =s;
r=s;
}
r->next =NULL;
}
void find(LinkList *L)
{
int m;
LinkList p=L->next,q=p->next;
while(p!=NULL)
{
if(p->data<=(q->data))
p=q;
q=q->next;
m=p->no;
}
cout<<m;
}
int main()
{
int b[10]={1,2,4,3,2,7,4,8,3,7};
LinkList L1;
CreateList(L1,b,10);
find(L1);
return 0;
}
这个代码是有问题的，一直没有输出。。。。请帮忙指出问题。
5 .对于有n（n≥1）个节点的循环单链表L，假设所有节点值是递增有序的，设计一个算法就地删除所有值重复的节点。
bool delet(DLinkList *&L)
{
int i=0;
DLinkList *p=L,*q;
while(p!=NULL)
{
if(p->data == p->prior->data ) //原本写的与后面的元素进行比较，但如果像 1 1 1 1 多个相同就不行，所以改为与前面进行比较
{
q=p->prior;
q->next=p->next;
if(p->next!=NULL)
p->next->prior=q;
free§;
}
p=p->next;
}
}
6 .用带头节点单链表表示集合，假设该单链表中的元素递增有序，设计一个高效算法求两个集合的交集，并分析该算法的时间和空间复杂度。
void bingji(LinkList *L1,LinkList *L2,LinkList *&L)
{
LinkList *p=L1->next,*q=L2->next,*r,*s;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
while(p!=NULL&&q!=NULL)
{
if(p->data>q->data) q=q->next;
if(p->datadata) p=p->next;
if(p->data==q->data)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=p->data;
r->next=s;
r=s;
p=p->next;
q=q->next;
}
}
r->next=NULL;
}
时间复杂度为O(min(m,n));
空间复杂度为O(m+n)；