出自:国家开放大学数据结构复习题

在循环双链表的p所指结点之后插入s所指结点的操作是（ ）。
A.p->right=s；s->left=p；p->right->left=s；s->right=p->right；
B. p->right=s；p->right->left=s；s->left=p；s->right=p->right；
C. s->left=p；s->right=p->right；p->right=s；p->right->left=s；
D. s->left=p；s->right=p->right；p->right->left=s；p->right=s；
若HL为一个不带表头结点的循环单链表的表头指针，若有HL->next= =HL条件存在，则该循环单链表是（ ）。
A.空表 B.只有1个元素；
C.空表或只有一个元素 D.非空表
若HL为一个带表头结点的单链表的表头指针，则该表为空表的条件是（ ）。
A.HL==NULL B.HL->next==NULL
C.HL->next==HL D.HL!=NULL
设头指针为head的非空的单向链表，指针p指向尾结点,则通过以下操作（ ）可使其成为单向循环链表。
选择一项：
A. head = p; B. p=head;
C. p->next = NULL ; D. p->next=head;
设有一个不带头结点的单向循环链表，结点的指针域为next，指针p指向尾结点，现要使p指向第一个结点，可用语句p=p->next;。
设有一个单向链表，结点的指针域为next，头指针为head，p指向尾结点，为了使该单向链表改为单向循环链表，可用语句p->next=head
设有一个单向循环链表，结点的指针域为next，头指针为head，指针p指向表中某结点，若逻辑表达式p->next==head;的结果为真，则p所指结点为尾结点。
要在一个单向链表中删除p所指向的结点，已知q指向p所指结点的直接前驱结点，若链表中结点的指针域为next，则可执行q->next= p->next
要在一个单向链表中p所指向的结点之后插入一个s所指向的新结点，若链表中结点的指针域为next，可执行 p->next=s; s->next= p->next；的操作。
要在一个带头结点的单向循环链表中删除头结点，得到一个新的不带头结点的单向循环链表，若结点的指针域为next，头指针为head，尾指针为p，则可执行head=head-> next; p->next=head；
设有一个单向循环链表，头指针为head，链表中结点的指针域为next，p指向尾结点的直接前驱结点，若要删除尾结点，得到一个新的单向循环链表，可执行操作p->next=head；。
线性表用顺序方式存储可以随机访问。
设有一个长度为40的顺序表，要删除第8个元素需移动元素的个数为3
线性表用关键字的顺序方式存储，可以用二分法排序
设线性表以不带头结点的单向链表存储，链表头指针为head，以下程序的功能是输出链表中各结点中的数据域data,完成程序中空格部分。
#define NULL 0
void main（ ）
{ NODE *head ,*p ;
p=head; /*p为工作指针*/
do
{printf(“%d\n”,
[ 1 ];
[ 2 ];
}while
[ 3 ]；
设有一个头指针为head的不带头结点单向链表，p、q是指向链表中结点类型的指针变量，p指向链表中结点a, （设链表中没有结点的数据域与结点a的数据域相同）,写出相关语句
(1)使该单向链表成为单向循环链表
(2)插入结点s,使它成为a结点的直接前驱
q=p; x=p->data;
while（[ 4 ]）q=q->next;
q->next=head;
q=p; p=p->next;
while(p->data!=x)
{ q=p;
[ 5 ]
}
s->next=p;
[ 6 ]
设有一个不带头结点的单向链表，头指针为head，p、prep是指向结点类型的指针，该链表在输入信息时不慎把相邻两个结点的信息重复输入，以下程序段是在该单向链表中查找这相邻两个结点，把该结点的数据域data打印出来，并把其中之一从链表中删除，填写程序中的空格。
prep=head;
p=prep->next;
while(p->data!=prep->data)
{
prep=p;
[ 7 ];
}
printf(“min=%d”,
[ 8 ]);
prep->next= [ 9 ];
若让元素1，2，3依次进栈，则出栈顺序不可能为（ ）。
A．3，2，1 B．2，1，3
C．3，1，2 D．1，3，2
一个队列的入队序列是1，2，3，4。则队列的输出序列是（ ）。
A．4，3，2，1 B．1，2，3，4
C．1，4，3，2 D．3，2，4，1
一个栈的进栈序列是10，20，30，40，50，则栈的不可能输出序列是（ ）（进栈出栈可以交替进行）。
A．10,20,30,40,50 B．40,30,50,10,20
C．40,50,30,20,10 D．50,40,30,20,10
元素4，6，8，10按顺序依次进栈，按该栈的可能输出序列依次入队列，该队列的可能输出序列是（ ）（进栈出栈可以交替进行）。
A．10，8，4，6 B．10，6，4，8
C．8，4，6，10 D．10，8，6，4
向顺序栈中压入新元素时，应当（ ）。
A．先移动栈顶指针，再存入元素
B．先存入元素，再移动栈顶指针
C．先后次序无关紧要
D．同时进行
在一个栈顶指针为top的链栈中，将一个p指针所指的结点入栈，应执行（ ）。
A．top->next=p;
B．p->next=top->next; top->next=p;
C．p->next=top; top=p;
D．p->next=top->next; top=top->next;
在一个栈顶指针为top的链栈中删除一个结点时，用 x保存被删结点的值，则执行（ ）。
A．x=top;top=top->next;
B．x=top->data;
C．top=top->next; x=top->data;
D．x=top->data; top=top->next;
一般情况下，将递归算法转换成等价的非递归算法应该设置（ ）。
A．栈 B．队列
C．堆栈或队列 D．数组
表达式a*(b+c)-d的后缀表达式是（ ）。+++
A．abcd*+- B．abc+*d- C．abc*++d- D．-+*abcd
判断一个顺序队列sq（最多元素为m）为空的条件是（ ）。
A．sq->rear-sq->front== m B．sq->rear-sq->front-1= = m
C．sq->front==sq->rear D．sq->front==sq->rear+1
判断一个循环队列Q（最多元素为m）为满的条件是（ ）。
A．Q->front==Q->rear B．Q->front!=Q->rear
C．Q->front==(Q->rear+1)% m D．Q->front!= (Q->rear+1)% m
判断栈s满（元素个数最多n个）的条件是（ ）。
A．s->top==0 B．s->top!=0
C．s->top==n-1 D．s->top!=n-1
一个队列的入队顺序是a,b,c,d，则离队的顺序是（ ）。
A．a,d,cb B．a,b,c,d C．d,c,b,a D．c,b,d,a
如果以链表作为栈的存储结构，则退栈操作时（ ）。
A．必须判断栈是否满 B．判断栈元素类型
C．必须判断栈是否空 D．对栈不作任何判断
在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印数据缓冲区，主机将要输出的数据依次写入缓冲区中，而打印机则从缓冲区中取出数据打印，该缓冲区应该是一个（ ）结构。
A．堆栈 B．队列 C．数组 D．先性表
一个递归算法必须包括（ ）。
A．递归部分 B．终止条件和递归部分
C．迭代部分 D．终止条件和迭代部分
从一个栈顶指针为top的链栈中删除一个结点时，用变量x保存被删结点的值，则执行（ ）。
A．x=top->data; top=top->next; B．x=top->data;
C．top=top->next; x=top->data; D．top=top->next; x=data;
在一个链队中，假设f和r分别为队头和队尾指针，则删除一个结点的运算为（ ）。
A．r=f->next; B．r=r->next; C．f=f->next; D．f=r->next;
在一个链队中，假设f和r分别为队头和队尾指针，则插入s所指结点的运算为（ ）。
A．f->next=s; f=s; B．r->next=s;r=s;
C．s->next=r;r=s; D．s->next=f;f=s;
在一个不带头结点的链队中，假设f和r分别为队头和队尾指针，则从该对列中删除一个结点并把结点的值保存在变量x中的运算为（ ）。+++
A．x=r->data；r=r->next; B．r=r->next; x=r->data
C．x=f->data；f=f->next; D．f=f->next; x=f->data
栈和队列的共同特点是（ ）。
A．都是先进后出 B．元素都可以随机进出
C．只容许在端点处插入和删除元素 D．都是先进先出
栈的插入和删除操作在（ ）进行。
A．栈顶 B．栈底
C．任意位置 D．指定位置
在一个顺序队列中，队首指针指向队首元素的（ ）位置。
A．前一个 B．后一个
C．当前 D．后面
当利用大小为n的数组顺序存储一个队列时，该队列的最大长度为( )。
A. n-2 B. n-1 C. n D. n+1
从一个顺序存储的循环队列中删除一个元素时，首先需要( )。
A. 队头指针加一 B. 队头指针减一
C. 取出队头指针所指的元素 D. 取出队尾指针所指的元素
链式栈与顺序栈相比, 一个明显的优点是通常不会出现栈满的情况。
在一个顺序存储的循环队列中, 队头指针指向队头元素的后一个位置。
栈和队列都是顺序存取的线性表, 但它们对存取位置的限制不同。
若让元素1,2,3依次进栈，则出栈次序1,3,2是不可能出现的情况。
在用单链表表示的链式队列Q中，队头指针为Q->front，队尾指针为Q->rear，则队空条件为Q->front == Q->rear
递归定义的数据结构通常用递归算法来实现对它的操作。
递归的算法简单、易懂、容易编写，而且执行效率也高。
递归调用算法与相同功能的非递归算法相比，主要问题在于重复计算太多，而且调用本身需要分配额外的空间和传递数据和控制，所以时间与空间开销通常都比较大。
首页 <上一页 1 2 3 4 5 下一页> 尾页