栈和队列

栈和队列

一、单项选择题（共59题）

1. 假定一个链式队列的队首和队尾指针分别用front和rear表示，每个结点的结构为：

，当出列时所进行的指针操作为（）

A. front = front->next;

B. rear = rear->next;

C. front->next = rear; rear = rear->next;

D. front = front->next; front->next = rear;

答案：A

2. 向一个栈顶指针为HS的链栈中插入一个s所指结点时，则执行（）。

A. HS->next = s;

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

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

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

答案：C

3. 假定一个带头结点的循环链式队列的队首和队尾指针分别用front和rear表示，则判断队空的条件为（）。

A. front == rear ＞next

B. rear == NULL

C. front == NULL

D. front == rear

答案：D

4. 若让元素1, 2, 3, 4依次进栈，则出栈次序不可能出现（）的情况。

A. 3, 2, 1, 4

B. 2, 1, 4, 3

C. 4, 3, 2, 1

D. 1, 4, 2, 3

答案：D

5. 假定一个顺序循环队列存储于数组a[N]中，其队首和队尾指针分别用f和r表示，则判断队满的条件为（）。

A. (r - 1) % N == f

B. (r + l) % N == f

C. (f - 1) % N == r

D. (f + l) % N == r

答案：B

6. 假定利用数组a[N]循环顺序存储一个队列，用f和r分别表示队首和队尾指针，并已知

队未空，当出列并返回队首元素时所执行的操作为（）

A. return a[++r % N];

B. return a[--r % N];

C. return a[++f % N];

D. return a[f++ % N];

答案：C

7. 假定利用数组a[N]顺序存储一个栈，用top表示栈顶指针，用top==N+l表示栈空，该数组所能存储的栈的最大长度为N，则表示栈满的条件为（）

A. top == 1

B. top == 1

C. top == 0

D. top > 1

答案：A

8. 假定一个链式栈的栈顶指针用top表示，该链式栈为空的条件为（）

A. top != NULL;

B. top == top->next;

C. top == NULL;

D. top != top->next;

答案：C

9. 判定一个循环队列Q(最多元素为M)为满队列的条件是（）。

A. (Q->rear + 1) % M == Q->front

B. Q->rear - Q->front - 1 == M

C. Q->front == Q->rear

D. Q->front == Q->rear + 1

答案：A

10. 栈和队列的共同特点是（）。

A. 都是先进先出

B. 都是先进后出

C. 只允许在端点处插入和删除元素

D. 没有共同点

答案：C

11. 用不带头结点的单链表存储队列时，其队头指针指向队头结点，其队尾指针指向队尾结点，则在进行删除操作时（）。

A. 仅修改队头指针

B. 仅修改队尾指针

C. 队头、队尾指针都要修改

D. 队头、队尾指针都可能要修改

答案：A

12. 在一个长度为N的数组空间中，循环顺序存储着一个队列，该队列的队首和队尾指针分别用front和rear表示，则该队列中的元素个数为（）

A. （rear - front) % N

B. (rear - front + N) % N

C. (rear + N) % N

D. (front + N) % N

答案：B

13. 如果进栈序列为e1,e2,e3,e4，则可能的出栈序列是（）。

A. e3，e1，e4，e2

B. e2，e4，e3，e1

C. e3，e4，e1，e2

D. 以上均有可能

答案：D

14. 栈的插入和删除操作在（）进行。

A. 栈顶

B. 栈底

C. 任意位置

D. 指定位置

答案：A

15. 假定一个链式队列的队首和队尾指针分别为front和rear，则判断队空的条件为（）

A. front == rear

B. front != NULL

C. rear != NULL

D. front == NULL

答案：D

16. 假定一个带头结点的循环链式队列的队首和队尾指针分别用front和rear表示，每个结点包含值域data和指针域next，则使P所指结点入列所执行的操作为（）

A. p->next = NULL; rear = rear->next = p;

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

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

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

答案：B

17. 在一个顺序循环队列中，队首指针指向队首元素的（）位置。

