编程的队列有什么用

A. Python Queue 入门

Queue 叫队列，是数据结构中的一种，基本上所有成熟的编程语言都内置了对 Queue 的支持。

Python 中的 Queue 模块实现了多生产者和多消费者模型，当需要在多线程编程中非常实用。而且该模块中的 Queue 类实现了锁原语，不需要再考虑多线程安全问题。

该模块内置了三种类型的 Queue，分别是 class queue.Queue(maxsize=0) ， class queue.LifoQueue(maxsize=0) 和 class queue.PriorityQueue(maxsize=0) 。它们三个的区别仅仅是取出时的顺序不一致而已。

Queue 是一个 FIFO 队列，任务按照添加的顺序被取出。

LifoQueue 是一个 LIFO 队列，类雀指似堆栈，后添加的任务先被取出。

PriorityQueue 是一个优先级队列，队列里面的肆岁友任务按照优先级排序，优先级高的先被取出。

如你所见，就是上面所说的三种不同类型的内置队列，其中 maxsize 是个整数，用于设置可以放入队列中的任务数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的任务被消费掉。如果 maxsize 小于等于零，则队列尺寸为无限大。

向队列中添加任务，直接调用 put() 函数即可

put() 函数完整的函数签名如下 Queue.put(item, block=True, timeout=None) ，如你所见，该函数有两个可选参数。

默认情况下，在队列满时，该函数会一直阻塞，直到队列中有空余的位置可以添加任务为止。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有空余的位置出来，则会引发 Full 异常。

当 block 为 false 时，timeout 参数将失效。同时如果队列中没有空余的位置可添加任务则会引发 Full 异常，否则会直接把任务放入队列并返回，不会阻塞。

另外，还可以通过 Queue.put_nowait(item) 来添加任务，相当于 Queue.put(item, False) ，不再赘述。同样，在队列满时，该操作会引发 Full 异常。

从队列中获取任务，直接调用 get() 函数即可。

与 put() 函数一样， get() 函数也有两个可选参数，完整签名如下 Queue.get(block=True, timeout=None) 。

默认情况下，当队列空时调用该函数会一直阻塞，直到队列中有任务可获取为止。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有任务可获取，则会引发 Empty 异常。

当 block 为 false 时，timeout 参数将失效。同时如果队列中没有任务可获取则会立刻引发 Empty 异常，否则会直接获取一个任务并返回，不会阻塞。

另外，还可以通过 Queue.get_nowait() 来获取任务，相当于 Queue.get(False) ，不再赘述。同裂槐样，在队列为空时，该操作会引发 Empty 异常。

Queue.qsize() 函数返回队列的大小。注意这个大小不是精确的，qsize() > 0 不保证后续的 get() 不被阻塞，同样 qsize() < maxsize 也不保证 put() 不被阻塞。

如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。

如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。

queue.Queue() 是 FIFO 队列，出队顺序跟入队顺序是一致的。

queue.LifoQueue() 是 LIFO 队列，出队顺序跟入队顺序是完全相反的，类似于栈。

优先级队列中的任务顺序跟放入时的顺序是无关的，而是按照任务的大小来排序，最小值先被取出。那任务比较大小的规则是怎么样的呢。

注意，因为列表的比较对规则是按照下标顺序来比较的，所以在没有比较出大小之前 ，队列中所有列表对应下标位置的元素类型要一致。

好比 [2,1] 和 ["1","b"] 因为第一个位置的元素类型不一样，所以是没有办法比较大小的，所以也就放入不了优先级队列。

然而对于 [2,1] 和 [1,"b"] 来说即使第二个元素的类型不一致也是可以放入优先级队列的，因为只需要比较第一个位置元素的大小就可以比较出结果了，就不需要比较第二个位置元素的大小了。

但是对于 [2,1] 和 1 [2,"b"] 来说，则同样不可以放入优先级队列，因为需要比较第二个位置的元素才可以比较出结果，然而第二个位置的元素类型是不一致的，无法比较大小。

