队列的基本知识及应用
队列的基本知识及应用
[内容提要]
1．通过本章学习，掌握队列的定义及队列的存储结构
2．掌握队列的基本操作运算：建队、插入、删除、队列空等，用数组、链接方式所建立队列及操作运算
3．掌握循环队列概念及运算
4．能够利用队列解决一些实际问题：广度优先搜索算法
[重点难点]
1．队列、循环队列概念及存储结构
2．队列的基本操作
3．综合运用队列结构解决实际问题
[内容讲授]
一、队列的基本知识
队列(Queue)是一种特殊的线性表。它是一种运算受限的线性表。它只允许在表的一端进行插入，而在另一端进行删除。允许删除的一端称为队头(front)，允许插入的一端称为队尾(rear)。因此队列亦称作先进先出(First In First Out)的线性表，简称FIFO表。
1．队列的性质
假设队列为a1,a2,..,a n，那么a1就是队头元素，a n为队尾元素。队列中的元素是按a1,a2,..,a n 的顺序进入的，退出队列也只能按照这个次序依次退出。也就是说，只有在a1离开队列之后，a2才能退出队列，只有在a1,a2,..,a n-1都离开队列之后，a n才能退出队列。图1是队列的示意图。
图1 队列的先进先出示意图
2．队列的存储结构
（1） 顺序存储：可用记录数组实现 （2） 链接存储：用链接存储方式实现
如图所示：
front rear A1
A2
A3
……
……
……
An-1
An
顺序存储结构——数组
3．基本术语：
(1) 队空：当队列中没有元素时称为空队列。
(2) 队满：当队列中单元全部被占用 (3) 队列操作规则：
在队列中依次加入元素a1,a2,…an 之后，a1是队头元素，an 是队尾元素。其出队操作规定从队头进行，进队操作从队尾进行。 即队列的操作是依先进先出的原则进行的。 (4) 上溢、下溢：真溢、假溢
4．队列的基本操作
用顺序队列存储结构的表示方法： type queue=record
vec : array[1..m] of elemtype f, r : integer ; end;
f, r 分别指向队列的头和尾
（1）进队操作（插入运算） Procedure insert( q, x ) ; begin
① if q.r =m then 输出上溢 ② q.r := q.r+1
③ q.vec[q.r]:=x ; { 进入队尾 } ④ if q.f= 0 then q.f:=1
end;
（2）出队操作：删除操作 procedure dele (q , x) ; begin
① if q.f=0 then 输出下溢
链队示意图
… a 2 rear
front
a 1 ∧
②x=q.vec[q.f]
③if q.f=q.r then [ q.f=0; q.r =0 ]
else q.f:=q.f + 1
end;
（3）置空队算法
procedure setnull (Q) ;
begin
q.f:=0 ; q.r:=0 ;
end;
5. 循环队列
为充分利用向量空间，克服"假上溢"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。
（1）定义：将队列的首、尾连接起来，形成一个环状。队尾指向m ，队首指向1。
对循环队列的操作：
（2）插入操作：
procedure insert2(q.x);
begin
if (q.r mod m)+1 =q.f then 溢出
else q.r:= [ (q.r mod m)+1 ；q.vec[q.r]:=x ]
end;
(3) 删除操作:
procedure delete2( q, x ) ;
begin
if q.f=q.r then 输出队空
else [ q.f = ( q.f mod m ) +1 ；x=q.vec[q.f ] ]
end;
(4) 循环队列的长度：
( r- f+ n ) mod n
6. 链队列
链队是指队列的链接存储表示，也就是说它只允许在表尾进行插入和在表头进行删除的单链表。一个链队需要队首、队尾两个指针，一个指向表头，一个指向表尾，如下图所示：
设有如下的数据类型定义：
type linklist= ^dynanode ;
dynanode = record
data : elemtype ;
next : linklist ;
end;
type linkqueue=record
f, r : linklist ;
end;
链接队列的操作运算如下：
（1）插入算法
procedure insert ( HQ,x) ;
begin
●new(p) ; p^.data:=x ; p^.next := nil ;
●if HQ.r = nil then [ HQ.f := p; HQ.r :=p ]
else [ HQ.r^.next := p ; HQ.r := p ]
end;
（2）删除算法
procedure delete (HQ, x ) ;
begin
●if HQ.f= nil then error ( ‘ underflow ‘); { 队为空}
●x:=HQ.f ^.data ;
●p:= HQ.f ;
●if HQ.f = HQ.r then [ HQ.f:= nil ; HQ.r := nil ] { 删除结点}
else HQ.f := HQ.f ^ .next ;
●dispose (p) ;
end;
二、队列的应用
队列在日常生活中应用很多，特别是在计算机科学领域中所起的作用很大。例如在解决主机与外部设备之间速度不匹配问题，解决多用户引起的资源竞争问题等，都运用了队列这样的数据结构算法，下面通过一些实例，了解运用队列解决问题方法。运用队列解决广度优先搜索算法中的最短路径问题是一种比较好的算法。
例题1. 1995年高中组基础题第4 题，从入口（1）到出口（17）的可行路线图中，数字标号表示关卡：
现将上面的路线图，按记录结构存储如下 ：
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
请设计一种能从存储数据中求出从入口到出口经过最少关卡路径的算法。
（1）该题是一个路径搜索问题，根据图示，从入口（1）到出口（17）可以有多种途径，其中最短的路径只有一条，那么如何找最短路径是问题的关键。
（2）根据题意，用一维数组存储各关卡号（设NO ），用另一个数组存储访问到某关卡号的前趋关卡号（设PRE ）。
（3）由于本题是一个典型的图的遍历问题，此题可以采用图的广度优先遍历算法，并利用队列的方式存储顶点之间的联系。即访问一个点，将其后继结点入队，并存储它的前趋结点，直到最后从（17）点出口。
（4）从最后出口的关卡号（17）开始回访它的前趋关卡号，则回返的搜索路径便是最短路径。（跳过许多不必要搜索的关卡）。
（5）从列表中可以看出出口关卡号（17）的被访问路径最短的是：
（17）← （16）←（19）←（18）←（1）←开始
由此，我们得到广度优先遍历求最短路径的基本方法：访问一个点，将其后继结点入队，并存储它的前趋结点，直到所需要到达的地，然后通过最终目标点的结点的前驱记录，返回搜索最短路径的轨迹。
例题2：如下图表示的是从城市A 到城市H 的交通图。从图中可以看出，从城市A 到城市H 要经过若干个城市。现要找出一条经过城市最少的一条路线。
1 2 18 7 3 12 4 19 8 5 13 16 6 14 15 9 17 0
1
1
1
2
2
2
3
4
5
6
8
10
11
11
11
12
城市交通图矩阵存储结构
算法如下：
用队列的方法。用a记录搜索过程，a.city记录经过的城市,a.pre记录前趋元素，这样就可以倒推出最短线路。具体过程如下：
（1）将城市A入队，队首、队尾都为1。
（2）将队首所指的城市所有可直通的城市入队（如果这个城市在队中出现过就不入队，可用一个集合来判断），将入队城市的pre指向队首的位置。然后将队首加1，得到新的队首城市。重复以上步骤，直到城市H入队为止。当搜到城市H时，搜索结束。利用pre可倒推出最少城市线路。
程序如下：
program exp_2 ;
const ju: array[1..8,1..8] of 0..1=((1,0,0,0,1,0,1,1),
(0,1,1,1,1,0,1,1),
(0,1,1,0,0,1,1,1),
(0,1,0,1,1,1,0,1),
(1,1,0,1,1,1,0,0),
(0,0,1,1,1,1,1,0),
(1,1,1,0,0,1,1,0),
(1,1,1,1,0,0,0,1));
type R=record {记录定义}
city:array[1..100] of char;
pre:array[1..100] of integer;
end;
var h, d, i:integer;
a: R;
s: set of 'A'..'H';
procedure out; {输出过程}
begin
write(a.city[d]);
repeat
d:= a.pre[d];
write ('--',a.city[d]);
until a.pre[d]=0;
writeln;
halt;
end;
procedure doit;
begin
h:=0; d:=1;
a.city[1]:='A';
a.pre[1]:=0;
s:=['A'];
repeat {步骤2}
inc(h); {队首加一，出队}
for i:=1 to 8 do {搜索直通的城市}
if （ju [ord(a.city[h])-64, I ]=0）and （not（chr（i+64）in s））then { 判断城市是否走过} begin
inc(d); {队尾加一，入队}
a.city[d]:=chr(64+i);
a.pre[d]:=h;
s:=s+[a.city[d]];
if a.city[d]='H' then out;
end;
until h=d;
end;
begin {主程序}
doit;
end.
输出：H-F--A
例题3 迷宫问题：设有一个n*n方格的迷宫，入口和出口分别在左上角和右下角，如图所示，其走路规则是：在任何一个格子中，可以向8个方向前进，格子中0表示可以走，1表示不通，当迷宫给定后，找出一条从入口到出口的通路。
入口 出口
迷宫图 搜索的8个方向
算法分析： （1）
本题采用回溯算法，应用队列存放走过的路径：即先进先出，后进后出原理，输出走迷宫的路径。 A[I,J]:= 0 表示可以走了
1 表示不可以走
（2）
超界条件为： x<=1，x>n ,y<1, y>n , a[x,y]=1 ,入口处条件：x=1 ,y=1, x=n , y=1
（3） 增量和文字的方向：用数组表示 程序如下： program exp_3 ;
var A: array [1..20 , 1..20 ] of 0…1 ;
c: array [1..20 , 1..20 ] of 0…1 ; b : array [o ..400 ] of integer ; dx,dy : array [1..20 , 1..20 ] of 0…1 ; n, m, k,I,x,y :integer ; begin
write (‘n= ‘) ; readln (n) ;
for y:=1 to n do begin { 初始化程序段 } for x:=1 to n do begin
read(a[x.y]) ;c [ x,y] :=o ;
end;
dx[1]：=1； dy[1]:=-1 ; dx[2]：=1； dy[2]:=0 ;
dx[3]: =-1 ; dy[3]:= 1; dx[4]:= -1 ; dy[4]:=0 ;
0 0 0 1 1 0 1 0 1 0 1 1 0 1 1 0 0
1 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 1 0 0 0 1 1 0 0 1 1 1 1 1 0 1 0 0 1 1 1 0 1 1 1
1
dx[5]: = 1; dy[5]:= 1; dx[6] : = -1 ; dy[6]: = -1 ;
dx[7]:=0 ; dy[7]:= 1 ; dx[8]:= 0 ; dy[8]:= -1 ;
x:=1 ; y:=1 ; m:=0 ; k:=0 ;
for I:= 0 to 400 do b[I]:=0 ;
while (x<> n) or (y<>1 ) do { 按八个方向搜索}
begin
k:=k+1 ;
if k> 8 then begin { 八个方向均搜索后，无法前进}
k:=b[m] ; m:=m-1 ; {退回到上一步}
x: = x- dx[k] ; { 清当前所走的记录内容}
y:= y - dy[k] ;
end
else begin { 可以向前走一步}
x:=x+dx[k] ;
y:=y+dy[k] ;
if ( x<1) or (x>n) or (y<1) or (y>n) or ( a[x,y]=1 ) or ( c[x,y]=1 ) then
begin
x:=x-dx[k] ; y: = y- dy[k] ; { 超界或已经访问过，回退}
end
else
begin
m:= m+1 ; c[x,y] := 1 ; b[m]:= k ; k:=0 ; { 进队，记录所访问的格子} end;
end ;
end ;
x:=1 ; y:=1 ;
write (‘( ‘, x , ‘, ‘ , y , ‘ ) ‘) ;
for I:= 1 to m do
begin
x:=x+ dx[b[I]]; y:=y+ dy[b[I]] ;
write(‘-( ‘, x , ‘, ‘ , y , ‘) ‘ ) ;
end ;
writeln ;
end.
程序运行结果：(1 , 1 ) ——（2，1）——（3，1）——（2，2）——（1，3）——（2，4）——（3，3）——（4，3）——（5，2）——（6，3）——（7，3）——（8，2）—（8，1）例题4 有10升油在10升的容器中，另有两个7升和3升的空容器，现要求用这三个容器倒油，使得最后在10升和7升的容器中各有5升油。
提示：三个容器可以看作三个变量C10，C7，C3，每次倒油的可能性只有如下六种情况：
①C10 向C7 倒油②C10 向C3 倒油
③C7 向C10 倒油④C7 向C3 倒油
⑤C3 向C10 倒油⑥C3 向C7 倒油
算法分析：
（1）从一个容器的状态（三个容器中油的容量）看，虽然有可能经过上述六种倒油的方法产生六种容器状态，但实际上这六种新产生的容器状态，许多是已经出现过的状态。例如初始状态（10,0,0）表示C10=10，C7=0，C3=0，经过上述六种倒油方法只能产生出两种新的容器状态（3,7,0），表示C10向C7倒油的结果和（7,0,3），表示C10向C3倒油的结果。如果再增加应该表示新容器状态是由什么状态产生的指示pre，那么用这三个容器倒油的过程就可以用队列的技法来实现了
（2）队列可以理解为一个数组，数组元素是如下记录：
RECORD
C10,C7,C3, pre: integer;
END;
数组下标为容器状态号。下面是倒油过程的队列图示：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 C10 10 3 7 0 3 7 6 4 6 4 9 1 9 1 2 8 2 8 5 C7 0 7 0 7 4 3 4 3 1 6 1 6 0 7 7 0 5 2 5 C3 0 0 3 3 3 0 0 3 3 0 0 3 1 2 1 2 3 0 0 pre 0 1 1 2 2 3 5 6 7 8 9 10 11 12 13 14 15 16 17 当倒油产生出第19个容器状态时已达到了题解的目的。这时只要根据pre中的状态号17可以回溯到第17个容器状态的pre值为15，依次可再获得13，11，9，7，5，2，1容器状态号，从而即可得到本题的倒油过程（共倒9次），而且是最少的倒油次数。
注意,从一个容器中向另一个容器中倒油,人操作是很直观的,对编程来说则必须考虑:
1) 有没有油可倒?
2) 究竟倒多少?可能要全部倒入另一容器,也可能只要倒一部分另一容器已经满了.
队列元素说明了100个，是因为10升容器最多有0～10种状态，7升容器最多有0～7种状态，3升容器最多有0～3种状态，全部可能的状态为11*8*4=352种，但油的总量为10，因此352种可能状态中大部分是不存在的。变量fp，rp在程序中用作队列的头指针和尾指针，flag在程序中标识是否已倒出了需要的容器状态(C10=5,C7=5)，下面是程序清单：
program exp_4 ;
var fp, rp, i, k, w10, w7, w3:integer;
flag: boolean;
s:array[1..100] of 1..100;
q:array[1..100] of record
c10,c7,c3:integer;
pre:0..100
end;
procedure int;
begin
w10:=q[fp].c10;
w7:=q[fp].c7;
w3:=q[fp].c3;
end;
procedure push; { 进队操作}
var flag1 :boolean;
begin
flag1:=true;
for k:=1 to rp do
if (q[k].c10=w10) and (q[k].c7=w7) and (q[k].c3=w3) then flag1:=false;
if flag1 then begin
rp:=rp+1;
q[rp].c10:=w10;
q[rp].c7:=w7;
q[rp].c3:=w3;
end;
end;
PROCEDURE cup; { 倒油的操作过程}
BEGIN
int;
IF w10>0 THEN BEGIN { 将10升油桶中的油倒入7升油桶} IF w10+w7>=7 THEN BEGIN w10:=w10-7+w7; w7:=7；END ELSE BEGIN w7:=w10+w7; w10:=0；END;
push;
IF (q[rp].c10=5) and (q[rp].c7=5) THEN { 判断是否满足问题的解} BEGIN flag:=true; exit ;END
END;
int;
if w10>0 then begin { 将10升油桶向3升油桶倒油}
if w10+w3>=3 then begin w10:=w10-3+w3; w3:=3 ；end
else begin w3:=w10+w3; w10:=0 ; end;
push;
if (q[rp].c10=5) and (q[rp].c7=5 ) then begin flag:=true; exit ;end end; { 判断是否满足问题求解}
int;
IF w7>0 THEN BEGIN w10:=w10+w7; w7:=0; push; { 将7升倒入10升油桶} IF (q[rp].c10=5) and (q[rp].c7=5 THEN BEGIN flag:=true; exit ; END ;
END; { 判断是否满足问题求解}
int;
IF w7>0 THEN BEGIN { 将7升倒入3升油桶}
IF w7+w3>=3 THEN BEGIN w7:=w7-3+w3; w3:=3；END
ELSE BEGIN w3:=w7+w3; w7:=0; END;
push;
IF (q[rp].c10=5) and (q[rp].c7=5 THEN
BEGIN flag:=true; exit ; END ; { 判断是否满足问题求解} END; { 以下同理}
int;
IF w3>0 THEN BEGIN w10:=w10+w3; w3:=0; push;
IF (q[rp].c10=5) and (q[rp].c7=5 THEN BEGIN flag:=true; exit ; END
END;
int;
IF w3>0 THEN BEGIN
IF w7+w3>=7 THEN BEGIN w3:=w3-7+w7; w7:=7 END
ELSE BEGIN w7:=w7+w3; w3:=0 ; END;
push;
IF (q[rp].c10=5) and (q[rp].c7=5 ) THEN BEGIN flag:=true; exit ;END
END;
END;
BEGIN { 主程序}
fp:=1;
rp:=1;
q[1].c10:=10; { 初始化}
q[1].c7:=0;
q[1].c3:=0;
q[1].pre:=0;
flag:=false;
repeat
cup;
fp:=fp+1;
until flag or (fp>rp); { 反复倒油，直到完成倒油过程或队列中所有元素都访问过}
if fp>rp then write ('have not solution')
else
begin
writeln('queue');
for k:=1 to rp do { 输出进队过程}
writeln (q[k].c10:3,q[k].c7:3,q[k].c3:3,q[k].pre:3);
s[1]:=rp;
i:=1;
while s[i]>0 do { 用S数组存放最少倒油过程的路径}
begin
i:=i+1; s[i]:=q[s[i-1]].pre
end;
writeln ('solution:');
for k:=i-1 downto 1 do { 输出倒油步骤}
writeln('step',i-1-k;2,':',q[s[k]].c10:3,q[s[k]].c7:3,q[s[k]].c3:3) ；
end；
end. {主程序结束}
说明：例题4比较难和繁，将该程序介绍给大家的目的在于，供老师们辅导学生竞赛时参考，希望您的学生能够用队列的特点、记录数组的结构，灵活地解决问题。
参考练习：
1．上机调试完成例题1最短路径问题
2．上机调试完成例题2迷宫问题
3．假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求写一算法模拟上述舞伴配对问题。
4．设有数2，3，5，7，13，运算符号为+，—，* ，且运算符无优先级之分，如2+3*5=25，3*5+2=17。现给出任意一个整数n，要求用以上的数和运算符，以最少的运算次数产生出。
数据结构(C语言)队列的基本操作
实验名称：实验四队列的基本操作 实验目的 掌握队列这种抽象数据类型的特点及实现方法。 实验内容 从键盘读入若干个整数，建一个顺序队列或链式队列，并完成下列操作： （1）初始化队列； （2）队列是否为空； （3）出队； （4）入队。 算法设计分析 （一）数据结构的定义 单链表存储结构定义为： struct Node; //链表单链表 typedef struct Node *PNode; int dui; dui =1; struct Node { int info; PNode link; }; struct LinkQueue { PNode f; PNode r; }; typedef struct LinkQueue *PLinkQueue; （二）总体设计 程序由主函数、创建队列函数、判断是否为空队列函数、入队函数、出队函数、取数函数、显示队列函数、菜单函数组成。其功能描述如下： （1）主函数：调用各个函数以实现相应功能 main() { PLinkQueue a; //定义链表a int b,c,e; //b 菜单选择c选择继续输入e输入元素 do { //菜单选择 mune(); scanf("%d",&b);
switch(b) { case 1://初始化 a=create(); //初始化队列 case 2: //入队 do { printf("\n请输入需要入队的数："); if(e!=NULL) { scanf("%d",&e); enQueue(a,e); } printf("是否继续入队？(是:1 否：0)\n"); scanf("%d",&c); } while(c==1); break; case 3: //出队 c=frontQueue(a); deQueue(a); if(dui!=0) { printf("\n出队为:%d\n",c); } dui=1; break; case 4: //显示队中元素 showQueue(a); break; case 5: return; default: printf("输入错误，程序结束!\n"); return; } } while(a!=5); { return 0; } } （三）各函数的详细设计： Function1: PLinkQueue create(void)//创队
栈和队列习题答案
第三章栈和队列习题答案 一、基础知识题 设将整数1，2，3，4依次进栈，但只要出栈时栈非空，则可将出栈操作按任何次序夹入其中，请回答下述问题： (1)若入、出栈次序为Push(1), Pop(),Push(2),Push(3), Pop(), Pop( ),Push(4), Pop( ),则出栈的数字序列为何(这里Push(i)表示i进栈，Pop( )表示出栈) (2)能否得到出栈序列1423和1432并说明为什么不能得到或者如何得到。 (3)请分析1，2 ，3 ，4 的24种排列中，哪些序列是可以通过相应的入出栈操作得到的。 答：(1)出栈序列为：1324 (2)不能得到1423序列。因为要得到14的出栈序列，则应做Push(1),Pop(),Push(2),Push (3),Push(4),Pop()。这样，3在栈顶，2在栈底，所以不能得到23的出栈序列。能得到1432的出栈序列。具体操作为：Push(1), Pop(),Push(2),Push(3),Push(4),Pop(),Pop(),Pop()。 (3)在1，2 ，3 ，4 的24种排列中，可通过相应入出栈操作得到的序列是： 1234,1243,1324,1342,1432,2134,2143,2314,2341,2431,3214,3241,3421,4321 不能得到的序列是： 1423,2413,3124,3142,3412,4123,4132,4213,4231,4312 链栈中为何不设置头结点 答：链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要对头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。 循环队列的优点是什么如何判别它的空和满 答：循环队列的优点是：它可以克服顺序队列的"假上溢"现象，能够使存储队列的向量空间得到充分的利用。判别循环队列的"空"或"满"不能以头尾指针是否相等来确定，一般是通过以下几种方法：一是另设一布尔变量来区别队列的空和满。二是少用一个元素的空间,每次入队前测试入队后头尾指针是否会重合，如果会重合就认为队列已满。三是设置一计数器记录队列中元素总数，不仅可判别空或满，还可以得到队列中元素的个数。 设长度为n的链队用单循环链表表示，若设头指针，则入队出队操作的时间为何若只设尾指针呢答：当只设头指针时，出队的时间为1，而入队的时间需要n，因为每次入队均需从头指针开始查找，找到最后一个元素时方可进行入队操作。若只设尾指针，则出入队时间均为1。因为是循环链表，尾指针所指的下一个元素就是头指针所指元素，所以出队时不需要遍历整个队列。 指出下述程序段的功能是什么 (1) void Demo1(SeqStack *S){ int i; arr[64] ; n=0 ; while ( StackEmpty(S)) arr[n++]=Pop(S); for (i=0, i< n; i++) Push(S, arr[i]); } .. // 设Q1已有内容，Q2已初始化过 while ( ! QueueEmpty( &Q1) ) { x=DeQueue( &Q1 ) ; EnQueue(&Q2, x); n++;} for (i=0; i< n; i++) { x=DeQueue(&Q2) ; EnQueue( &Q1, x) ; EnQueue( &Q2, x);} 答： (1)程序段的功能是将一栈中的元素按反序重新排列，也就是原来在栈顶的元素放到栈底，栈底的
队列的基本操作代码
队列的基本操作代码： #include
3 栈和队列答案
第3章栈和队列 一、基础知识题 3.1 设将整数1，2，3，4依次进栈，但只要出栈时栈非空，则可将出栈操作按任何次序夹入其中，请回答下述问题： (1)若入、出栈次序为Push(1), Pop(),Push(2),Push(3), Pop(), Pop( ),Push(4), Pop( ),则出栈的数字序列为何(这里Push(i)表示i进栈，Pop( )表示出栈)? (2)能否得到出栈序列1423和1432?并说明为什么不能得到或者如何得到。 (3)请分析 1，2 ，3 ，4 的24种排列中，哪些序列是可以通过相应的入出栈操作得到的。 3.2 链栈中为何不设置头结点? 3.3 循环队列的优点是什么? 如何判别它的空和满? 3.4 设长度为n的链队用单循环链表表示，若设头指针，则入队出队操作的时间为何? 若只设尾指针呢? 3.5 指出下述程序段的功能是什么? (1) void Demo1(SeqStack *S){ int i; arr[64] ; n=0 ; while ( StackEmpty(S)) arr[n++]=Pop(S); for (i=0, i< n; i++) Push(S, arr[i]); } //Demo1 (2) SeqStack S1, S2, tmp; DataType x; ...//假设栈tmp和S2已做过初始化 while ( ! StackEmpty (&S1)) { x=Pop(&S1) ; Push(&tmp,x); } while ( ! StackEmpty (&tmp) ) { x=Pop( &tmp); Push( &S1,x); Push( &S2, x); } (3) void Demo2( SeqStack *S, int m) { // 设DataType 为int 型 SeqStack T; int i; InitStack (&T); while (! StackEmpty( S)) if(( i=Pop(S)) !=m) Push( &T,i); while (! StackEmpty( &T)) { i=Pop(&T); Push(S,i);
栈和队列的基本操作
《数据结构与算法》实验报告 专业班级学号 实验项目 实验二栈和队列的基本操作。 实验目的 1、掌握栈的基本操作：初始化栈、判栈为空、出栈、入栈等运算。 2、掌握队列的基本操作：初始化队列、判队列为空、出队列、入队列等运算。 实验容 题目1： 进制转换。利用栈的基本操作实现将任意一个十进制整数转化为R进制整数 算法提示： 1、定义栈的顺序存取结构 2、分别定义栈的基本操作（初始化栈、判栈为空、出栈、入栈等） 3、定义一个函数用来实现上面问题： 十进制整数X和R作为形参 初始化栈 只要X不为0重复做下列动作 将X%R入栈 X=X/R 只要栈不为空重复做下列动作 栈顶出栈输出栈顶元素 题目2： 利用队列的方式实现辉三角的输出。 算法设计分析 （一）数据结构的定义 1、栈的应用 实现十进制到其他进制的转换，该计算过程是从低位到高位顺序产生R进制数的各个位数，而打印输出一般从高位到低位进行，恰好与计算过程相反。因此，运用栈先进后出的性质，即可完成进制转换。 栈抽象数据结构描述 typedef struct SqStack /*定义顺序栈*/ { int *base; /*栈底指针*/ int *top; /*栈顶指针*/ int stacksize; /*当前已分配存储空间*/ } SqStack;
2、队列的应用 由于是要打印一个数列，并且由于队列先进先出的性质，肯定要利用已经进队的元素在其出队之前完成辉三角的递归性。即，利用要出队的元素来不断地构造新的进队的元素，即在第N行出队的同时，来构造辉三角的第N+1行，从而实现打印辉三角的目的。 队列抽象数据结构描述 typedef struct SeqQueue { int data[MAXSIZE]; int front; /*队头指针*/ int rear; /*队尾指针*/ }SeqQueue; （二）总体设计 1、栈 （1）主函数：统筹调用各个函数以实现相应功能 int main() （2）空栈建立函数：对栈进行初始化。 int StackInit(SqStack *s) （3）判断栈空函数：对栈进行判断，若栈中有元素则返回1，若栈为空，则返回0。 int stackempty(SqStack *s) （4）入栈函数：将元素逐个输入栈中。 int Push(SqStack *s,int x) （5）出栈函数：若栈不空，则删除栈顶元素，并用x返回其值。 int Pop(SqStack *s,int x) （6）进制转换函数：将十进制数转换为R进制数 int conversion(SqStack *s) 2、队列 （1）主函数：统筹调用各个函数以实现相应功能 void main() （2）空队列建立函数：对队列进行初始化。 SeqQueue *InitQueue() （3）返回队头函数：判断队是否为空，若不为空则返回队头元素。 int QueueEmpty(SeqQueue *q) （4）入队函数：将元素逐个输入队列中。 void EnQueue(SeqQueue *q,int x) （5）出队函数：若队列不空，则删除队列元素，并用x返回其值。 int DeQueue(SeqQueue *q) （6）计算队长函数：计算队列的长度。 int QueueEmpty(SeqQueue *q) （7）输出辉三角函数：按一定格式输出辉三角。 void YangHui(int n)
队列的基本操作及其应用
广西工学院计算机学院 《数据结构》课程实验报告书实验四队列的基本操作及其应用 学生姓名：李四 学号：2012 班级：计Y124 指导老师：王日凤 专业：计算机学院软件学院 提交日期：2013年6月20日
1．实验目的 1）通过对队列特点的分析，掌握队列的存储结构及其基本操作，学会定义队列的顺序存储结构和链式存储结构，在实际问题中灵活运用。 2）掌握队列先进先出的特点，掌握队列的基本操作，如出队列、入队列、判队列空、判队列满等，熟悉各种操作的实现方法。 3）通过具体的应用实例，进一步熟悉和掌握队列的实际应用。 2.实验内容 （1）建立一个含n个数据的队列，实现队列的基本操作。包括： ?//1. 初始化,构造一个空队列 void initQueue(Queue &Q) ?//2. 判断队列空, 空则返回true bool QueueEmpty(seqQueue &Q) ?//3. 判断队列满, 满则返回true bool QueueFull(seqQueue &Q) ?//4. 取队头元素, 用x返回队头元素，返回true；空队列则返回false Bool QueueHead(seqQueue &Q, elementType &x) ?//5. 入队列，在队尾插入新元素x （流程图） bool pushQueue (seqQueue &Q, elementType x) ?//6. 出队列，用x带回队头元素，并在队头删除，返回true，队列空则返回false（流程图）bool popQueue (seqQueue &Q, elementType &x) ?//7. 输出队列,从队头到队尾依次输出 void printQueue(seqQueue Q) （2）队列应用：利用队列操作打印杨辉三角形的前n行（如n=7）。 3．实验要求 （1）上机前交实验源程序（纸质版），由学习委员统一收好交老师（附上不交同学名单）。 （2）用一切你能想到的办法解决遇到的问题，培养解决问题的能力。 （3）实验课上进行答辩。 （4）实验报告当场交。报告内容包括：实验目的、实验内容、实验代码、实验输入输出结果以及实验体会供五部分。
栈和队列的基本操作的实现
封面： 安徽大学 网络工程 栈和队列的基本操作的实现 ______2010\4\12
【实验目的】 1.理解并掌握栈和队列的逻辑结构和存储结构； 2.理解栈和队列的相关基本运算； 3.编程对相关算法进行验证。 【实验内容】 （一）分别在顺序和链式存储结构上实现栈的以下操作（含初始化，入栈，出栈，取栈顶元素等）： 1.构造一个栈S，将构造好的栈输出； 2.在第1步所构造的栈S中将元素e 入栈，并将更新后的栈S输出； 3.在第2步更新后所得到的栈S中将栈顶元素出栈，用变量e返回该元素，并将更新后的栈S输出。（二）分别在链队列和循环队列上实现以下操作（初始化，入队，出队，取队头元素等）： 1.构造一个队列Q，将构造好的队列输出； 2.在第1步所构造的队列Q中将元素e入队，并将更新后的队列Q输出； 3.在第2步更新后所得到的队列Q中将队头元素出队，用变量e返回该元素，并将更新后的队列Q输出。
【要求】 1.栈和队列中的元素要从终端输入； 2.具体的输入和输出格式不限； 3.算法要具有较好的健壮性，对运行过程中的错误 操作要做适当处理。 三、实验步骤 1．本实验用到的数据结构 (1)逻辑结构：线性结构 (2)存储结构：程序一、四（顺序存储结构）； 程序二、三（链式存储结构）； 2．各程序的功能和算法设计思想 程序一：顺序栈 # include
试验 --循环队列的基本操作及应用
数据结构实验报告 ----试验三循环队列的基本操作及应用 一、问题描述： 熟悉并掌握循环队列的相关操作，自己设计程序，实现循环队列的构造、清空、销毁及队列元素的插入和删除等相关操作。 二、数据结构设计： #define MAXQSIZE 10 //最大队列长度 struct SqQueue { QElemType *base; //初始化动态分配存储空间 Int front; // 头指针，若队列不空，只想对列头元素 int rear; //尾指针，若队列不空，指向队列尾元素的 //下一个位置 }; 三、功能设计： 程序中所涉及到的函数如下： Status InitQueue(SqQueue &Q) //构造一个空队列Q Status DestroyQueue(SqQueue &Q) //销毁队列Q,Q不再存在 Status ClearQueue(SqQueue &Q) //将Q清为空队列 Status QueueEmpty(SqQueue Q) //若队列Q为空队列，则 //返回TRUE，否则返回FALSE int QueueLength(SqQueue Q) //返回Q的元素个数，即队列长度Status GetHead(SqQueue Q,QElemType &e)//若队列不空，则用e返回Q的对 //头元素，并返回OK，否则返回ERROR Status EnQueue(SqQueue &Q,QElemType e)//插入元素e为Q的新的队尾元素Status DeQueue(SqQueue &Q,QElemType &e)//若队列不空，则删除Q的队头 //元素，用e返回其值，并返回 //OK，否则返回ERROR Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))//从队头到队尾依次 //对队列Q中每个元素调用函数 //vi()。一旦vi失败，则操作失败四、源程序： // c1.h (程序名) #include
第3章 栈和队列
《数据结构》 第3章栈和队列 共85题 一、单选 1. (1)分题目ID号：10705 题目难度：容易 设对一组数据的处理具有“后进先出”的特点，则应采用的数据结构是【1】 A. 队列 B. 栈 C. 顺序表 D. 二叉树题目答案：B 2. (1)分题目ID号：10706 题目难度：容易 若进栈序列为3、5、7、9，进栈和出栈可穿插进行，则不可能的出栈序列是【1】 A. 7，5，3，9 B. 9，5，7，3 C. 9，7，5，3 D. 7，5，9，3 题目答案：B 3. (1)分题目ID号：10707 题目难度：较难 设用一维数组A[m]存储栈，令A[m-1]为栈底，t指示当前栈顶的位置。如果栈不空，则出栈时应使【1】 A. t=t+l B. t=t-1 C. t=m-1 D. 不改变t 题目答案：A 4. (1)分题目ID号：10708 题目难度：容易 设用一维数组A[m]存储栈，令A[0]为栈底，top指示当前钱顶的位置，当把栈清空时所要执行的操作是【1】 A. top-- B. top=0 C. top=-1 D. top=m-1 题目答案：C 5. (1)分题目ID号：10709 题目难度：容易 设栈s的初始状态为空，如果进栈序列为1、2、3、4、5、6，出栈序列为3、2、5、6、4、1，则s的容量至少是【1】 A. 6 B. 4 C. 2 D. 3 题目答案：D 6. (1)分题目ID号：10710 题目难度：容易 设栈s最多能容纳4个元素，现有A、B、C、D、E、F六个元素按顺序进栈，以下可能的出栈序列是【1】 A. E、D、C、B、A、F B. B、C、E、F、A、D C. C、B、E、D、A、F D. A、D、F、E、B、C 题目答案：C
栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用 一_一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 一_二、实验内容 题目一、试写一个算法，判断依次读入的一个以@为结束符的字符序列，是否为回文。所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。 相关常量及结构定义： #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int SElemType; typedef struct SqStack { SElemType *base; SElemType *top; int stacksize; }SqStack; 设计相关函数声明： 判断函数：int IsReverse() 栈：int InitStack(SqStack &S )
int Push(SqStack &S, SElemType e ) int Pop(SqStack &S,SElemType &e) int StackEmpty(s) 一_三、数据结构与核心算法的设计描述 1、初始化栈 /* 函数功能：对栈进行初始化。参数：栈(SqStack S)。 成功初始化返回0,否则返回-1 */ int InitStack(SqStack &S) { S.base=(SElemType *)malloc(10*sizeof(SElemType)); if(!S.base) //判断有无申请到空间 return -1; //没有申请到内存,参数失败返回-1 S.top=S.base; S.stacksize=STACK_INIT_SIZE; S.base=new SElemType; return 0; } 2、判断栈是否是空 /*函数功能:判断栈是否为空。参数; 栈(SqStack S)。栈为空时返回-1,不为空返回0*/ int StackEmpty(SqStack S) { if(S.top==S.base) return -1; else return 0; } 3、入栈 /*函数功能:向栈中插入元素。参数; 栈(SqStack S),元素(SElemtype e)。成功插入返回0,否则返回-1 */ int Push(SqStack &S,SElemType e) { if(S.top-S.base>=S.stacksize) { S.base=(SElemType *)realloc(S.base,(S.stacksize+1) * sizeof(SElemType));
数据结构第三章栈和队列3习题
第三章栈和队列试题 一、单项选择题 1.栈的插入和删除操作在（）进行。 A. 栈顶 B. 栈底 C. 任意位置 D. 指定位置 2.当利用大小为n的数组顺序存储一个栈时，假定用top==n表示栈空，则向这个栈插入一个元素时， 首先应执行（）语句修改top指针。 A. top++; B. top--; C. top = 0; D. top; 3.若让元素1,2,3依次进栈，则出栈次序不可能出现（）种情况。 A. 3, 2, 1 B. 2, 1, 3 C. 3, 1, 2 D. 1, 3, 2 4.在一个顺序存储的循环队列中，队头指针指向队头元素的（）位置。 A. 前一个 B. 后一个 C. 当前 D. 后面 5.当利用大小为n的数组顺序存储一个队列时，该队列的最大长度为（）。 A. n-2 B. n-1 C. n D. n+1 6.从一个顺序存储的循环队列中删除一个元素时，需要（）。 A. 队头指针加一 B. 队头指针减一 C. 取出队头指针所指的元素 D. 取出队尾指针所指的元素 7.假定一个顺序存储的循环队列的队头和队尾指针分别为front和rear，则判断队空的条件为（）。 A. front+1 == rear B. rear+1 == front C. front == 0 D. front == rear 8.假定一个链式队列的队头和队尾指针分别为front和rear，则判断队空的条件为（）。 A. front == rear B. front != NULL C. rear != NULL D. front == NULL 9.设链式栈中结点的结构为（data, link），且top是指向栈顶的指针。若想在链式栈的栈顶插入一 个由指针s所指的结点，则应执行操作（）。 A. top->link = s; B.s->link = top->link; top->link = s; C. s->link = top; top = s; D. s->link = top; top = top->link; 10.设链式栈中结点的结构为（data, link），且top是指向栈顶的指针。若想摘除链式栈的栈顶结点， 并将被摘除结点的值保存到x中，则应执行操作（）。 A. x = top->data; top = top->link; B. top = top->link; x = top->data; C. x = top; top = top->link; D. x = top->data; 11.设循环队列的结构是 #define MaxSize 100 typedef int ElemType;
数据结构 栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用 一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 2、会用栈和队列解决简单的实际问题。 二、实验内容（可任选或全做） 题目一、试写一个算法，判断依次读入的一个以@为结束符的字符序列， 是否为回文。所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。 相关常量及结构定义： # define STACK_INIT_SIZE 100 # define STACKINCREMENT 10 # define OK 1 # define ERROR 0 typedef int SElemType; //栈类型定义 typedef struct SqStack { SElemType *base; SElemType *top; int stacksize; }SqStack; 设计相关函数声明： 判断函数：int IsReverse() 栈：int InitStack(SqStack &S ) int Push(SqStack &S, SElemType e ) int Pop(SqStack &S,SElemType &e) int StackEmpty(s) 题目二、编程模拟队列的管理，主要包括： 出队列、 入队、 统计队列的长度、 查找队列某个元素e、 及输出队列中元素。 [实现提示]：参考教材循环队列的有关算法，其中后两个算法参考顺序表的实现。 题目三、Rails
Description There is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited that time. It was possible to establish only a surface track. Moreover, it turned out that the station could be only a dead-end one (see picture) and due to lack of available space it could have only one track. The local tradition is that every train arriving from the direction A continues in the direction B with coaches reorganized in some way. Assume that the train arriving from the direction A has N <= 1000 coaches numbered in increasing order 1, 2, ..., N. The chief for train reorganizations must know whether it is possible to marshal coaches continuing in the direction B so that their order will be a1, a2, ..., aN. Help him and write a program that decides whether it is possible to get the required order of coaches. You can assume that single coaches can be disconnected from the train before they enter the station and that they can move themselves until they are on the track in the direction B. You can also suppose that at any time there can be located as many coaches as necessary in the station. But once a coach has entered the station it cannot return to the track in the direction A and also once it has left the station in the direction B it cannot return back to the station. Input The input consists of blocks of lines. Each block except the last describes one train and possibly more requirements for its reorganization. In the first line of the block there is the integer N described above. In each of the next lines of the block there is a permutation of 1, 2, ..., N. The last line of the block contains just 0. The last block consists of just one line containing 0. Output
数据结构实验二-栈和队列的基本操作与应用
实验报告 课程名称_______数据结构实验__________________ 实验项目___ 栈和队列的基本操作与应用____ 实验仪器_____________________________________ 系别 ___ 计算机学院_______________ 专业 __________________ 班级/学号______ _________ 学生姓名_____________________ __ 实验日期__________________ 成绩_______________________ 指导教师____ __________________
一、实验内容： 本次实验主要内容是表达式求值，主要通过栈和队列来编写程序，需要实现整数运算其中需要实现的功能有加减乘除以及括号的 运用，其中包含优先级的判断。 二、设计思想 1.优先级中加减、乘除、小括号、以及其他可以分组讨论优先 级 2.优先级关系用“>”“<”“=”来表示三种关系 3.为实现运算符优先使用两个栈：OPTR 运算符栈与OPND操作 符栈 4.运用入栈出栈优先级比较等方式完成运算 三、主要算法框架 1.建立两个栈InitStack(&OPTR); InitStack(&OPND); 2.Push“#”到 OPTR 3.判断优先级做入栈出栈操作 If“<” Push(&OPTR, c); If“=” Pop(&OPTR, &x) If“>” Pop(&OPTR, &theta); Pop(&OPND, &b);
Pop(&OPND, &a); Push(&OPND, Operate(a, theta, b)); 四、调试报告 遇到的问题与解决 1.C语言不支持取地址符，用*S代替&S来编写代码 2.一开始没有计算多位数的功能只能计算一位数，在几个中间 不含运算符的数字中间做p = p*10+c运算。代码如下：p = p * 10 + c - '0'; c = getchar(); if (In(c)) { Push(&OPND, p); p = 0; } 主要算法改进设想： 1.可以用数组储存优先级 2.可以用C++编写，C++支持取地址符&。 五、实验总结
数据结构实验二(栈和队列)
实验二栈和队列的基本操作及其应用 一、实验目的 1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序 存储结构和链式存储结构上的实现。 二、实验内容 本次实验提供4个题目，每个题目都标有难度系数，*越多难度越大，学生 可以根据自己的情况任选一个！ 题目一：回文判断（*） [问题描述] 对于一个从键盘输入的字符串，判断其是否为回文。回文即正反序相同。如 “abba”是回文，而“abab”不是回文。 [基本要求] （1）数据从键盘读入； （2）输出要判断的字符串； （3）利用栈的基本操作对给定的字符串判断其是否是回文，若是则输出 “Yes”，否则输出“No”。 [测试数据] 由学生任意指定。 题目二：顺序栈和循环队列基本操作（*） [基本要求] 1、实现栈的基本操作 六项基本操作的机制是：初始化栈：init_stack(S)；判断栈空：stack_empty(S)；取栈顶元素：stack_top(S,x)；入栈：push_stack(S,x)；出栈：pop_stack(S)；判断栈满：stack_full(S) 2、实现队列的基本操作 六项基本操作的机制是：初始化队列：init_queue(Q)；判断队列是否为空：queue_empty(Q)；取队头元素：queue_front(Q,x)；入队：enqueue(Q,x)；出队：outqueue(Q,x)；判断队列是否为满：queue_full(Q) [测试数据]
由学生任意指定。 题目三：商品货架管理（**） [问题描述] 商店货架以栈的方式摆放商品。生产日期越近的越靠近栈底，出货时从栈顶取货。一天营业结束，如果货架不满，则需上货。入货直接将商品摆放到货架上，则会使生产日期越近的商品越靠近栈顶。这样就需要倒货架，使生产日期越近的越靠近栈底。 [基本要求] 设计一个算法，保证每一次上货后始终保持生产日期越近的商品越靠近栈底。 [实现提示] 可以用一个队列和一个临时栈作为周转。 [测试数据] 由学生任意指定。 三、实验前的准备工作 1、掌握栈的逻辑结构和存储结构。 2、熟练掌握栈的出栈、入栈等操作。 3、掌握队列的逻辑结构和存储结构。 4、熟练掌握队列的出队、入队等操作 四、实验报告要求 1、实验报告要按照实验报告格式规范书写。 *2、写出算法设计思路。 3、实验上要写出多批测试数据的运行结果。 4、结合运行结果，对程序进行分析。 题目四：Rails（ACM训练题） Description There is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited that time. It was possible to establish only a surface track. Moreover, it turned out that the
数据结构栈和队列习题及答案
习题三栈和队列 一单项选择题 1. 在作进栈运算时,应先判别栈是否(① ),在作退栈运算时应先判别栈是否(② )。当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为(③ )。 ①, ②: A. 空 B. 满 C. 上溢 D. 下溢 ③: A. n-1 B. n C. n+1 D. n/2 2．若已知一个栈的进栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，...，pn，若p1＝3，则p2为( )。 A 可能是2 B 一定是2 C 可能是1 D 一定是1 3. 有六个元素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 4.设有一顺序栈S，元素s1,s2,s3,s4,s5,s6依次进栈，如果6个元素出栈的顺序是s2,s3,s4, s6, s5,s1,则栈的容量至少应该是（） A.2 B. 3 C. 5 D.6 5. 若栈采用顺序存储方式存储，现两栈共享空间V[1..m]，top[i]代表第i个栈( i =1,2)栈顶，栈1的底在v[1]，栈2的底在V[m]，则栈满的条件是（）。 A. |top[2]-top[1]|=0 B. top[1]+1=top[2] C. top[1]+top[2]=m D. top[1]=top[2] 6. 执行完下列语句段后，i值为：（） int f(int x) { return ((x>0) ? x* f(x-1):2);} int i ; i =f(f(1)); A．2 B. 4 C. 8 D. 无限递归 7. 表达式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；(*^(- 8. 用链接方式存储的队列，在进行删除运算时（）。 A. 仅修改头指针 B. 仅修改尾指针 C. 头、尾指针都要修改 D. 头、尾指针可能都要修改 9. 递归过程或函数调用时，处理参数及返回地址，要用一种称为（）的数据结构。 A．队列 B．多维数组 C．栈 D. 线性表 10．设C语言数组Data[m+1]作为循环队列SQ的存储空间， front为队头指针，rear为队尾指针，则执行出队操作的语句为（） A.front=front+1 B. front=（front+1）% m C.rear=(rear+1)%(m+1) D. front=(front+1)%(m+1) 11.循环队列的队满条件为 ( ) 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
顺序队列的基本操作
#include
相关文档
- 队列的基本知识及应用
- 顺序栈,循环队列的基本操作及其应用
- 试验--循环队列的基本操作及应用
- 试验 --循环队列的基本操作及应用
- 栈和队列的基本操作讲解
- 实验二 栈和队列(基本操作)
- 试验--循环队列的基本操作及应用
- 队列及其应用
- 循环队列的9个基本操作及测试
- 队列的定义及基本操作
- 栈和队列的基本操作及其应用数据结构实验报告书
- 实验三 队列及队列的应用实验
- 队列的基本操作
- 队列的基本操作及其应用
- 队列的基本操作(xinn)
- 试验 循环队列的基本操作及应用
- 数据结构实验三(循环队列基本操作)题目和源程序
- 栈和队列的基本操作及其应用
- 数据结构 栈和队列的基本操作实现及其应用
- 栈和队列基本操作实验报告