A. 前一个

B. 后一个

C. 当前

D. 最后

答案：A

18. 对于循环队列，下列叙述中正确的是（）。

A. 队首指针是固定不变的

B. 队首指针一定大于队尾指针

C. 队首指针一定小于队尾指针

D. 队首指针可以大于队尾指针，也可以小于队尾指针

答案：D

19. 将递归算法转换成对应的非递归算法时，通常需要使用（）。

A. 栈

B. 队列

C. 链表

D. 树

答案：A

20. 假定利用数组a[N]顺序存储一个栈，用top表示栈顶指针，top == -1表示栈空，并已知栈未满，当元素x进栈时所执行的操作为（）

A. a[--top] = x;

B. a[top--] = x;

C. a[++top] = x;

D. a[top++] = x;

答案：C

21. 假定利用数组a[N]顺序存储一个栈，用top表示栈顶指针，top == -1表示栈空，并已知栈未空，当退栈并返回栈顶元素时所执行的操作为（）

A. return a[--top];

B. return a[top--];

C. return a[++top];

D. return a[top++];

答案：B

22. 假定一个链式栈的栈顶指针用top表示，每个结点的结构为，退栈时所执行的指针操作为（）

A. top->next = top;

B. top = top->data;

C. top = top->next;

D. top->next = top->next->next;

答案：C

23. 栈和队列都是（）。

A. 顺序存储的线性结构

B. 链式存储的非线性结构

C. 限制存取点的线性结构

D. 限制存取点的非线性结构

答案：C

24. 设计一个判别表达式中左右括号是否配对出现的算法，采用（）数据结构最佳。

A. 线性表的顺序存储结构

B. 队列

C. 栈

D. 线性表的链式存储结构

答案：C

25. 假定一个顺序循环队列的队首和队尾指针分别用f和r表示，则判断队空的条件为（）

A. f + 1 == r

B. r + 1 == f

C. f == 0

D. f == r

答案：D

26. 从一个顺序循环队列中删除元素时，首先需要（）

A. 前移队首指针

B. 后移队首指针

C. 取出队首指针所指位置上的元素

D. 取出队尾指针所指位置上的元素

答案：B

27. 假定利用数组a[N]循环顺序存储一个队列，用f和r分别表示队首和队尾指针，并已知队列未满，当元素x入列时所执行的操作为（）

A. a[++r % N] = x;

B. a[r++ % N] = x;

C. a[--r % N] = x;

D. a[r-- % N] = x;

答案：A