综上，也就是说， 直到在比较出结果之前，对应下标位置的元素类型都是需要一致的 。

下面我们自定义一个动物类型，希望按照年龄大小来做优先级排序。年龄越小优先级越高。

本章节介绍了队列以及其常用操作。因为队列默认实现了锁原语，因此在多线程编程中就不需要再考虑多线程安全问题了，对于程序员来说相当友好了。

B. 栈和队列的作用是什么它们主要可以应用在哪些方面

栈和队列都属于一位链表，栈是后进先出，进和出都是在同一端进行，就好像一筒羽毛球，只有把上面拿出来，下面的才能拿隐返出来；队列是先进先出的，进和出分别在不同的端进行，比如排队的人，排在前面的人先到柜台办理业务，后面来的人后得到服务。

栈作为一种数据结构，是一种只能在一汪核端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底。

最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指困携掘针。

(2)编程的队列有什么用扩展阅读：

在计算机系统中，栈则是一个具有以上属性的动态内存区域。程序可以将数据压入栈中，也可以将数据从栈顶弹出。在i386机器中，栈顶由称为esp的寄存器进行定位。压栈的操作使得栈顶的地址减小，弹出的操作使得栈顶的地址增大。

栈在程序的运行中有着举足轻重的作用。最重要的是栈保存了一个函数调用时所需要的维护信息，这常常称之为堆栈帧或者活动记录。

C. 栈和队列在计算机系统中有哪些应用

栈是在一列数据中，一块后进先出的地方，在编程中比如1+2+3+……+100，就可以利用栈来完成；而队列先进先出的地方，比如打印文档就是排队等候，先到的就先得打印一样。在计算机系统中编程方面用得最多也最明显，在已经成为程序成品的不太明显，最明显的就是打印。祥锋

栈和队列都属于一位链表，栈是后进先出，进和出都是谨仔晌在同一端进行，就好像一筒羽毛球，只有把上面拿出来，下面的才能拿出来；队列是先进先出的，进和出分别在不同的端进行，比如排队的人，排在前面的人先到柜台办理业务，后面来的人后得到服务。

(3)编程的队列有什么用扩展阅读：

系统或者数据结构栈中数据内容的读取与戚核插入（压入push和弹出pop）是两回事！压入是增加数据，弹出是删除数据 ，这些操作只能从栈顶即最低地址作为约束的接口界面入手操作 ，但读取栈中的数据是随便的没有接口约束之说。

很多人都误解这个理念从而对栈产生困惑。而系统栈在计算机体系结构中又起到一个跨部件交互的媒介区域的作用 即 cpu 与内存的交流通道 ，cpu只从系统给我们自己编写的应用程序所规定的栈入口线性地读取执行指令， 用一个形象的词来形容它就是pipeline。

D. 我现在在学习c语言，入门的课已经通过了，现在在学习一些关于堆栈与队列，还有一些高级的东西

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元物迅素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，备茄它是把栈顶元素删除掉，使其相仿蚂察邻的元素成为新的栈顶元素。队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。以上是从数据结构角度来看，从操作系统角度来看，所有的数据结构都是对虚拟内存的操作，堆是堆，栈是栈，栈指的是C语言函数所使用的自动有函数回收的虚拟内存空间，而堆则有操作系统堆管理器来管理的那部分虚拟内存，从C语言角度来看，使用malloc函数动态分配的内存，就是堆内存。

E. 在linux驱动程序中，使用等待队列的作用

我帮你搜索到如下的回复希望对你有帮助《Linux就该这么学》
概念与术语
1内核里面的一个队列，可以将对象加入到队列中，
2可以选择条件休眠和无条件休眠，一般情况下是条件休眠用得较多。
3作用：阻塞读。当运用程序读数据但是现在还无数据可读时，往往会先挂起，
4让其他线程先走，等有数据可读时再唤醒。
5那么什么时候唤醒呢？怎样唤醒呢？
6这里等待队列就派上用场了。读的时候若无数据可读则加入到等待队列中，
7写入的时候唤醒这个队列。
8可以类比运用程序编程中的pthread_cond_wait()与pthread_cond_broadcast()记忆。
函数接口
include/linux/wait.h

