一、单选题（每题 2 分，共30分）
(1）数据在计算机存储器内表示时，物理地址和逻辑地址相同并且是连续的，称之为 ( C ）。
A．存储结构 B．逻辑结构 C．顺序存储结构 D．链式存储结构
(2) 用链表表示线性表的优点是（ B ）。
A．便于随机存取 B．便于进行插入和删除操作
C．占用的存储空间较顺序表少 D．元素的物理顺序与逻辑顺序相同
(3)已知单链表的每个结点包括一个指针域next，它指向该结点的后继结点。现要将指针 q 指向的新结点插入到指针 p 指向的结点之后，下面的操作序列中正确的是（ C ）。
A . q = p.next ; p.next = q.next ;
B . p.next = q.next ; q = p.next ;
C . q.next = p.next; p.next = q ;
D . p.next = q ; q.next = p.next ;
(4)若长度为 n 的线性表采用顺序存储结构，访问其第 i 个元素的算法时间复杂度为（ A ）。
A. 0 ( l ) B. 0 ( n ) C. 0 ( n2 ) D. 0 ( log2n )
(5)若长度为 n 的线性表采用顺序存储结构，删除其第 i 个元素的算法时间复杂度为（ B ）。
A. 0 ( l ) B. 0 ( n ) C. 0 ( n2 ) D. 0 ( log2n )
(6) 带头结点的单链表L为空的条件是( C )
A. L!＝NULL B. L＝＝NULL C. L.next＝＝NULL D. L.next＝＝L
(7) 将长度为m的单链表接在长度为n的单链表之后的算法的时间复杂度为( B )：
A．O（m+n） B.O(n) C.O(m) D.(m*n)
(8)有 6 个元素按 6 、 5 、 4 、 3 、 2 、 1 的顺序进栈，进栈过程中可以出栈，则以下可能的出栈序列是（ B ）。
A . 1 、 4 、 3 、 5 、 2 、 6 B . 6 、 5 、 4 、 3 、 2 、 l C . 3 、 l 、 4 、 2 、 6 、 5 D . 3 、 6 、 5 、 4 、 2 、 l
(9)以下不属于栈的基本运算的是（ B ）。
A．删除栈顶元素 B．删除栈底元素 C．判断栈是否为空 D．将栈置为空栈
(10)若顺序循环队列长度为M， front 为当前队头元素的前一个位置，rear为队尾元素的位置，假定队中元素的个数总是小于 M ，则当前队中元素的个数为（ D ）。
A. rear-front B. M + front - rear
C. M + rear -1 D. (rear–front +M) % M
(11)若顺序循环队列长度为n，其队头和队尾指针分别用front和 rear 表示，则判断队满的条件是（ C ）。
A. ( rear - 1 ) % n = ＝front B. ( front + 1 ) % n = = rear
C. ( rear + 1 ) % n = =front D. ( front - l ) % n = = rear
(12)链栈与顺序栈相比有1个明显的优点，( B )。
A.插入操作更加利便 B.通常不会出现栈满的情况
C.不会出现栈空的情况 D.删除操作更加利便
(13)设有一个空队列，若进入队列的序列为 1 , 2 , 3 , 4 ，则合法的出队序列是（ D ）。
A. 3 , 2 , 4 , 1 B. 4 , 2 , 3 , l
C. 4 , 3 , 2 , 1 D. l , 2 , 3 , 4
(14) 设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度为（ B ）。
A．O(1) B． O(n) C．O(n2) D．O(log2n)
(15) 设带头节点链式栈中结点的结构为（data, next），且head是指向该栈的指针。若想在栈顶插入一个由指针s所指的结点，则应执行操作（ B ）。
A. s.next=head; head.next = s;
B. s.next = head.next; head.next = s;
C. s.next = head; head = s;
D. s.next = head; head = head .next;
二、判断题（每题 1 分，共10分）
(1)顺序存储的线性表可以实现随机存取。( √ )
(2)线性表的链式存储结构优于顺序存储。( × )
(3)栈是运算受限制的线性表。( √ )
(4)链表的每个结点都恰好包含一个指针域。( × )
(5)如果某数据结构的每一个元素最多只有一个直接前驱，则其必为线性表( × )
(6)进栈操作时，必须判断栈是否已满。 (× )
(7)不管栈采用何种存储结构，只要不为空，就可以任意的删除数据元素。( × )
(8)线性表若采用链式存储表示时所有存储结点之间的地址可连续也可不连续( √ )
(9) 在一个循环队列Q中，判断队满的条件为(Q. front+1) % MaxSize == Q. rear（ × ）
(10) 在对链队列作出队操作时，不会改变front指针的值。( × )
三、填空题（每题 2 分，共20分）
- 在线性结构、树形结构和图形结构中，前驱和后继结点之间分别存在着_一对一、_一对多__和__多对多______的联系。
- 使用顺序存储方式保存的普通队列存在___假上溢_______的问题，所以在实际应用时多用首尾相连的___循环链表_______。
3．设有一个顺序栈S，元素a1, a2, a3, a4, a5, a6依次进栈，如果6个元素的出栈顺序为a2, a3, a4, a6, a5, a1，则顺序栈的容量至少应为__3________ - 循环队列的最大存储空间为MaxSize=6，采用少用一个元素空间以有效地判断栈空或栈满，若队头指针front=4，当队尾指针rear= __3___时队满，队列中共有____5____个元素。
5、一个算法应具有有穷性、确定性、可行性、输入和___输出。
四、应用题（每题10 分，共20分）
1、请给出下面程序的输出结果。(Stack为栈，Queue为队列）
void unknown ( Queue Q ) {
Stack S;
int i=0;
for (i=1;i<11;i++)
Q. EnQueue (i) ;
while (!Q.IsEmpty ( ) )
{ i=Q.DeQueue () ; S.Push ( i ); }
while (!S.IsEmpty ( ) )
{ S.Pop (); System.out.print(i+" "); }
}
10 9 8 7 6 5 4 3 2 1
该题有地方不严谨，按题意应该为i=Q.DeQueue ()；每次出队列返回出队元素的值并赋值给i，然后再将i进栈，然后出栈输出也应该是i=S.Pop()。 则结果应该是10 9 8 7 6 5 4 3 2 1。如果出队列和出栈i都未赋值，则结果应该是 11 11 11 11 11 11 11 11 11 11。因循环执行完成i的值为11，进队列进了10个11，出队列自然也是10个11
2.请补充下面的算法：
// 从链表中删除所有值比min小及比max大的元素
void unknown3(LinkNode head, int min, int max){
LinkNode q=head, p=head.next;
while (p!=NULL) {
if (__p.data >= min && p.data <= max (1))
{q=p; ___(2)p = p.next___}
else {
__q.next = p.next____ (3) ______;
p= q.next ;
}
}
}
本题解析：注意要求是删除所有值比min小及比max大的元素，当p.data >= min && p.data <= max，则是在最小值和最大值之间的时候（可以等于最小值和最大值），则q=p;p=p.next;将p指向下一个结点。else其它情况，则是比min小或是比max大时，则删除p结点。注意q为p的前驱节点，所以应该是q.next＝p.next;p=q.next等于删除了p结点，并且让p指向了下一结点。
五、常用算法题（共20分）
１.链队列的数据结构形式如下，请实现链队列的入队和出队操作函数。front、rear分别是链队列的队头、队尾结点(10分)
public class QNode { // 结点结构
public int data;
public QNode next;
public QNode(int data, QNode next) {
this.data = data;
this.next = next;
}
}
public class LinkQueue { // 队列结构
public QNode front;
public QNode rear;
public boolean deQueue() {
if (front == null) {
System.out.println("队列为空,无法出队！！");
return false;
}
QNode p = front; // p指向队头结点
front = p.next; // front指向p的后继
if (p == rear) // 如被删结点也是队尾结点
rear = null; // rear置空
return true; // 返回出队成功标志;
}
public void enQueue(int e) {
QNode p = new QNode(e, null);
if (front == null) {
front = p;
rear = p;
} else {
rear.next = p;
rear = p;
}
}
}
２、ListNode包含next、data公有成员，可直接通过p.next读取下一结点，p.data读取数据，请编写一个函数算法，实现从一个非递减有序链表中删除所有值相同的多余元素.该有序链表的头结点为la，（算法提示，定义两个节点p和q，初始q指向头结点，p指向第一个结点，q为p的前驱，当p结点不为空，则判断p结点的数据是否与q相同，如果相同，则删除p结点）(10分)
public static void deleteSameNode(ListNode la) {
ListNode p, q;
if (la == null)
return;
q = la;
p = la.next;
while (p != null) {
if (p.data > q.data) {
q = p;
p = p.next;
} else {
q.next = p.next;
p = q.next;
}
}
}