28. 若已知一个栈的入栈队列是1，2，3，…，n，若输出序列的第一个元素是n，则输出的第i个元素是（）(1

A. i

B. n - i

C. n - i + 1

D. 不确定

答案：C

29. 用链接方式存储的队列，在进行删除运算时（）.

A. 仅修改头指针

B. 仅修改尾指针

C. 头尾指针都要修改

D. 头尾指针可能都要修改

答案：D

30. 如果以链表作为栈的存储结果，则出栈操作时（）。

A. 必须判别栈是否为空

B. 对栈不作任何判别

C. 必须判别栈是否为满

D. 判别栈元素的类型

答案：A

31. 当利用大小为N的数组循环顺序存储一个队列时，该队列的最大长度为（）

A. N - 2

B. N - 1

C. N

D. N+1

答案：B

32. 当利用大小为N的数组顺序存储一个栈时，假定用top==N表示栈空，则向这个栈插入一个元素时，首先应执行（）语句修改top指针。

A. top++;

B. top--;

C. top = 0;

D. top = N - 1;

答案：B

33. 现有a、b、c、d 4个元素相继进入堆栈，则下面不可能得到的出栈序列为（）。

A. abcd

B. bdac

C. cbda

D. dcba

答案：B

34. 在一个链队中，假设f和r分别为队首和队尾指针，则删除一个结点的运算是（）。

A. r = f->next

B. r = r->next

C. f = f->next

D. f = r->next

答案：C

35. 判定一个顺序栈S(最多元素为M)为空的条件是（）。

A. S->top != -1

B. S->top == -1

C. S->top != M - 1

D. S->top == M - 1

答案：B

36. 用单链表表示的链式队列的队头在链表的（）位置。

A. 链头

B. 链尾

C. 链中

D. 任意

答案：A

37. 若用单链表表示队列，则应该选用（）。

A. 带尾指针的非循环链表

B. 带尾指针的循环链表

C. 带头指针的非循环链表

D. 带头指针的循环链表

答案：B

38. 在解决计算机主机与打印机之间速度不匹配问题时，通常设置一个打印数据缓冲区，主机将要输出的数据依次写入该缓冲区，而打印机则从该缓冲区中取出数据打印，先放入打印缓冲区的数据先被打印。该缓冲区应该是一个（）结构。

A. 堆栈

B. 队列

C. 数组

D. 线性表

答案：B

39. 若用一个大小为6的数组来实现循环队列，且当前rear和front的值分别为0和3。当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为（）。A. 1和5 B. 2和4 C. 4和2 D. 5和1

答案：B

40. 设栈的输入序列为1,2，…,10，输出序列为a1,a2,…,a10，若a5=10，则a7为（）。

A. 4

B. 8

C.不确定

D.7

答案：C

41. 设栈的输入序列是1,2,3,4，则（）不可能是其出栈序列。

A． 1243 B. 2134 C. 1432 D. 4312

答案：D

42. 若已知一个队列的入队序列是1,2,3,…,n，其输出序列为P1,P2,P3,…,P n，若P1=1，则P i为（）。

A. i

B. n - i

C. n - i + 1

D.不确定

答案：A

43. 对于一个栈，给出输入项A,B,C。如果输入项序列由A,B,C所组成，则不可能产生的输出序列是（）。

A. CAB

B. CBA

C. ABC

D. ACB

答案：A

44. 以下哪一个不是队列的基本运算（）。

A. 从队尾插入一个新元素

B. 从队列中删除第i个元素

C. 判断一个队列是否为空

D. 读取队头元素的值

答案：C

45. 在具有n个单元的顺序存储的循环队列中，假定front和rear分别为队首指针和队尾指针，则判断队空的条件是（）。

A. front = rear + 1

B. front = rear

C. front + 1 = rear

D. front = 0

答案：B

46. 一个栈的入栈序列是a,b,c,d,e，则栈不可能的输出序列是（）。

A. edcba

B. decba

C. dceab

D. abcde

答案：C

47. 栈结构通常采用的两种存储结构是（）。

A. 顺序存储结构和链表存储结构

B. 散列方式和索引方式

C. 链表存储结构和数组

D. 线性存储结构和非线性存储结构

答案：A

48. 判断一个顺序栈ST（最多元素为mo）为空的条件是（）。

A. ST->top <> 0

B. ST->top == 0

C. st->top <> mo

D. st->top == mo 答案：B

49. 不带头结点的单链表head为空表的判定条件是（）。

A. head == NILL

B. head->next == NULL

C. head->next == head

D. head != NULL

答案：A

50. 在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在p和q之间插入s 结点，则应执行（）。

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

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

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

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

答案：C

51.假设双向链表结点的类型如下：

struct Linknode{

int data;

Linknode *lLink; /*前驱结点指针*/

Linknode *rLink; /*后继结点指针*/

}

下面给出的算法是要把一个q所指新结点，作为非空双向链表中的p所指的结点前驱结点插入到该双向链表中，能正确完成要求的算法段是（）。

A．q->rLink = p; q->lLink = p->lLink; p->lLink = q; p->lLink->rLink = q;

B. p->lLink = q; q->rLink = p; p->lLink->rLink = q; q->lLink = p->lLink;

C. q->lLink = p->lLink; q->rLink = p; p->lLink->rLink = q; p->lLink = q;

D. 以上均不对

答案：C

52. 栈中元素的进出原则是（）

A. 先进先出

B. 后进先出

C. 栈空则进

D. 栈满则出

答案：B

53. 若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n-4，则pi为（）

A. i

B. n - i

C. n - i + 1

D. 不确定

答案：D

54. 判定一个栈ST（最多元素为m0）为空的条件是（）

A. ST->top <> 0

B. ST->top == 0

C. ST->top <> m0

D. ST->top == m0

答案：B

55. 判定一个队列QU（最多元素为m0）为满队列的条件是（）

A. QU->rear - QU->front == m0

B. QU->rear - QU->front - 1 == m0

C. QU->front == QU->rear

D. QU->front == QU->rear + 1

答案：D

56．数组Ｑ[n]用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素的公式为（）

A. r - f

B. (n + f - r) % n

C. n + r - f

D. (n + r - f) % n

答案：D

57. 设有4个数据元素a1、a2、a3和a4，对他们分别进行栈操作或队操作。在进栈或进队操作时，按a1、a2、a3、a4次序每次进入一个元素。假设栈或队的初始状态都是空。现要进行的栈操作是进栈两次，出栈一次，再进栈两次，出栈一次;这时，第一次出栈得到的元素是( (1) )，第二次出栈得到的元素是( (2) );类似地，考虑对这四个数据元素进行的队操作是进队两次，出队一次，再进队两次，出队一次;这时，第一次出队得到的元素是( (3) )，第二次出队得到的元素是( (4) )。经操作后，最后在栈中或队中的元素还有( (5) )个。

(1)～(4)：

A. a1

B. a2

C. a3

D. a4

(5)：

A. 1

B. 2

C. 3

D. 0

答案：B D A B B

58. 栈是一种线性表，它的特点是( (1) )。设用一维数组A[1,…,n]来表示一个栈，A[n]为栈底，用整型变量T指示当前栈顶位置，A[T]为栈顶元素。往栈中推入（PUSH）一个新元素时，变量T的值( (2) );从栈中弹出（POP）一个元素时，变量T的值( (3) )。设栈空时，有输入序列a，b，c，经过PUSH，POP，PUSH，PUSH，POP操作后，从栈中弹出的元素的序列是( (4) )。

(1)：

A. 先进先出

B. 后进先出

C. 进优于出

D. 出优于进

(2)、(3)：

A. 加1

B. 减1

C. 不变

D. 清0

(4)：

A. a,b

B. b,c

C. c,a

D. b,a

E. c,b

F. a,c

答：B B A F

59. 在做进栈运算时，应先判别栈是否( (1) );在做退栈运算时，应先判别栈是否( (2) )。当栈中元素为n个，做进栈运算时发生上溢，则说明该栈的最大容量为( (3) )。为了增加内存空间的利用率和减少溢出的可能性，由两个栈共享一片连续的内存空间时，应将两栈的( (4) )分别设在这片内存空间的两端，这样，只有当( (5) )时，才产生上溢。

(1)(2)：

A. 空

B. 满

C. 上溢

D. 下溢

(3)：

A. n - 1

B. n

C. n + 1

D. n / 2

(4)：

A. 长度

B. 深度

C. 栈顶

D. 栈底

(5)：

A. 两个栈的栈顶同时到达栈空间的中心点

B. 其中一个栈的栈顶到达栈空间的中心点

C. 两个栈的栈顶在达栈空间的某一位置相遇

D. 两个栈均不空，且一个栈的栈顶到达另一个栈的栈底

答：B A B D C

二、填空题（共16题）

1. 假定front和rear分别为一个链队列的队首和队尾指针，则该链队列中只有一个结点的条件为（）。

答案：front = rear && front != NULL 或者 front == rear && rear != NULL

2. 在一个链栈中，若栈顶指针等于NULL则为（）;在一个链队列中，若队首指针与队尾指针的值相同，则表示该队列为（）或该队列（）。

答案：空栈; 空; 只含有一个结点

3. 一个顺序循环队列存于a[M]中，假定队首和队尾指针分别为front和rear，则求出队首和队尾指针的下一个位置的计算公式分别为（）和（）。

答案：(front + 1) % M; (r + 1) % M

4. （）是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。

答案：队列

5. 队列的插入操作在（）进行，删除操作在（）进行。

答案：队尾; 队首

6. 数据结构分为线性结构和非线性结构，带链的队列属于（）。

答案：线性结构

7. 栈是一种特殊的线性表，允许插入和删除运算的一端称为（）;不允许插入和删除运算的一端称为（）。

答案：栈顶; 栈底

8. 在一个循环队列中，若约定队首指针指向队首元素的前一个位置，则从循环队列中删除一个元素时，其操作是先（），后（）。

答案：移动队首指针; 删除元素

9. 表达式求值是（）应用的一个典型例子。

答案：栈

10. 一个顺序栈存储于一维数组a[M]中，栈顶指针用top表示，当栈顶指针等于（）时为空栈;栈顶指针等于（）时为满栈。

答案：-1; M - 1

11. 设元素a，b，c，d依次进栈，若要在输出端得到序列cbda，则应进行的操作序列为Push(s, a)，Push(s, b)，Push(s, c)，（），（），（），Pop(s)，Pop(s)。

答案：Pop(s); Pop(s); Push(s,d)

12. 设元素1, 2, 3, 4, 5依次进栈，若要在输出端得到序列34251，则应进行的操作序列

为Push(s, 1)，Push(s, 2)，（），Pop(s)，Push(s, 4)，Pop(s)，（），（），Pop(s)，Pop(s)。

答案：Push(s, 3); Pop(s); Push(s, 5)

13. 将递归算法转换成非递归算法时，通常需要使用（）。

答案：栈

14. 假定一个链栈的栈顶指针为top，每个结点包含值域data和指针域next，当进行出栈运算时（假定栈非空），需要把栈顶指针top修改为（）的值。

答案：top->next

15. 栈又称为（）表，队列又称为（）表。

答案：先进后出; 先进先出

16. 循环队列的引入，目的是为了克服（）。

答案：上溢

三、简答题（共10题）

1. 设将整数1, 2, 3, 4依次进栈，但只要出栈时栈非空，则可将出栈操作按任何次序压入其中，请回答下述问题：

(1) 若入、出栈次序为Push(1)，Pop()，Push(2)，Push(3)，Pop()，Pop()，Push(4)，Pop()，则出栈的数字序列如何？

(2)能否得到出栈序列1423和1432，并说明为什么不能得到或者如何得到。

(3)请分析1, 2, 3, 4的各种排列中，哪些序列是可以通过相应的入、出栈操作得到的。答案：

(1) 1324。

(2) 能得到1432，不能得到1423。因为同时压入2, 3，在弹出时根据堆栈的运算规则只能弹出3, 2。

(3) 在1, 2, 3, 4的各种排列中，根据堆栈的运算规则（先进后出），可能出现的次序是：1234，1324，1432，2143，2134，3214，4321。

2. 有5个元素，其入栈次序为a, b, c, d, e，在各种可能的出栈次序中，以元素c第一个、d第二个出栈的次序有哪几个？

答案：依据栈“后进先出”的操作原则，入栈次序为A. B. C. D. e，出栈是c和d先出，

则第一种栈操作的可能情况为：

a入栈，b入栈，c入栈，c出栈，d入栈，d出栈，e入栈，e出栈，b出栈，a出栈，出栈序列为cdeba。

第二种栈操作的可能情况为：

a入栈，b入栈，c入栈，c出栈，d入栈，d出栈，b出栈，e入栈，e出栈，a出栈，出栈序列为cdbea。

第三种栈操作的可能情况为：

a入栈，b入栈，c入栈，c出栈，d入栈，d出栈，b出栈，a出栈，e入栈，e出栈，出栈序列为cdbae。

3. 有6个元素A，B，C，D，E，F依次入栈，允许任何时候出栈，能否得到下列的各个出栈序列，若能，给出出栈操作的过程，若不能，简述其理由。

(1) CDBEFA (2) ABEDFC (3) DCEABF (4)BAEFCD

答案：第(1)个序列可以得到，操作过程为:Push(S，A)，Push(S，B)，Push(S，C)，Pop(S)，Push(S，D)，Pop(S)，Pop(S)，Push(S，E)，Pop(S)，Push(S，F)，Pop(S)，Pop(S)。

第(2)个序列可以得到，操作过程为：Push (S，A)，Pop(S)，Push(S，B)，Pop(S)，Push （S，C)，Push(S，D)，Push(S，E)，Pop(S)，Pop(S)，Push(S，F)，Pop（S)，Pop(S)。第(3)个序列不可以得到，因为按照栈的后进先出或者称先进后出的原则，当A，B，C，D 相继入栈，再进行两次出栈时，A和B仍在栈中，此后只能B在A前面出栈，而在此序列