F. 栈和队列在实际编程中的应用有哪些

模拟递归，表达式化成后缀，括号匹配等等

G. 栈和队列数据结构的特点,什么情况下用到栈,什么情况下用到队列(各举3个例子)

栈：特点就是一个先进后出的结构。
队列：特点就是一个先进先出的结构。
//一般只要你满足这个特点就可以称之为栈或队列。
栈的应用：非常广泛，在CPU内部就有提供栈这个机制。主要用途：函数调用和返回，数字转字符，表达式求值，走迷宫等等。在CPU内部栈主要是用来进行子程序调用和返回，中断时数据保存和返回。在编程语言中：主要用来进行函数的调用和返回。可以说在计算机中，只要数据的保存满足先进后出的原理，都优先考虑使用栈，所以栈是计算机中不可缺的机制。
队列的应用：队列主要用在和时间有关的地方，特别是操作系统中，队列是实现多任务的重要机制。windows中的消息机制就是通过队列来实现的。进程调度也是使用队列来实现，所以队列也是一个重要的机制。只要满足数据的先进先出原理就可以使用队列。

H. 队列研究的重要性评价怎么写

队列是一种重要的数据结构，它在许多不同的领域都有广泛的应用。队列的研究对于我们理解和优化计算机系统的性能具有重要意义。

例如，在计算机网络中，队列可以用来维护消息的没冲好传递顺序，并且在处理海量枯铅数据时也可以提供有效的存储方式。队列在操作系统中也有着广泛的应用，它可以用来调度进程的执行顺序，并且在多线程编程中也可以提供有效的同步机制。

此外，队列在数据库系统中也有着重要的作用，它可以用来维护数据的存储和访问顺序，并且在数据分析和挖掘中也可以提供有效的处理方式判亮。

总的来说，队列研究对于我们更好地理解和优化计算机系统的性能具有重要意义，因此其重要性是不可忽视的。

I. 求救：栈和队列在程序设计中的作用

栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，

故又称它们为运算受限的线性表。栈和队列被广泛应用于各种程序设计中。

栈的定义及基本运算

1、栈的定义

栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。

