| 显示国家开放大学系统国家开放大学数据结构复习题所有答案 |
|
从一个顺序存储的循环队列中删除一个元素时，首先需要( )。
A. 队头指针加一 B. 队头指针减一
C. 取出队头指针所指的元素 D. 取出队尾指针所指的元素
|
答案是：A
|
|
当利用大小为n的数组顺序存储一个队列时，该队列的最大长度为( )。
A. n-2 B. n-1 C. n D. n+1
|
答案是：B
|
|
在一个顺序队列中，队首指针指向队首元素的（ ）位置。
A．前一个 B．后一个
C．当前 D．后面
|
答案是：A
|
|
栈的插入和删除操作在（ ）进行。
A．栈顶 B．栈底
C．任意位置 D．指定位置
|
答案是：A
|
|
栈和队列的共同特点是（ ）。
A．都是先进后出 B．元素都可以随机进出
C．只容许在端点处插入和删除元素 D．都是先进先出
|
答案是：C
|
|
在一个不带头结点的链队中，假设f和r分别为队头和队尾指针，则从该对列中删除一个结点并把结点的值保存在变量x中的运算为（ ）。+++
A．x=r->data；r=r->next; B．r=r->next; x=
|
答案是：C
|
|
在一个链队中，假设f和r分别为队头和队尾指针，则插入s所指结点的运算为（ ）。
A．f->next=s; f=s; B．r->next=s;r=s;
C．s->next=r;r=s;
|
答案是：B
|
|
在一个链队中，假设f和r分别为队头和队尾指针，则删除一个结点的运算为（ ）。
A．r=f->next; B．r=r->next; C．f=f->next; D．f=r->next;
|
答案是：C
|
|
从一个栈顶指针为top的链栈中删除一个结点时，用变量x保存被删结点的值，则执行（ ）。
A．x=top->data; top=top->next; B．x=top->data;
C．top=top->next; x=to
|
答案是：A
|
|
一个递归算法必须包括（ ）。
A．递归部分 B．终止条件和递归部分
C．迭代部分 D．终止条件和迭代部分
|
答案是：D
|
|
在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印数据缓冲区，主机将要输出的数据依次写入缓冲区中，而打印机则从缓冲区中取出数据打印，该缓冲区应该是一个（ ）结构。
A．堆栈 B．队列 C．数组
|
答案是：B
|
|
如果以链表作为栈的存储结构，则退栈操作时（ ）。
A．必须判断栈是否满 B．判断栈元素类型
C．必须判断栈是否空 D．对栈不作任何判断
|
答案是：C
|
|
一个队列的入队顺序是a,b,c,d，则离队的顺序是（ ）。
A．a,d,cb B．a,b,c,d C．d,c,b,a D．c,b,d,a
|
答案是：B
|
|
判断栈s满（元素个数最多n个）的条件是（ ）。
A．s->top==0 B．s->top!=0
C．s->top==n-1 D．s->top!=n-1
|
答案是：C
|
|
判断一个循环队列Q（最多元素为m）为满的条件是（ ）。
A．Q->front==Q->rear B．Q->front!=Q->rear
C．Q->front==(Q->rear+1)% m
|
答案是：C
|
|
判断一个顺序队列sq（最多元素为m）为空的条件是（ ）。
A．sq->rear-sq->front== m B．sq->rear-sq->front-1= = m
C．sq->front==
|
答案是：C
|
|
表达式a*(b+c)-d的后缀表达式是（ ）。+++
A．abcd*+- B．abc+*d- C．abc*++d- D．-+*abcd
|
答案是：B
|
|
一般情况下，将递归算法转换成等价的非递归算法应该设置（ ）。
A．栈 B．队列
C．堆栈或队列 D．数组
|
答案是：A
|
|
在一个栈顶指针为top的链栈中删除一个结点时，用 x保存被删结点的值，则执行（ ）。
A．x=top;top=top->next;
B．x=top->data;
C．top=top->next; x=top->dat
|
答案是：D
|
|
在一个栈顶指针为top的链栈中，将一个p指针所指的结点入栈，应执行（ ）。
A．top->next=p;
B．p->next=top->next; top->next=p;
C．p->next=top; top=p;
|
答案是：C
|
|
向顺序栈中压入新元素时，应当（ ）。
A．先移动栈顶指针，再存入元素
B．先存入元素，再移动栈顶指针
C．先后次序无关紧要
D．同时进行
|
答案是：A
|
|
元素4，6，8，10按顺序依次进栈，按该栈的可能输出序列依次入队列，该队列的可能输出序列是（ ）（进栈出栈可以交替进行）。
A．10，8，4，6 B．10，6，4，8
C．8，4，6，10
|
答案是：D
|
|
一个栈的进栈序列是10，20，30，40，50，则栈的不可能输出序列是（ ）（进栈出栈可以交替进行）。
A．10,20,30,40,50 B．40,30,50,10,20
C．40,50,30,20,
|
答案是：B
|
|
一个队列的入队序列是1，2，3，4。则队列的输出序列是（ ）。
A．4，3，2，1 B．1，2，3，4
C．1，4，3，2 D．3，2，4，1
|
答案是：B
|
|
若让元素1，2，3依次进栈，则出栈顺序不可能为（ ）。
A．3，2，1 B．2，1，3
C．3，1，2 D．1，3，2
|
答案是：C
|
|
设有一个不带头结点的单向链表，头指针为head，p、prep是指向结点类型的指针，该链表在输入信息时不慎把相邻两个结点的信息重复输入，以下程序段是在该单向链表中查找这相邻两个结点，把该结点的数据域data打印出来，并把其中之一从链表中删除，
|
答案是：（7）p=p->next; （8）p->data或prep->data （9）p->next
|
|
设有一个头指针为head的不带头结点单向链表，p、q是指向链表中结点类型的指针变量，p指向链表中结点a, （设链表中没有结点的数据域与结点a的数据域相同）,写出相关语句
(1)使该单向链表成为单向循环链表
(2)插入结点s,使它
|
答案是：（4）q >next!=NULL （5）p=p >next （6）q >next=s
|
|
设线性表以不带头结点的单向链表存储，链表头指针为head，以下程序的功能是输出链表中各结点中的数据域data,完成程序中空格部分。
#define NULL 0
void main（ ）
{ NODE *head
|
答案是：（1）p >data （2） p=p >next （3）p!=NULL
|
|
线性表用关键字的顺序方式存储，可以用二分法排序
|
答案是：错
|
|
设有一个长度为40的顺序表，要删除第8个元素需移动元素的个数为3
|
答案是：错
|
|
线性表用顺序方式存储可以随机访问。
|
答案是：对
|
|
设有一个单向循环链表，头指针为head，链表中结点的指针域为next，p指向尾结点的直接前驱结点，若要删除尾结点，得到一个新的单向循环链表，可执行操作p->next=head；。
|
答案是：对
|
|
要在一个带头结点的单向循环链表中删除头结点，得到一个新的不带头结点的单向循环链表，若结点的指针域为next，头指针为head，尾指针为p，则可执行head=head-> next; p->next=head；
|
答案是：对
|
|
要在一个单向链表中p所指向的结点之后插入一个s所指向的新结点，若链表中结点的指针域为next，可执行 p->next=s; s->next= p->next；的操作。
|
答案是：错
|
|
要在一个单向链表中删除p所指向的结点，已知q指向p所指结点的直接前驱结点，若链表中结点的指针域为next，则可执行q->next= p->next
|
答案是：对
|
|
设有一个单向循环链表，结点的指针域为next，头指针为head，指针p指向表中某结点，若逻辑表达式p->next==head;的结果为真，则p所指结点为尾结点。
|
答案是：对
|
|
设有一个单向链表，结点的指针域为next，头指针为head，p指向尾结点，为了使该单向链表改为单向循环链表，可用语句p->next=head
|
答案是：对
|
|
设有一个不带头结点的单向循环链表，结点的指针域为next，指针p指向尾结点，现要使p指向第一个结点，可用语句p=p->next;。
|
答案是：对
|
|
设头指针为head的非空的单向链表，指针p指向尾结点,则通过以下操作（ ）可使其成为单向循环链表。
选择一项：
A. head = p; B. p=head;
C. p->next = NULL ; D.
|
答案是：D
|
|
若HL为一个带表头结点的单链表的表头指针，则该表为空表的条件是（ ）。
A.HL==NULL B.HL->next==NULL
C.HL->next==HL
|
答案是：B
|
|
若HL为一个不带表头结点的循环单链表的表头指针，若有HL->next= =HL条件存在，则该循环单链表是（ ）。
A.空表 B.只有1个元素；
C.空表或只有一个元素 D.非
|
答案是：B
|
|
在循环双链表的p所指结点之后插入s所指结点的操作是（ ）。
A.p->right=s；s->left=p；p->right->left=s；s->right=p->right；
B. p->right=s；p->right
|
答案是：B
|
|
在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入s结点，则以下操作哪个是正确的（ ）。
A. s->next=p->next；p->next=s；
B. p->next=s->next；s->ne
|
答案是：D
|
|
在一个单链表HL中，若要向表头插入一个由指针p指向的结点，则执行_________。
A. HL=p;p->next=HL;
B. p->next=HL;HL=p;
C. p->next=HL;p=HL;
D. p->next=HL
|
答案是：A
|
|
设有一个长度为n的顺序表，要在第i个元素之前（也就是插入元素作为新表的第i个元素），插入一个元素，则移动元素个数为（ ）。
A. n-i+1 B. i
C. n-i-1 D. n-i
|
答案是：A
|
|
对链表, 以下叙述中正确的是（ ）。
A. 不能随机访问任一结点
B. 插入删除元素的操作一定要要移动结点
C. 结点占用的存储空间是连续的
D. 可以通过下标对链表进行直接访问
|
答案是：A
|
|
在线性表的顺序结构中，以下说法正确的是（ ）。
A. 逻辑上相邻的元素在物理位置上不一定相邻
B. 数据元素是不能随机访问的
C. 进行数据元素的插入、删除效率较高
D. 逻辑上相邻的元素在物理位置上也相邻
|
答案是：D
|
|
在一个不带头结点的单循环链表中，p、q分别指向表中第一个结点和尾结点，现要删除第一个结点，且p、q仍然分别指向新表中第一个结点和尾结点。可用的语句是p=p->next;和（ ）。
A. q->next=p B. p->nex
|
答案是：A
|
|
一个顺序表第一个元素的存储地址是90，每个元素的长度为2，则第6个元素的地址是（ ）。
A. 106 B. 98
C. 102 D. 100
|
答案是：A
|
|
向一个有127个元素的顺序表中插入一个新元素，并保持原来的顺序不变，平均要移动（ ）个元素。
A. 63.5 B. 7
C. 63 D. 8
|
答案是：A
|
|
有关线性表的正确说法是（ ）。
A. 线性表至少要求一个元素
B. 每个元素都有一个直接前驱和一个直接后继
C. 表中的元素必须按由小到大或由大到下排序
D. 除了一个和最后一个元素外，其余元素都有一个且仅有一个直接前驱和
|
答案是：D
|
|
在一个长度为n的顺序表中为了删除第5个元素，由第6个元素开始从后到前依次移动了15个元素。则原顺序表的长度为（ ）。
A. 19 B. 21 C. 20 D. 25
|
答案是：C
|
|
带头结点的链表为空的判断条件是（ ）（设头指针为head）。
A. head->next==head
B. head ==NULL
C. head->next==NULL
D. head!=NULL
|
答案是：A
|
|
链表不具有的特点是（ ）。
A. 不必事先估计存储空间
B. 可随机访问任一元素
C. 逻辑上相邻的元素在物理位置上不一定相邻
D. 插入删除不需要移动元素
|
答案是：B
|
|
非空的单向循环链表的尾结点满足（ ）（设头指针为head，指针p指向尾结点）。
A. p->next==head B. p==NULL
C. p== head D. p->next==NULL
|
答案是：A
|
|
在一个单链表中p所指结点之后插入一个s所指的结点时，可执行（ ）。
A. p->next= s; s->next= p->next B. p->next=s->next;
C. s->next=p->next; p->next
|
答案是：C. s->next=p->next; p->next=s;
|
|
在一个单链表中，p、q分别指向表中两个相邻的结点，且q所指结点是p所指结点的直接后继，现要删除q所指结点，可用语句（ ）。
A. q->next=NULL B. p->next=q->next
C. p=q->next
|
答案是：B. p->next=q->next
|
|
设有一个长度为n的顺序表，要删除第i个元素移动元素的个数为（ ）。A. I B. n-i-1 C. n-i D. n-i+1
|
答案是：C. n-i
|
|
设有一个长度为n的顺序表，要在第i个元素之前（也就是插入元素作为新表的第i个元素），插入一个元素，则移动元素个数为（ ）。
A. n-i B. n-i-1 C. n-i+1
|
答案是：C. n-i+1
|
|
int fun (int n)
{
int I=1, s=1;
while (s
|
答案是：O(n)
|
|
目前为：
5/6
页
首页 上页 下页 尾页
|