中出现了A先于B出栈的情况，所以说此序列是错误的。

第(4)个序列不可以得到，因为在某一时刻，C和D同在栈中，并且D是栈顶，此后只能D 先于C出栈，而在此序列中出现了C先于D出栈的情况，所以是错误的。

4. 铁路进行列车调度时, 常把站台设计成栈式结构的站台，如右图所示。试问：

(1) 设有编号为1,2,3,4,5,6的六辆列车, 顺序开入栈式结构的站台, 则可能的出栈序列有多少种?

(2) 若进站的六辆列车顺序如上所述, 那么是否能够得到435612, 325641, 154623和135426的出站序列, 如果不能, 说明为什么不能; 如果能, 说明如何得到(即写出"进栈"或"出栈"的序列)。

()132

)16/(16

12

=*+

C

【解答】 (1) 可能的不同出栈序列有

种。

(2) 不能得到435612和154623这样的出栈序列。因为若在4, 3, 5, 6之后再将1, 2

出栈，则1, 2必须一直在栈中，此时1先进栈，2后进栈，2应压在1上面，不可能1先于2出栈。154623也是这种情况。出栈序列325641和135426可以得到。

3

5

6

2 2

4 4 4 4

1

1

1 1

1

1

1

1

3 32 32 325 325 3256 3256

4 325641

5

3 4 4

1

2

2

2

2

6

1 1 13 135 **** ****

2 13542 135426

5. 试证明：若借助栈可由输入序列1, 2, 3, …, n 得到一个输出序列p 1, p 2, p 3, …, p n (它是输入序列的某一种排列)，则在输出序列中不可能出现以下情况，即存在i < j < k ，使得p j < p k < p i 。(提示：用反证法) 【解答】

因为借助栈由输入序列1, 2, 3, …, n ，可得到输出序列p 1, p 2, p 3, …, p n ，如果存

在下标i, j, k ，满足i < j < k ，那么在输出序列中，可能出现如下5种情况： ① i 进栈，i 出栈，j 进栈，j 出栈，k 进栈，k 出栈。此时具有最小值的排在最前面p i 位置，具有中间值的排在其后p j 位置，具有最大值的排在p k 位置，有p i < p j < p k , 不可能出现p j < p k < p i 的情形；

② i 进栈，i 出栈，j 进栈，k 进栈，k 出栈，j 出栈。此时具有最小值的排在最前面p i 位

置，具有最大值的排在p j位置，具有中间值的排在最后p k位置，有p i < p k < p j , 不可能出现p j < p k < p i的情形；

③ i进栈，j进栈，j出栈，i出栈，k进栈，k出栈。此时具有中间值的排在最前面p i位置，具有最小值的排在其后p j位置，有p j < p i < p k, 不可能出现p j < p k < p i的情形；

④ i进栈，j进栈，j出栈，k进栈，k出栈，i出栈。此时具有中间值的排在最前面p i 位置，具有最大值的排在其后p j位置，具有最小值的排在p k位置，有p k < p i < p j, 也不可能出现p j < p k < p i的情形；

⑤ i进栈，j进栈，k进栈，k出栈，j出栈，i出栈。此时具有最大值的排在最前面p i 位置，具有中间值的排在其后p j位置，具有最小值的排在p k位置，有p k < p j < p i, 也不可能出现p j < p k < p i的情形；

6. 根据教案中给出的优先级，回答以下问题：

(1) 在表达式求值的过程中，如果表达式e含有n个运算符和分界符，问操作数栈(NS)中最多可存入多少个元素？

(2) 如果表达式e含有n个运算符，且括号嵌套的最大深度为6层，问栈中最多可存入多少个元素？

【解答】

(1) 如果表达式e含有n个运算符和分界符，则可能的运算对象有n+1个。因此在利用后缀表达式求值时所用到的运算对象栈中最多可存入n+1个元素。

(2) 同上。

7. 表达式的中缀表示为a * x - b / x^2，试利用栈将它改为后缀表示ax * bx2^/ -。写出转换过程中栈的变化。(^表示乘方运算)

【解答】

若设当前扫描到的运算符ch的优先级为icp(ch)，该运算符进栈后的优先级为isp(ch)，则可规定各个算术运算符的优先级如下表所示。

运算符;( ^ *,/, % +, -)

isp 0 1 7 5 3 8

icp 0 8 6 4 2 1

isp也叫做栈内(in stack priority)优先数，icp也叫做栈外(in coming priority)优先数。当刚扫描到的运算符ch的icp(ch)大于isp(stack)时，则ch进栈；当刚扫描到的运算符ch 的icp(ch)小于isp(stack)时，则位于栈顶的运算符退栈并输出。从表中可知，icp(“(”)最高，但当“(”进栈后，isp(“(”)变得极低。其它运算符进入栈中后优先数都升1，这样可体现在中缀表达式中相同优先级的运算符自左向右计算的要求。运算符优先数相等的情况只出现在括号配对“)”或栈底的“;”号与输入流最后的“;”号配对时。前者将连续退出位于栈顶的运算符，直到遇到“(”为止。然后将“(”退栈以对消括号，后者将结束算法。

步序

扫

描

项

项类型动作栈的

变化

输出

0 ? ';' 进栈, 读下一符号;

1 a 操作数?直接输出, 读下一符号; A

2 * 操作符? isp ( ' ; ' ) < icp ( ' * ' ), 进栈, 读下一符号; * A

3 x 操作数?直接输出, 读下一符号; * a x

4 - 操作符? isp ( ' * ' ) > icp ( ' - ' ), 退栈输出; a x *

? isp ( ' ; ' ) < icp ( ' - ' ), 进栈, 读下一符号;- a x *

5 b 操作数?直接输出, 读下一符号;- a x * b

6 / 操作符? isp ( ' - ' ) < icp ( '/' ), 进栈, 读下一符号;-/ a x * b

7 x 操作数?直接输出, 读下一符号;-/ a x * b x

8 ^ 操作符? isp ( ' / ' ) < icp ( '^' ), 进栈, 读下一符号;-/^ a x * b x

9 2 操作数?直接输出, 读下一符号;-/^ a x * b x 2

10 ; 操作符? isp ( '↑' ) > icp ( ' ;' ), 退栈输出;-/ a x * b x 2^

? isp ( ' / ' ) > icp ( ' ;' ), 退栈输出; - a x * b x 2^/

? isp ( ' - ' ) > icp ( ' ;' ), 退栈输出; a x * b x 2^/ -

?结束

8. 设循环队列的容量为70（序号从1到70），经过一系列入队和退队运算后，有：

（1）front=15，rear=46；

（2）front=45，rear=10

问在上述两种情况下，循环队列中各有多少个元素？

【解答】

(1)队列中元素的个数为(MAXSIZE+rear-front) %MAXSIZE = (70+46-15)%70=31

(2)队列中元素的个数为(MAXSIZE+rear-front) %MAXSIZE = (70+10-45)%70=35 9. 写出下列程序段的输出结果（栈的元素类型SElem Type为char）。

void main()

{

Stack S;

char x = 'c', y = 'k';

InitStack(S);

Push(S, x); Push(S, 'a'); Push(S, y);

Pop(S, x); Push(S, 't'); Push(S, x);

Pop(S, x); Push(S, 's');

while(!StackEmpty(S))

{

Pop(S,y);

printf("%c", y);

};

printf("%c", x);

}

答案：stack

10. 写出下列程序段的输出结果。

void main( )

{

Queue Q;

Init Queue (Q);

char x = 'e', y = 'c';

EnQueue(Q, 'h'); EnQueue(Q, 'r'); EnQueue(Q, 'y');

DeQueue(Q, x); EnQueue(Q, x);

DeQueue(Q, x); EnQueue(Q, 'a');

while(!QueueEmpty(Q))

{

DeQueue(Q, y);

printf("%c", y);

};

printf("%c", x);

}

答案：ahyr

四、应用题（共8题）

1. 编写算法，利用找的基本运算将栈中的内容逆转。

答案：可以利用两个临时栈s1和s2。根据栈的特点，先将s栈中的内容移到s1栈中，再将s1栈中的内容移到s2栈中，最后将s2栈中的内容移到s栈中，即可实现。算法源代码如下：

void reverse(st *s)

{

st *s1, *s2; // s，s1，s2均为栈类型

int x; // 栈中元素的类型，用于存储从栈中取出元素的临时变量

initstack(s1); // 栈的初始化

initstack(s2);

while(!stackempty(s)) // 如果栈不空，将s栈中的内容移到s1栈中

{

pop(s, x); // 取栈顶元素放入变量x中

push(s1, x); // 将变量x入栈

}

while(!stackempty(s1)) // 如果栈不空，将s1栈中的内容移到s2栈中

{

pop(s1, x);

push(s2, x);

}

while(!stackempty(s2)) // 如果栈不空，将s2栈中的内容移到s栈中

{

pop(s2, x);

push(s, x);

}

}

2. 假定在一个链式队列中只设置队尾指针，不设置队首指针，并且让队尾结点的指针域指向队首结点（称此为循环链队），试分别写出在循环链队上进行插入和删除操作的算法。答案：插入操作的算法如下：

void EnQueue(node * &rear, datatype &x)

// 新元素x的值插入到循环链队中

{

node *newptr = new node;

// 得到一个由newptr指针所指向的新结点

if (newptr == NULL)

{

printf("Memory allocation failare!");

exit(1);

}

newptr->data = x; // 把x的值赋给新结点的值域

if(rear == NULL) // 若链队为空，则新结点既是队首结点又是队尾结点

rear = newptr->next = newptr;

else

{

newptr-next= rear->next; // 使新结点的指针域指向队首结点

rear->next= newptr; // 使队尾结点的指针域指向新结点

rear= newptr; // 使新结点成为新的队尾结点

}

}

删除操作的算法如下：

datatype OutQueue(node*＆rear) ／*从循环链队中删除队首元素*／ {

if ( rear == NULL) {

printf("Linked queue is empty!"); exit(1); }

node*p = rear -next; ／*使p 指向队首结点*／ if(p == rear) rear= NULL; // 若链队中只有一个结点，则删除后队尾指针为空

else

rear ->next = p->next;// 使队尾结点的指针域指向队首的后继结点 datatype temp = p->data; // 暂存队首元素 delete p; // 回收原队首结点 return temp;

// 返回被删除的队首元素

}

3. 将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m 时该栈为空。两个栈均从两端向中间增长。当向第0号栈插入一个新元素时，使top[0]增1得到新的栈顶位置，当向第1号栈插入一个新元素时，使top[1]减1得到新的栈顶位置。当top[0]+1 == top[1]时或top[0] == top[1]-1时，栈空间满，此时不能再向任一栈加入新的元素。试定义这种双栈(Double Stack)结构的类定义，并实现判栈空、判栈满、插入、删除算法。 【解答】

双栈的类型定义如下：

typedef struct

bot[0] top[0] top[1]

bot[1]