习题集

1求整数的二分序列算法如下，该算法的渐近时间复杂度函数是（）。

void binary ( int n ) { while ( n ) {

printf ( \ n = n / 2; } }

A、O( log(n) ) B、O( n*log2(n) ) C、O ( n^2 ) D、O ( n ) 正确答案： A

2算法分析是为了分析算法的效率以求改进，那么算法分析的两个主要方面是（）。

A、正确性和简明性 B、空间复杂度和时间复杂度 C、可读性和文档性

D、数据复杂性和程序复杂性 正确答案： B

3下面说法错误的是（） (1）算法原地工作的含义是指不需要任何额外的辅助空间（2）在相同的规模n下，复杂度O(n)的算法在时间上总是优于复杂度O(2*n)的算法（3）最坏时间复杂度是指在最坏情况下，估算出来的算法执行时间的一个上界（4）同一个算法，实现语言的级别越高，执行效率就越低

A、(1) B、(1),(2) C、(1),(4) D、(3) 正确答案： C

4在下面程序段中，x 赋值语句的频度是（） for (i=1;i<=n;i++) for (j=1;j<=n;j++) x=x+1;

A、O(2*n)

B、O(n) C、O(n^2) D、O(log2(n)) 正确答案： C

5下面有若干算法（关于问题规模 n）的执行时间频度函数和若干渐近时间复杂度函数，请问以下哪个对应关系是正确的。

(1) 100*n^3 (2) 6*n^2 - 12*n + 1 (3) 1024 (4) n + 2*log2(n) (5) n*(n + 1)*(n + 2) / 6 (6) 2^(n+1) + 100 * n

(a) O(1) (b) O( 2^n) (c) O(n) (d) O(n^2) (e) O( log2(n) ) (f) O ( n^3)

A、(1)--(a) (2)--(b) (3)--(c) (4)--(d) (5)--(e) (6)--(f) B、(1)--(f) (2)--(d) (3)--(a) (4)--(c) (5)--(f) (6)--(b) C、(1)--(f) (2)--(e) (3)--(d) (4)--(c) (5)--(b) (6)--(a) D、(1)--(f) (2)--(b) (3)--(c) (4)--(e) (5)--(f) (6)--(b) 正确答案： B

6在存储数据时，通常不仅要存储各数据元素的值，而且还要存储（）。 A、数据的处理方法 B、数据元素的类型 C、数据元素之间的关系 D、数据的存储方法 正确答案： C

7数据结构在计算机内存中的表示是指（） A、数据的存储结构 B、数据结构 C、数据的逻辑结构 D、数据元素之间的关系 正确答案： A

8算法的计算量的大小称为算法的（）。 A、效率 B、复杂度

C、现实性 D、难度 正确答案： B

9在数据结构中，从逻辑关系上可以把数据结构分成（） A、动态结构和静态结构 B、紧凑结构和非紧凑结构 C、线性结构和非线性结构 D、内部结构和外部结构 正确答案： C

10算法的时间复杂度取决于（）。 A、问题的规模 B、待处理数据的初态 C、A和B

D、执行算法的计算机速度 正确答案： C

11在数据结构中，与所使用的计算机无关的是数据的（）结构。 A、逻辑 B、存储 C、逻缉和存储 D、物理 正确答案： A

12计算机执行下面的语句时，语句 s 的执行次数为（）。 for ( i=1; i=i; j--) s;

A、n*(n+1)/2 B、n*(n-1)/2 C、n^2

D、(n-2)*(n+3)/2 正确答案： D

13下面算法的渐近时间复杂度函数分别是（）。

void combi ( int n ) { int i, j, k; for ( i=1; i<=n; i++) for ( j=i+1; j<=n; j++) for ( k=j+1; k<=n; k++) printf ( \} } A、O(n) B、O(n^2) C、O(n^3) D、O(n*log(n)) 正确答案： C

14循环队列的引入，目的是为了克服_______。 A、假溢出时大量移动数据元素 B、空间不够 C、队列为空 D、队列未分配空间 正确答案： A

15用 I 和 O 分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由 I 和 O 组成的序列，能够完成操作的序列称为合法序列，否则称为非法序列。下面所示的序列中哪些是合法的？

A. IOIIOIOO B. IOOIOIIO C. IIIOIOIO D. IIIOOIOO A、A B B、A D C、C D D、B C 正确答案： B

16有数组 elema[m+1] 作为循环队列的存储空间，front 为队头指示器，rear 为队尾指示器，则出队操作的语句是

A、front=front+1 B、front=（front+1）% m C、rear=(rear+1)%(m+1) D、front=(front+1)%(m+1) 正确答案： D

17栈是操作受限的线性表，其插入和删除操作遵循_______的原则。 A、FIFO B、FILO C、LILO D、以上都对 正确答案： B

18元素 6，5，4，3，2，1 依序进栈，请问下列哪个出栈序列是不合法的 A、5 4 3 6 1 2 B、4 5 3 1 2 6 C、3 4 6 5 2 1 D、2 3 4 1 5 6 正确答案： C

19表达式求值是_______应用的一个典型例子。 A、队列 B、线性表 C、栈 D、顺序表 正确答案： C

20假设用 S 表示入栈操作、X 表示出栈操作。若元素入栈的顺序为 1、2、3、4，为了得到 1、3、4、2 的出栈顺序，相应的 S 和 X操作串是（）。

A、SXSXSXSX B、SXSSXSXX C、SSSSXXXX D、SXXSSSXX 正确答案： B

21用单链表存储的队列，进行删除操作时，应该 A、仅修改头指针 B、仅修改尾指针 C、头、尾指针都要修改 D、头、尾指针可能都要修改 正确答案： D

22栈是操作受限的线性表，其运算遵循( )的原则。 A、先进先出 B、同进同出 C、后进先出 D、先进不出 正确答案： C

23已知链队列的头尾指针分别是f和r，则将值x入队的操作序列是s=(LinkedList)malloc(sizeof(LNode))；s->data=x;____________；r->next=s；r=s；

A、r->next=s->next B、r->next==s; C、s->next=r->next D、s->next=r 正确答案： C

24表达式3* 2^(4+2*2-6*3)-5求值过程中当扫描到6时，对象栈和算符栈为（），其中^为乘幂

A、3,2,4,1,1；(*^(+*- B、3,2,8；(*^- C、3,2,4,2,2；(*^(- D、3,2,8；(*^(- 正确答案： D

25函数调用时，为处理参数及返回地址，要用一种称为（）的数据结构 A、队列 B、多维数组 C、栈 D、线性表

正确答案： C

26设有顺序栈 S，元素 s1, s2, s3, s4, s5, s6 依次进栈，若这 6 个元素出栈顺序是 s2, s3, s4, s6 , s5, s1，则栈的容量至少应该是

A、2 B、3 C、5 D、6 正确答案： B

27一个栈的输入序列是 1、2、3，则不可能的栈输出序列是( )。 A、3 1 2 B、1 2 3 C、3 2 1 D、以上都可能 正确答案： A

28下面的程序段执行完后，变量 i 值应该是： int func ( int x ) { if ( x>0 )

return x * func ( x-1 ); else return 2; } int i;

i = func ( func(1) ); A、2 B、4 C、8 D、无限递归 正确答案： B

29队列是限制插入只能在表的一端，而删除在表的另一端进行的线性表，其特点是_______。

A、先进先出

B、先进后出 C、先进不出 D、后进不出 正确答案： A

30已知循环队列用数组 A [ 0..m-1 ] 存放元素，其头尾指示器分别是 front 和 rear，则队列的元素个数是（）。

A、rear-front+1 B、rear-front+m C、(rear-front+m)%m D、(rear-front+1)%m 正确答案： C

31已知一个栈的进栈序列是 1，2，3，?，n，输出序列是 p1，p2，p3，...，pn，若 p1＝3，则 p2 应该

A、可能是2 B、一定是2 C、可能是1 D、一定是1 正确答案： A 32链栈定义如下： typedef struct Node { int data;

struct Node * next; } StackNode, *LStack;

以下函数实现了(带头结点的)链栈初始化，请问________________处用哪条语句予以填充。

void InitStack ( LStack *S ) { ________________;}

A、S=NULL B、S->next=NULL C、S.next=NULL D、以上都不对

正确答案： B 33有链栈定义如下： typedef struct Node { int data;

struct Node * next; } StackNode, *LStack;

以下函数实现了(带头结点)链栈上的进栈，请问空白处应用哪些语句予以填充。

void Push（LStack *S, int x） { LStack p;

p=(LStack)malloc(sizeof(StackNode)); ________________; p->next=S->next; ________________; }

A、p->data=x S->next=p->next B、S->next=p p->data=x C、p->data=x S=p D、p->data=x S->next=p 正确答案： D

34若栈中已有 n 个元素，在作进栈操作时发生了溢出，则说明该栈的最大容量是

A、n-1 B、n C、n+1 D、n/2 正确答案： B

35若栈采用数组方式存储，现将两个栈共享一个数组 v [0..m-1] 的空间，数组元素 top[i] 代表第 i 个栈( i =1, 2)栈顶，栈 1 的栈底在 v[0]，栈 2 的栈底在 v[m-1]，则栈满的判定条件应该是

A、top[2]-top[1]的绝对值=0 B、top[1]+1=top[2] C、top[1]+top[2]=m D、top[1]=top[2] 正确答案： B

36以下运算实现在(元素为整数的)链队列上的入队操作，请问空白处应用哪些语句予以填充。

void EnQueue ( LinkQueue *q, int x) { LNode *p;

p=(LNode *)malloc(sizeof(LNode)); ________________=x; p->next=NULL;

(q->rear)->next=________________; ________________; }

A、p->data p q->rear=p B、p->data p q->rear=p->next C、p->data p q=p D、p p->data q->rear=p 正确答案： A

37一个栈的输入序列是：1，2，3则不可能的栈输出序列是_______。 A、3 2 1 B、1 2 3 C、2 1 3 D、 3 1 2 正确答案： D

38循环队列的队满条件应该是（提示：队尾指示器始终指向末元素的下一个可用空位）

A、(sq.rear+1) % maxsize ==(sq.front+1) % maxsize B、(sq.front+1) % maxsize ==sq.rear

C、(sq.rear+1) % maxsize ==sq.front D、sq.rear ==sq.front 正确答案： C

39栈和队列的共同点是 A、都是先进先出 B、都是先进后出

C、只允许在端点处插入和删除元素 D、没有共同点 正确答案： C

40循环队列用数组A[0..m-1]存放其元素值，已知其头尾指针分别是front和rear ，则当前队列的元素个数是( )

A、(rear-front)%m B、(rear-front+1)%m C、(front-rear+1)%m D、rear-front 正确答案： B

41队列是限制插入只能在表的一端、删除在表的另一端进行的线性表，其特点是( )。

A、LILO B、LIFO C、FILO D、以上都不对 正确答案： A 42顺序栈定义如下： typedef struct { int data;

int top; //等于实际栈顶元素的下标 int stacksize; int incrementsize; } SqStack;

以下函数实现了退栈操作，请问空白处应用哪些语句予以填充。

int Pop (SqStack *S, int *x) { if ( ________________ ) return 0; *x=________________; S->top = ________________; return 1; }

A、S->top ==0 S->elem[S->top] S->top - 1 B、S->top ==-1 S->elem[S->top] S->top - 1 C、S->top ==-1 S->top - 1 S->elem[S->top] D、S->top ==0 S->top - 1 S->elem[S->top] 正确答案： B

43线性表L=（a1,a2,?,an）用数组实现，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是（）。

A、(n-1)/2 B、n/2 C、(n+1)/2 D、以上都不对 正确答案： A

44以下说法错误的是 ( )

A、对于线性表来说，定位运算LocateElem在顺序表和单链表上的时间复杂度均为O（n）

B、指定位置读取元素操作在顺序表上只需常数时间O（1）便可实现，因此顺序表是一种随机存取结构

C、在链表上实现读表元运算的平均时间复杂度为O（1） D、插入、删除操作在链表上的实现可在O（1）时间内完成 E、插入、删除操作在顺序表上的实现，平均时间复杂度为O（n） 正确答案： C

45对于顺序表，以下说法错误的是（）

A、顺序表是用一维数组实现的线性表，数组的下标可以看成是元素的内存物理地址

B、顺序表的所有存储结点按相应数据元素间的逻辑关系决定的次序依次排列

C、顺序表的特点是:逻辑结构中相邻的结点在存储结构中仍相邻

D、顺序表的特点是:逻辑上相邻的元素，存储在物理位置也相邻的单元中 正确答案： A

46长度为 n 的线性表是具有 n 个（）的有限序列（n>0） A、表元素 B、字符 C、数据元素 D、数据项 E、信息项 正确答案： C

47在循环链表中，将头指针改设为尾指针（rear）后，其头结点和尾结点的存储位置分别是（）

A、rear和rear->next->next B、rear->next 和rear C、rear->next->next和rear D、rear和rear->next 正确答案： B

48对于顺序存储的线性表，指定位序访问元素和增加、删除元素的时间复杂度为（）

A、O(n) O(n) B、O(n) O(1) C、O(1) O(n) D、O(1) O(1) 正确答案： C

49对于顺序表的插入算法而言，若以结点移动为标准操作，则插入算法的在最坏情况下的移动次数为（），时间复杂度是（）；在平均情况下的移动次数为（），时间复杂度是（）。

A、n, O(n), n/2, O(n/2) B、n/2, O(n), n/2, O(n)

C、n, O(n), n, O(n) D、n, O(n), n/2, O(n) 正确答案： D

50以下为顺序表的查找算法，分析算法，请在空白处填上正确的语句 int LocateElem_Sq ( SqList L, ElemType X) //在 L 中查找第一值等于 X 的元素。若找到则返回该元素位序号；否则返回 0

{

________;

while ( ( i <=L.length ) && ( L.elem[i-1] != X) ) i++; if( ________ ) return i; else return 0; } A、i=0, i

B、i=1, i<=L.length C、i=1, i

D、i=0, i<=L.length 正确答案： B

51在带头结点的非空单链表中，头结点的存储位置由( )指示，首元素结点的存储位置由( )指示，除首元素结点外，其它任一元素结点的存储位置由( )指示。

A、头结点指针域、头指针、前驱结点指针域 B、头指针、前驱结点指针域、头结点指针域 C、头指针、头结点指针域、前驱结点指针域 D、以上都不对 正确答案： C

52单链表中，在指针 p 所指向的结点之后插入指针为 s 的新结点，正确的操作是：（）

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

正确答案： B

53静态链表中指针表示的是（） A、内存地址 B、数组下标 C、下一元素地址 D、左、右孩子地址 正确答案： B

54若某线性表中最常用的操作是读取第 i 个元素和找第 i 个元素的前趋，则采用（）存储方式最节省时间

A、顺序表 B、单链表 C、双链表 D、单循环链表 正确答案： A

55对于一个头指针为 head 的带头结点的单链表，判定该链表为空的条件是（）

A、head==NULL B、head→next==NULL C、head→next==head D、head!=NULL 正确答案： B

56下面关于线性表的叙述中，错误的是哪一个？ A、线性表采用顺序存储，必须占用一片连续的存储单元 B、线性表采用顺序存储，便于进行插入和删除操作 C、线性表采用链接存储，不必占用一片连续的存储单元 D、线性表采用链接存储，便于插入和删除操作 正确答案： B

57设单链表的结点结构为 (data, next)，其中 next 为指针域。已知有指针 px 指向单链表中 data=x 的结点，指针 py 指向 data=y 的新结点，若需要将 y 插入到 x 之后，则需要执行以下语句（）

A、px->next=py; py->next=px->next;

}

出队算法：

int DeleteQueue( SeqQueue *Q , QueueElementType *x) { /*删除队头元素，用x返回其值*/

if(Q->front==Q->rear && tag==0) /*队空*/ return(FALSE);

*x=Q->element[Q->front];

Q->front=(Q->front+1)%MAXSIZE; /*重新设置队头指针*/

if(Q->front==Q->rear) tag=0; /*队头元素出队后队列为空，重新设置标志域*/

Return(TUUE); }

111设表达式以字符形式已存入数组E[n]中，‘#’为表达式的结束符，试写出判断表达式中括号（‘（’和‘）’）是否配对的C语言描述算法：EXYX(E); (注：算法中可调用栈操作的基本算法。)

正确答案：

[题目分析]判断表达式中括号是否匹配，可通过栈，简单说是左括号时进栈，右括号时退栈。退栈时，若栈顶元素是左括号，则新读入的右括号与栈顶左括号就可消去。如此下去，输入表达式结束时，栈为空则正确，否则括号不匹配。

int EXYX(char E[],int n)

//E[]是有n字符的字符数组，存放字符串表达式，以‘#’结束。本算法判断表达式中圆括号是否匹配。

{char s[30]; //s是一维数组，容量足够大，用作存放括号的栈。 int top=0; //top用作栈顶指针。

s[top]= ‘#’; //‘#’先入栈，用于和表达式结束符号‘#’匹配。 int i=0; //字符数组E的工作指针。 while(E[i]!= ‘#’) //逐字符处理字符表达式的数组。 switch(E[i])

,case‘(’: s*++top+=‘(’; i++ ; break ; case‘)’: if(s*top+==‘(’,top--; i++; break;}

else{printf(“括号不配对”);exit(0);}

case‘#’: if(s[top]==‘#’){printf(“括号配对\\n”);return (1);} else {printf(“括号不配对\\n”);return (0);} //括号不配对 default : i++; //读入其它字符，不作处理。 }

}//算法结束。

[算法讨论]本题是用栈判断括号匹配的特例：只检查圆括号的配对。一般情况是检查花括号（‘{’，‘}’）、方括号（‘[’，‘]’）和圆括号（‘（’，‘）’）的配对问题。编写算法中如遇左括号（‘{’，‘[’，或‘（’）就压入栈中，如遇右括号（‘}’，‘]’，或‘）’），则与栈顶元素比较，如是与其配对的括号（左花括号，左方括号或左圆括号），则弹出栈顶元素；否则，就结论括号不配对。在读入表达式结束符‘#’时，栈中若应只剩‘#’，表示括号全部配对成功；否则表示括号不匹配。

另外，由于本题只是检查括号是否匹配，故对从表达式中读入的不是括号的那些字符，一律未作处理。再有，假设栈容量足够大，因此入栈时未判断溢出。

112画出对算术表达式A-B*C/D-E↑F求值时操作数栈和运算符栈的变化过程。

正确答案：

113设有两个栈S1,S2都采用顺序栈方式，并且共享一个存储区[O..maxsize-1],为了尽量利用空间，减少溢出的可能，可采用栈顶相向，迎面增长的存储方式。试设计S1,S2有关入栈和出栈的操作算法。

正确答案：

[题目分析]两栈共享向量空间，将两栈栈底设在向量两端，初始时，s1栈顶指针为-1，s2栈顶为maxsize。两栈顶指针相邻时为栈满。两栈顶相向，迎面增长，栈顶指针指向栈顶元素。

#define maxsize 两栈共享顺序存储空间所能达到的最多元素数 #define elemtp int //假设元素类型为整型 typedef struct

{elemtp stack[maxsize]; //栈空间

int top[2]; //top为两个栈顶指针

}stk;

stk s; //s是如上定义的结构类型变量，为全局变量。 (1)入栈操作： int push(int i,int x)

//入栈操作。i为栈号，i=0表示左边的栈s1，i=1表示右边的栈s2，x是入栈元素。入栈成功返回1，否则返回0。

{if(i<0||i>1){printf(“栈号输入不对”);exit(0);} if(s.top[1]-s.top[0]==1) {printf(“栈已满\\n”);return(0);} switch(i)

{case 0: s.stack[++s.top[0]]=x; return(1); break; case 1: s.stack[--s.top[1]]=x; return(1); } }//push （2）退栈操作 elemtp pop(int i)

//退栈算法。i代表栈号，i=0时为s1栈，i=1时为s2栈。退栈成功返回退栈元素，否则返回-1。

{if(i<0 || i>1){printf(“栈号输入错误\\n”)；exit(0);} switch(i)

{case 0: if(s.top[0]==-1) {printf(“栈空\\n”)；return（-1）；} else return(s.stack[s.top[0]--]);

case 1: if(s.top[1]==maxsize {printf(“栈空\\n”); return(-1);} else return(s.stack[s.top[1]++]); } }//算法结束

[算法讨论] 请注意算法中两栈入栈和退栈时的栈顶指针的计算。两栈共享空间示意图略，s1栈是通常意义下的栈，而s2栈入栈操作时，其栈顶指针左移（减1），退栈时，栈顶指针右移（加1）。

114请利用两个栈S1和S2来模拟一个队列。已知栈的三个运算定义如下：PUSH(ST,x):元素x入ST栈；POP(ST,x)：ST栈顶元素出栈，赋给变量x；Sempty(ST)：判ST栈是否为空。那么如何利用栈的运算来实现该队列的三个运算：enqueue:

插入一个元素入队列； dequeue:删除一个元素出队列；queue_empty：判队列为空。（请写明算法的思想及必要的注释）

正确答案：

[题目分析]栈的特点是后进先出，队列的特点是先进先出。所以，用两个栈s1和s2模拟一个队列时，s1作输入栈，逐个元素压栈，以此模拟队列元素的入队。当需要出队时，将栈s1退栈并逐个压入栈s2中，s1中最先入栈的元素，在s2中处于栈顶。s2退栈，相当于队列的出队，实现了先进先出。显然，只有栈s2为空且s1也为空，才算是队列空。

(1) int enqueue(stack s1,elemtp x)

//s1是容量为n的栈，栈中元素类型是elemtp。本算法将x入栈，若入栈成功返回1，否则返回0。

{if(top1==n && !Sempty(s2)) //top1是栈s1的栈顶指针，是全局变量。 {printf(“栈满”);return(0);} //s1满s2非空,这时s1不能再入栈。 if(top1==n && Sempty(s2)) //若s2为空，先将s1退栈,元素再压栈到s2。

{while(!Sempty(s1)) {POP(s1,x);PUSH(s2,x);}

PUSH(s1,x); return(1); //x入栈，实现了队列元素的入队。 }

(2) void dequeue(stack s2,s1)

//s2是输出栈，本算法将s2栈顶元素退栈，实现队列元素的出队。 {if(!Sempty(s2)) //栈s2不空，则直接出队。 {POP(s2,x); printf(“出队元素为”,x); } else //处理s2空栈。

if(Sempty(s1)) {printf(“队列空”);exit(0);}//若输入栈也为空，则判定队空。 else //先将栈s1倒入s2中，再作出队操作。 {while(!Sempty(s1)) {POP(s1,x);PUSH(s2,x);} POP(s2,x); //s2退栈相当队列出队。 printf(“出队元素”，x); }

}//结束算法dequue。 (3) int queue_empty()

//本算法判用栈s1和s2模拟的队列是否为空。 {if(Sempty(s1)&&Sempty(s2)) return(1);//队列空。 else return(0); //队列不空。 }

[算法讨论]算法中假定栈s1和栈s2容量相同。出队从栈s2出，当s2为空时，若s1不空，则将s1倒入s2再出栈。入队在s1，当s1满后，若s2空，则将s1倒入s2，之后再入队。因此队列的容量为两栈容量之和。元素从栈s1倒入s2，必须在s2空的情况下才能进行，即在要求出队操作时，若s2空，则不论s1元素多少（只要不空），就要全部倒入s2中。

115已知Q是一个非空队列，S是一个空栈。仅用队列和栈的ADT函数和少量工作变量，编写一个算法，将队列Q中的所有元素逆置。栈的ADT函数有： makeEmpty(s:stack); 置空栈 push(s:stack;value:datatype); 新元素value进栈 pop(s:stack):datatype; 出栈，返回栈顶值 isEmpty(s:stack):Boolean; 判栈空否队列的 ADT函数有： enqueue(q:queue:value:datatype); 元素value进队

deQueue(q:queue):datatype; 出队列，返回队头值 isEmpty(q:queue):boolean; 判队列空否

正确答案：

[题目分析] 根据队列先进先出和栈后进先出的性质，先将非空队列中的元素出队，并压入初始为空的栈中。这时栈顶元素是队列中最后出队的元素。然后将栈中元素出栈，依次插入到初始为空的队列中。栈中第一个退栈的元素成为队列中第一个元素，最后退栈的元素（出队时第一个元素）成了最后入队的元素，从而实现了原队列的逆置。

void Invert(queue Q)

//Q是一个非空队列，本算法利用空栈S和已给的几个栈和队列的ADT函数，将队列Q中的元素逆置。

{makempty(S); //置空栈

while (!isEmpty(Q)) // 队列Q中元素出队

{value=deQueue(Q); push(S,value); }// 将出队元素压入栈中 while(!isEmpty(S)) //栈中元素退栈

{value=pop(S); enQueue(Q,value); }//将出栈元素入队列 Q }//算法invert 结束

本文来源：https://www.bwwdw.com/article/5mgt.html