(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。

(2)当表中没有元素时称为空栈。

(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO 表。

栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入

（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。

【示例】元素是以a1，a2，…，an 的顺序进栈，退栈的次序却是an，an-1，…，a1。

2、栈的基本运算

（1）InitStack（S）

构造一个空栈S。

（2）StackEmpty（S）

判栈空。若S 为空栈，则返回TRUE，否则返回FALSE。

（3）StackFull（S）

判栈满。若S 为满栈，则返回TRUE，否则返回FALSE。

注意：

该运算只适用于栈的顺序存储结构。

（4）Push（S，x）

进栈。若栈S 不满，则将元素x 插入S 的栈顶。

（5）Pop（S）

退栈。若栈S 非空，则将S 的栈顶元素删去，并返回该元素。

（6）StackTop（S）

取栈顶元素。若栈S 非空，则返回栈顶元素，但不改变栈的状态。

顺序栈

栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。

1、顺序栈的类型定义

#define StackSize 100 //假定预分配的栈空间最多为100 个元素

typedef char DataType;//假定栈元素的数据类型为字符

typedef struct{

DataType data[StackSize];

int top;

}SeqStack;

注意：

①顺序栈中元素用向量存放

②栈底位置是固定不变的，可设置在向量两端的任意一个端点

③栈顶位置是随着进栈和退栈操作而变化的，用一个整型量top（通常称top 为栈顶指针）来指示

当前栈顶位置

2、顺序栈的基本操作

前提条件：

设S 是SeqStack 类型的指针变量。若栈底位置在向量的低端，即S-＞data[0]是栈底元素。

（1） 进栈操作

进栈时，需要将S-＞top 加1

注意：

①S-＞top==StackSize-1 表示栈满

②"上溢"现象--当栈满时，再做进栈运算产生空间溢出的现象。

上溢是一种出错状态，应设法避免。

（2） 退栈操作

退栈时，需将S-＞top 减1

注意：

①S-＞top<0 表示空栈

②"下溢"现象——当栈空时，做退栈运算产生的溢出现象。

下溢是正常现象，常用作程序控制转移的条件。

顺序栈在进栈和退栈操作时的具体变化情况【参见动画演示】

3、顺序栈的基本运算

（1） 置栈空

void InitStack（SeqStack *S）

{//将顺序栈置空

S->top=-1;

}

（2） 判栈空

int StackEmpty（SeqStack *S）

{

return S->top==-1;

}

（3） 判栈满

int StackFull（SeqStack *SS）

{

return S->top==StackSize-1;

}

（4） 进栈

void Push（S，x）

{

if (StackFull(S))

Error("Stack overflow"); //上溢，退出运行

S->data[++S->top]=x;//栈顶指针加1 后将x 入栈

}

（5） 退栈

DataType Pop（S）

{

if(StackEmpty(S))

Error("Stack underflow"); //下溢，退出运行

return S->data[S->top--];//栈顶元素返回后将栈顶指针减1

}

（6） 取栈顶元素

DataType StackTop（S）

{

if(StackEmpty(S))

Error("Stack is empty");

return S->data[S->top];

}

4、两个栈共享同一存储空间

当程序中同时使用两个栈时，可以将两个栈的栈底设在向量空间的两端，让两个栈各自向中间延伸。

当一个栈里的元素较多，超过向量空间的一半时，只要另一个栈的元素不多，那么前者就可以占用后者的

部分存储空间。

只有当整个向量空间被两个栈占满（即两个栈顶相遇）时，才会发生上溢。因此，两个栈共享一个长

度为m 的向量空间和两个栈分别占用两个长度为└ m/2┘和┌m/2┐的向量空间比较，前者发生上溢的概

率比后者要小得多。

链栈

栈的链式存储结构称为链栈。

1、链栈的类型定义

链栈是没有附加头结点的运算受限的单链表。栈顶指针就是链表的头指针。

链栈的类型说明如下：

typedef struct stacknode{

DataType data

struct stacknode *next

}StackNode;

typedef struct{

StackNode *top; //栈顶指针

}LinkStack;

注意：

①LinkStack 结构类型的定义是为了方便在函数体中修改top 指针本身

②若要记录栈中元素个数，可将元素个数属性放在LinkStack 类型中定义。

2、链栈的基本运算

（1） 置栈空

Void InitStack(LinkStack *S)

{

S->top=NULL;

}

（2） 判栈空

int StackEmpty(LinkStack *S)

{

return S->top==NULL;

}

（3） 进栈

void Push(LinkStack *S,DataType x)

{//将元素x 插入链栈头部

StackNode *p=(StackNode *)malloc(sizeof(StackNode));

p->data=x;

p->next=S->top;//将新结点*p 插入链栈头部

S->top=p;

}

（4） 退栈

DataType Pop(LinkStack *S)

{

DataType x;

StackNode *p=S->top;//保存栈顶指针

if(StackEmpty(S))

Error("Stack underflow."); //下溢

x=p->data; //保存栈顶结点数据

S->top=p->next; //将栈顶结点从链上摘下

free(p);

return x;

}

（5） 取栈顶元素

DataType StackTop(LinkStack *S)

{

if(StackEmpty(S))

Error("Stack is empty.")

return S->top->data;

}

注意：

链栈中的结点是动态分配的，所以可以不考虑上溢，无须定义StackFull 运算。

--------------------------------------------------------------------------------------------

-----------------

队列的定义及基本运算

1、定义

队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表

（1）允许删除的一端称为队头（Front）。

（2）允许插入的一端称为队尾（Rear）。

（3）当队列中没有元素时称为空队列。

（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO 表。

队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"），每次离开的

成员总是队列头上的（不允许中途离队），即当前"最老的"成员离队。

【例】在队列中依次加入元素a1，a2，… ，an 之后，a1 是队头元素，an 是队尾元素。退出队列的次序

只能是a1，a2，… ，an。

2、队列的基本逻辑运算

（1）InitQueue（Q）

置空队。构造一个空队列Q。

（2）QueueEmpty（Q）

判队空。若队列Q 为空，则返回真值，否则返回假值。

（3） QueueFull（Q）

判队满。若队列Q 为满，则返回真值，否则返回假值。

注意：

此操作只适用于队列的顺序存储结构。

（4） EnQueue（Q，x）

若队列Q 非满，则将元素x 插入Q 的队尾。此操作简称入队。

（5） DeQueue（Q）

若队列Q 非空，则删去Q 的队头元素，并返回该元素。此操作简称出队。

（6） QueueFront（Q）

若队列Q 非空，则返回队头元素，但不改变队列Q 的状态。

顺序队列

1、顺序队列

（1）顺序队列的定义

队列的顺序存储结构称为顺序队列，顺序队列实际上是运算受限的顺序表。

（2） 顺序队列的表示

①和顺序表一样，顺序队列用一个向量空间来存放当前队列中的元素。

②由于队列的队头和队尾的位置是变化的，设置两个指针front 和rear 分别指示队头元素和队尾元素

在向量空间中的位置，它们的初值在队列初始化时均应置为0。

（3） 顺序队列的基本操作

①入队时：将新元素插入rear 所指的位置，然后将rear 加1。

②出队时：删去front 所指的元素，然后将front 加1 并返回被删元素。

注意：

①当头尾指针相等时，队列为空。

②在非空队列里，队头指针始终指向队头元素，尾指针始终指向队尾元素的下一位置。

顺序队列基本操作【参见动画演示】

（4）顺序队列中的溢出现象

① "下溢"现象

当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。

② "真上溢"现象

当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。

③ "假上溢"现象

由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中

实际的元素个数远远小于向量空间的规模时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。

该现象称为"假上溢"现象。

【例】假设下述操作序列作用在初始为空的顺序队列上：

EnQueue，DeQueue，EnQueue，DeQueue，…

尽管在任何时刻，队列元素的个数均不超过1，但是只要该序列足够长，事先定义的向量空间无论多大

均会产生指针越界错误。

链队列

1、链队列的定义

队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。

2、链队列的结构类型说明

注意：

增加指向链表上的最后一个结点的尾指针，便于在表尾做插入操作。

链队列示意图见上图，图中Q 为LinkQueue 型的指针。

3、链队列的基本运算

（1） 置空队

void InitQueue(LinkQueue *Q)

{

Q->front=Q->rear=NULL;

}

（2） 判队空

intQueueEmpty(LinkQueue *Q)

{

return Q->front==NULL&&Q->rear==Null;

//实际上只须判断队头指针是否为空即可

}

（3） 入队

void EnQueue(LinkQueue *Q,DataType x)

{//将元素x 插入链队列尾部

QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode));//申请新结点

p->data=x; p->next=NULL;

if(QueueEmpty(Q))

Q->front=Q->rear=p; //将x 插入空队列

else { //x 插入非空队列的尾

Q->rear->next=p; //*p 链到原队尾结点后

Q->rear=p; //队尾指针指向新的尾

}

}

