PTA选择判断——2019_4List_单向链表中的每个结点都需要动态分配内存空间。

1-1 单向链表中的每个结点都需要动态分配内存空间。

对

1-2 通常使用结构的嵌套来定义单向链表结点的数据类型。

对

2-1链表不具有的特点是（ ）。3

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

2-2设有如下定义的链表，则值为7的表达式是（）。3

struct st{
      int n;
      struct st  *next;
} a[3] = {5, &a[1], 7, &a[2], 9, NULL}, *p = &a;

1. p->n
2. (p->n)++
3. (++p)->n
4. p->next->n

不太明白为什么第四个选项不可以

2-3带表头附加结点的单链表head为空的判断条件是（）。2

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

2-4一个函数功能不太复杂，但要求被频繁调用，选用（ ）。1

1. 内联函数
2. 重载函数
3. 递归函数
4. 嵌套函数

2-5重载函数在调用时选择的依据中，错误的是（）。4

1. 函数的参数
2. 参数的类型
3. 函数的名字
4. 函数的类型

2-6以下有关函数的叙述中正确的是（ ）。3

1. 函数必须返回一个值
2. 函数体中必须有return语句
3. 两个同名函数，参数表相同而返回值不同不算重载
4. 函数执行中形参的改变会改变实参

2-7下列函数中，（ ）不能重载。3

1. 成员函数
2. 非成员函数
3. 析构函数
4. 构造函数

2-8下列关于函数重载的说法中，错误的是____。4

1. 重载函数的参数个数不同
2. 重载函数参数类型不同
3. 重载函数的函数名必须相同
4. 重载函数的返回值类型不同

2-9设单链表中结点的结构为
struct LinkNode{ //链表结点定义
    E data; //数据
    LinkNode * link; //结点后继指针
};
不带头结点的单链表first为空的判定条件是（）。1

1. first==NULL;
2. first->link== NULL;
3. first->link== first;
4. first! = NULL;

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

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

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

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-12若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用（）存储方式最节省运算时间。4

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

2-13在单链表指针为p的结点之后插入指针为s的结点，正确的操作是（）。2

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

2-14已知L是带头结点的单链表，则摘除首元结点的语句是（ ）。2

1. L=L->link;
2. L->link=L->link->link;
3. L=L->link->link;
4. L->link = L；

2-15单链表中，增加一个头结点的目的是（ ）。3

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

2-16需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是（）。2

1. 单链表
2. 静态链表
3. 线性链表
4. 顺序存储结构

2-17下面叙述正确的是（ ）1

1. 对单链表进行插入和删除运算时，不必移动元素，只要修改指针
2. 对数组进行插入和删除运算时，不必移动元素
3. 对单链表和数组进行插入和删除运算时，都必须移动大量元素
4. 对单链表进行插入运算时，需要移动元素，而执行删除运算时不必移动元素

2-18在一个单链表head中，若要在指针p所指结点后插入一个q指针所指结点，则执行（）。4

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

2-19以下程序的输出结果是（ ）。1

struct HAR
{int x, y; struct  HAR  *p;} h[2];
int main(void)
{ h[0].x=1; h[0].y=2;
  h[1].x=3; h[1].y=4;
  h[0].p=h[1].p=h;
  printf(“%d%d\n”,(h[0].p)->x,(h[1].p)->y);		
  return 0;		}
 

1. 12
2. 23
3. 14
4. 32

2-20以下程序的输出结果是（ ）。4

struct NODE{ int num;  struct NODE  *next; };
int main(void)
{ struct NODE *p,*q,*r;
  p=(struct NODE*)malloc(sizeof(struct NODE));
  q=(struct NODE*)malloc(sizeof(struct NODE));
  r=(struct NODE*)malloc(sizeof(struct NODE));
  p->num=10; q->num=20; r->num=30;
  p->next=q;q->next=r;
  printf(“%d\n”,p->num+q->next->num);	
  return 0;		}
 

1. 10
2. 20
3. 30
4. 40

2-21下面程序段输入一行字符，按输入的逆序建立一个链表。2

struct node{
  char info;
  struct node *link;
} *top, *p;
char c;
top=NULL;
while((c=getchat())!='\n')
{  p=( struct node*)malloc(sizeof(struct node));
   p->info=c;

   ;
   top=p;
}
 

1. top->link=p
2. p->link=top
3. top=p->link
4. p=top->link

2-22在一个单链表head中，若要删除指针p所指结点的后继结点，则执行（）。4

1. p=p->next;free(p);
2. p->next=p->next->next; free(p);
3. q=p->next q->next=p->next; free(q);
4. q=p->next; p->next=q->next; free(q);