课后作业2、结构体链表

执行如下程序段，打印输出的内容是：C

#include <stdio.h>
void fun (int c, int *d) {
    c++;
    (*d)++;
}
int main ( ){
    int a=5, b=9;
    fun(a, &b);
    printf("%d, %d", a, b);
    return 0;
}

A.5, 9

B.6, 10

C.5, 10

D.6, 9

---

2-2

以下正确的说明语句是( )。B

A.int *b[ ] = {1, 3, 5, 7, 9};

B.int a[5], *num[5] = {&a[0], &a[1], &a[2], &a[3], &a[4]};

C.

int a[ ] = {1, 3, 5, 7, 9}; 
int *num[5] = {a[0], a[1], a[2], a[3], a[4]};

D.

int a[3][4], (*num)[4]; 
num[1] = &a[1][3];

---

2-3

设有以下定义:

int a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12};
int (*prt)[3]=a,*p=a[0]

则下列能够正确表示数组元素a[1][2]的表达式是D

A.*((*prt+1)[2])

B.*(*(p+5))

C.(*prt+1)+2

D.*(*(a+1)+2)

---

2-4

设有如下定义，则对data中的a成员的正确引用是（）。B

struct sk{ int a; float b; } data, *p=&data;

A.(*p).data.a

B.(*p).a

C.p->data.a

D.p.data.a

---

2-5

下面程序的输出结果是( )。C

# include <stdio.h> 
void fun (int *x, int *y)
{
    printf("%d%d", *x, *y);
    *x = 3;
    *y = 4;
} 
int main(void)
{
    int x=1, y=2;  
    
    fun(&x, &y);  
    printf("%d%d", x, y);

    return 0;
}

A.2134

B.1212

C.1234

D.2112

---

2-6

下面程序的输出结果是( )。D

#include <stdio.h>

void fun (int *x,  int y)
{
    printf("%d%d", *x, y);
    *x=3;  
    y=4;
}
int main(void)
{
    int x = 1, y = 2;
        
    fun(&y, x);
    printf("%d%d", x, y);
        
    return 0;
}

A.1234

B.1221

C.2131

D.2113

---

2-7

设void f1(int * m，long & n)；int a；long b；则以下调用合法的是（）。B

A.f1(a，b)；

B.f1(&a，b)；

C.f1(a，&b)；

D.f1(&a，&b)；

---

2-8

下面程序片段,哪一个是正确的?D

A.int n=4; int &r=n*3;

B.int m=5; const int &r=m; r=6;

C.int n=8; const int &p=n; int &q=p ;

D.int n=8; int &p=n; const int q=p ;

---

2-9

表达式 “new int”的返回值类型是?B

A.int

B.int *

C.int &D.

无法确定

---

2-10

关于delete运算符的下列描述中，（）是错误的。C

A.它必须用于new返回的指针；

B.使用它删除对象时要调用析构函数；

C.对一个指针可以使用多次该运算符；

D.指针名前只有一对方括号符号，不管所删除数组的维数。

---

2-11

以下程序中，new语句干了什么。C

int** num;

num = new int* [20];

A.分配了长度为20的整数数组空间，并将首元素的指针返回。

B.分配了一个整数变量的空间，并将其初始化为20。

C.分配了长度为20的整数指针数组空间，并将num[0]的指针返回。

D.存在错误，编译不能通过。

---

2-12

以下程序存在的问题是：C

void fun()
{
 int *num1, *num2;
 num1 = new int[10];
 num2 = new int[20];
 num1[0] = 100;
 num2[0] = 300;
 num1 = num2;
 delete [] num1;
}

A.num2不能给num1赋值

B.num2最初指向的空间没有释放

C.num1最初指向的空间没有释放

D.程序没有问题

---

2-13

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

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

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

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

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

---

2-14

以下程序的输出结果是（ ）。D

#include <stdio.h>

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;        
}

A.12

B.23

C.14

D.32

---

2-15

以下程序的输出结果是（ ）。D

#include <stdio.h>
#include <stdlib.h>

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;
}

A.10

B.20

C.30

D.40

---

2-16

以下程序段的功能是：输入一行字符，按输入的逆序建立一个链表。B

char c;
struct node{
    char info;
    struct node *link;
} *top, *p;

top = NULL;
while ( (c = getchar() ) != '\n'){
    p = (struct node*) malloc(sizeof(struct node));
    p->info = c;
    _________ ;
    top = p;
}

A.top->link = p

B.p->link = top

C.top = p->link

D.p = top->link

---

2-17

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

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

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

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

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

---

2-18

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

A.p=p->next;free(p);

B.p->next=p->next->next; free(p);

C.q= p->next q->next=p->next; free(q);

D.q=p->next; p->next=q->next; free(q);

---

2-19

以下结构类型可用来构造链表的是（）。B

A.struct aa{ int a；int * b；}；

B.struct bb{ int a；bb * b；}；

C.struct cc{ int * a；cc b；}；

D.struct dd{ int * a；aa b；}；

---

2-20

struct LinkNode{ //链表结点定义

    E data; //数据

    LinkNode * link; //结点后继指针

};

不带头结点的单链表first为空的判定条件是（）。A

A.first==NULL;

B.first->link== NULL;

C.first->link== first;

D.first! = NULL;

---

2-21

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

A.可以加快对表的遍历

B.使空表和非空表的处理统一

C.节省存储空间

D.可以提高存取表元素的速度

---

2-22

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

A.L=L->link;

B.L->link=L->link->link;

C.L=L->link->link;

D.L->link = L；

---

2-23

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

A.单链表

B.静态链表

C.线性链表

D.顺序存储结构

---

2-2

已创建如下的单向链表结构，指针变量s指向链表的第一个结点。以下程序段实现的功能是C）。

p=s->next;
s->next=s->next->next;
free(p);

A.首结点成为尾结点

B.删除首节点的后继节点

C.删除首结点

D.删除尾结点

---

2-25

关于单向链表说法不正确的是：D

A.与数据相比，单向链表适合反复进行删除、插入操作

B.存储空间可以动态的获取和释放

C.结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针

D.单向链表在内存中是连续存储的

---

2-26

若已建立下面的链表结构，指针 p、q 分别指向图中所示结点，则不能将 q 所指结点插入到链表末尾的语句是（ ）。B

A.

q->next = NULL;
p = p->next; 
p->next = q;

B.

p = p->next; 
q->next = p->next;
p->next = q;

C.

p = p->next; 
q->next = p;
p->next = q;

D.

p = (*p).next; 
(*q).next = (*p).next;
(*p).next = q;

 

---

2-27

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

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

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

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

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