（4） 出队

DataType DeQueue (LinkQueue *Q)

{

DataType x;

QueueNode *p;

if(QueueEmpty(Q))

Error("Queue underflow");//下溢

p=Q->front; //指向对头结点

x=p->data; //保存对头结点的数据

Q->front=p->next; //将对头结点从链上摘下

if(Q->rear==p)//原队中只有一个结点，删去后队列变空，此时队头指针已为空

Q->rear=NULL;

free(p); //释放被删队头结点

return x; //返回原队头数据

}

（5） 取队头元素

DataType QueueFront(LinkQueue *Q)

{

if(QueueEmpty(Q))

Error("Queue if empty.");

return Q->front->data;

}

注意：

①和链栈类似，无须考虑判队满的运算及上溢。

②在出队算法中，一般只需修改队头指针。但当原队中只有一个结点时，该结点既是队头也是队尾，

故删去此结点时亦需修改尾指针，且删去此结点后队列变空。

③以上讨论的是无头结点链队列的基本运算。和单链表类似，为了简化边界条件的处理，在队头结点

前也可附加一个头结点，增加头结点的链队列的基本运算【参见练习】

循环队列

为充分利用向量空间，克服"假上溢"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这

种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。

（1） 循环队列的基本操作

循环队列中进行出队、入队操作时，头尾指针仍要加1，朝前移动。只不过当头尾指针指向向量上界

（QueueSize-1）时，其加1 操作的结果是指向向量的下界0。这种循环意义下的加1 操作可以描述为：

① 方法一：

if(i+1==QueueSize) //i 表示front 或rear

i=0;

else

i++;

② 方法二--利用"模运算"

i=(i+1)%QueueSize；

（2） 循环队列边界条件处理

循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时

头尾指针均相等。因此，无法通过条件front==rear 来判别队列是"空"还是"满"。【参见动画演示】

解决这个问题的方法至少有三种：

① 另设一布尔变量以区别队列的空和满；

② 少用一个元素的空间。约定入队前，测试尾指针在循环意义下加1 后是否等于头指针，若相等则认

为队满（注意：rear 所指的单元始终为空）；

③使用一个计数器记录队列中元素的总数（即队列长度）。

（3） 循环队列的类型定义

#define Queur Size 100 //应根据具体情况定义该值

typedef char Queue DataType; //DataType 的类型依赖于具体的应用

typedef Sturet{ //头指针，队非空时指向队头元素

int front; //尾指针，队非空时指向队尾元素的下一位置

int rear; //计数器，记录队中元素总数

DataType data[QueueSize]

}CirQueue;

（4） 循环队列的基本运算

用第三种方法，循环队列的六种基本运算：

① 置队空

void InitQueue(CirQueue *Q)

{

Q->front=Q->rear=0;

Q->count=0; //计数器置0

}

② 判队空

int QueueEmpty(CirQueue *Q)

{

return Q->count==0; //队列无元素为空

}

③ 判队满

int QueueFull(CirQueue *Q)

{

return Q->count==QueueSize; //队中元素个数等于QueueSize 时队满

}

④ 入队

void EnQueue(CirQueuq *Q,DataType x)

{

if(QueueFull((Q))

Error("Queue overflow"); //队满上溢

Q->count ++; //队列元素个数加1

Q->data[Q->rear]=x; //新元素插入队尾

Q->rear=(Q->rear+1)%QueueSize; //循环意义下将尾指针加1

⑤ 出队

DataType DeQueue(CirQueue *Q)

{

DataType temp;

if(QueueEmpty((Q))

Error("Queue underflow"); //队空下溢

temp=Q->data[Q->front];

Q->count--; //队列元素个数减1

Q->front=(Q->front+1)&QueueSize; //循环意义下的头指针加1

return temp;

}

⑥取队头元素

DataType QueueFront(CirQueue *Q)

{

if(QueueEmpty(Q))

Error("Queue if empty.");

return Q->data[Q->front];

}

J. 编程为什么要使用栈结构而不要队列

用栈大多是为了保存现场,比如在递归消除中,在二叉树前中后遍历中.

而队列大多是为了保存一个状态,一边出队一边进队进行扫描,比如二叉树的层次遍历以及图的BFS.

两者各有各的用处,而可以很明显的观察到,前者的用途要比后者广泛一些.

编程是一段很有意思的旅程,LZ加油