c语言栈队列
‘壹’ c语言栈和队列问题：停车场停车问题
#ifndef__PLOT_H__#define__PLOT_H__#defineFALSE0#defineTRUE1#defineMONEY1//单价可以自己定义#defineMAX_STOP10#defineMAX_PAVE100//存放汽车牌号typedefstruct{
inttime1;//进入停车场时间
inttime2;//离开停车场时间
charplate[10];
//汽车牌照号码，定义一个字符指针类型}Car;//停放栈typedefstruct{
CarStop[MAX_STOP-1];//各汽车信息的存储空间
inttop;//用来指示栈顶位置的静态指针}Stopping;//等候队列typedefstruct{intcount;//用来指示队中的数据个数
CarPave[MAX_PAVE-1];//各汽车信息的存储空间
intfront,rear;//用来指示队头和队尾位置的静态指针}Pavement;//让路栈typedefstruct{
CarHelp[MAX_STOP-1];//各汽车信息的存储空间
inttop;//用来指示栈顶位置的静态指针}Buffer;
Stoppings;
Pavementp;
Bufferb;
Carc;charC[10];voidstop_pave();//车停入便道voidcar_come();//车停入停车位voidstop_to_buff();//车进入让路栈voidcar_leave();//车离开voidwelcome();//主界面函数voidDisplay();//显示车辆信息#
源文件PLot.c
#include"PLot.h"#include<stdio.h>#include<time.h>//包含时间函数的头文件#include<string.h>#include<stdlib.h>voidstop_to_pave()//车停入便道{//判断队满
if(p.count>0&&(p.front==(p.rear+1)%MAX_PAVE))
{printf("便道已满，请下次再来
");
}else
{strcpy(p.Pave[p.rear].plate,C);
p.rear=(p.rear+1)%MAX_PAVE;//队尾指示器加1
p.count++;//计数器加1
printf("牌照为%s的汽车停入便道上的%d的位置
",C,p.rear);
}
}voidcar_come()//车停入停车位{printf("请输入即将停车的车牌号:");//输入车牌号
scanf("%s",&C);if(s.top>=MAX_STOP-1)//如果停车位已满，停入便道
{
stop_to_pave();//停车位->便道函数
}else
{
s.top++;//停车位栈顶指针加1
time_tt1;longintt=time(&t1);//标记进入停车场的时间
char*t2;
t2=ctime(&t1);//获取当前时间
c.time1=t;strcpy(s.Stop[s.top].plate,C);//将车牌号登记
printf("牌照为%s的汽车停入停车位的%d车位,当前时间:%s
",C,s.top+1,t2);
}return;
}voidstop_to_buff()//车进入让路栈{//停车位栈压入临时栈，为需要出栈的车辆让出道
while(s.top>=0)
{
if(0==strcmp(s.Stop[s.top--].plate,C))
{break;
}//让出的车进入让路栈
strcpy(b.Help[b.top++].plate,s.Stop[s.top+1].plate);printf("牌照为%s的汽车暂时退出停车位
",s.Stop[s.top+1].plate);
}
b.top--;//如果停车位中的车都让了道，说明停车位中无车辆需要出行
if(s.top<-1)
{printf("停车位上无此车消息
");
}else
{printf("牌照为%s的汽车从停车场开走
",s.Stop[s.top+1].plate);
}//将让路栈中的车辆信息压入停车位栈
while(b.top>=0)
{strcpy(s.Stop[++s.top].plate,b.Help[b.top--].plate);printf("牌照为%s的汽车停回停车位%d车位
",b.Help[b.top+1].plate,s.top+1);
}//从便道中->停车位
while(s.top<MAX_STOP-1)
{if(0==p.count)//判断队列是否为空
{break;
}//不为空，将便道中优先级高的车停入停车位
else
{strcpy(s.Stop[++s.top].plate,p.Pave[p.front].plate);printf("牌照为%s的汽车从便道中进入停车位的%d车位
",p.Pave[p.front].plate,s.top+1);
p.front=(p.front+1)%MAX_PAVE;
p.count--;
}
}
}voidcar_leave()//车离开{printf("请输入即将离开的车牌号:
");scanf("%s",&C);if(s.top<0)//判断停车位是否有车辆信息
{printf("车位已空，无车辆信息！
");
}else
{
stop_to_buff();
}
time_tt1;
longintt=time(&t1);
c.time2=t;//标记离开停车场的时间
char*t2;
t2=ctime(&t1);//获取当前时间
printf("离开时间%s
需付%ld元
",t2,MONEY*(c.time2-c.time1)/10);
}voidDisplay()
{inti=s.top;if(-1==i)
{printf("停车场为空
");
}
time_tt1;longintt=time(&t1);//标记显示时的时间
printf(" 车牌号 停放时间 当前所需支付金额
");while(i!=-1)
{
printf(" %s %d秒 %d元
",s.Stop[i].plate,t-c.time1,MONEY*(t-c.time1)/10);
i--;
}
}voidwelcome()
{printf(" *******************目前停车场状况***********************
");printf(" 停车场共有%d个车位,当前停车场共有%d辆车,等候区共有%d辆车
",MAX_STOP,s.top+1,(p.rear+MAX_PAVE-p.front)
%MAX_PAVE);printf(" ********************************************************
");printf(" ---------------WelcometoourCarParking---------------
");
printf(" *1.Parking*
");
printf(" *2.leaving*
");
printf(" *3.situation*
");
printf(" *4.exit*
");
printf(" --------------------------------------------------------
");
}
主函数main.c
/**********************************************************
问题描述：停车场是一个能放n辆车的狭长通道，只有一个大门，
汽车按到达的先后次序停放。若车场满了，车要在门外的便道上等候
，一旦有车走，则便道上第一辆车进入。当停车场中的车离开时，由
于通道窄，在它后面的车要先退出，待它走后依次进入。汽车离开
时按停放时间收费。
基本功能要求：
1）建立三个数据结构分别是：停放队列，让路栈，等候队列
2）输入数据模拟管理过程，数据（入或出，车号）。
***********************************************************/#include"PLot.h"intmain()
{//初始化
s.top=-1;
b.top=0;
p.rear=0;
p.count=0;
p.front=0;while(1)
{
system("clear");
welcome();inti,cho;
scanf("%d",&i);if(1==i)car_come();
if(2==i)car_leave();if(3==i)Display();if(4==i)break;
printf("返回请输入1
");
scanf("%d",&cho);if(1==cho)
{continue;
}else
{
printf("您的输入有误，请重新输入
");
scanf("%d",&cho);continue;
}
}return0;
}
‘贰’ C语言栈及队列问题
1、按链表的相反顺序打印出链表中各节点的值
typedef struct _l
{
int data;
struct _l *next;
} link;
void func(link *p)
{
if(p!=NULL)
{
func(p->next);
printf("%d",p->data);
}
}
2、一个队列管理的模拟系统
typedef struct _l
{
int data;
struct _l *next;
} link;
link *tail=NULL;
//1.队列初始化
int init()
{
tail=(link *)malloc(sizeof(link));
if(tail!=NULL)
{
tail->next=tail;
return 1;
}
return 0;
}
//2.当键盘输入一个正整数时，把它作为一个队列元素入队列
int insert(int n)
{
link *p;
p=(link *)malloc(sizeof(link));
if(p==NULL)
{
return 0;
}
p->data=n;
p->next=tail->next;
tail->next=p;
return 0;
}
//3.当键盘输入一个负整数时，则队头元素出列
int delete()
{
link *p=tail,*q=p;
while(p->next!=tail)
{
q=p;p=p->next;
}
if(p==q)
{
return 0;//队列空
}
else
{
q->next=p->next;
free(p);
return 1;
}
}
//4.当键盘输入0时，退出系统
//5.每输入一个整数，输出经过队列操作后队列中的所有元素
void trans()
{
link *p=tail->next;
while(p!=tail)
{
printf("%d",p->data);
p=p->next;
}
}
int main()
{
int n;
init();
while(true)
{
scanf("%d",&n);
if(n==0)
{
break;
}
else if(n>0)
{
insert(n);
}
else
{
delete();
}
trans();
}
}
‘叁’ c语言实现队列和栈的方法
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define N 20
typedef char SElemType;
typedef int Status;typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;#include<stdio.h>
#include<stdlib.h>Status CreatStack(SqStack &S){
//创建栈
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//CreatStackStatus Push(SqStack &S,SElemType e){
//插入e为新的栈顶元素
if(S.top-S.base>=S.stacksize){//栈满，追加存储空间
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit (OVERFLOW);//存储空间分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//PushStatus Pop(SqStack &S ,SElemType &e){
//若栈不空，删除栈顶元素，并用e返回其值
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}//Pop typedef char QElemType;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QNodePtr;typedef struct{
QNodePtr front;
QNodePtr rear;
}LinkQueue;Status CreatQueue(LinkQueue &Q){
//建立一个空的链式栈
Q.front=Q.rear=(QNodePtr)malloc(sizeof(QNode));
if(!Q.front)exit(OVERFLOW);
Q.front->next=NULL;
return OK;
}Status EnQueue(LinkQueue &Q,QElemType e){ QNodePtr p;
p=(QNodePtr)malloc(sizeof(QNode));
if(!p)exit(OVERFLOW);
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}Status DeQueue(LinkQueue &Q,QElemType &e){QNodePtr p;<br>if(Q.front==Q.rear) return ERROR;<br>p=Q.front->next; e=p->data;<br>Q.front->next=p->next;<br>if(Q.rear==p) Q.rear=Q.front;<br>free(p);<br>return OK;<br>}int stackPalindrom_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0
{
printf("栈练习，请输入要判断的字符串以#作为结束符，不要超过二十个字符\n");
SqStack S;
CreatStack(S);
char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
Push(S,b[count]); //进栈
count++;
}
int i = 0;
while(i < count)
{
Pop(S,a);
if(a!=b[i])
return ERROR;
i++;
}
return OK;}//stackPalindrom_Test int queuePalindrom_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0
{
printf("队列练习，请输入要判断的字符串以#作为结束符，不要超过二十个字符\n");
LinkQueue Q;
CreatQueue(Q); char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
EnQueue(Q,b[count]);; //入列
count++;
} while(count-- > 0)
{
DeQueue(Q,a);
if(a!=b[count])
return ERROR;
}
return OK;
}//queuePalindrom_Test Status main(){ if(stackPalindrom_Test()==1)
printf("是回文\n");
else printf("不是回文\n"); if(queuePalindrom_Test()==1)
printf("是回文\n");
else printf("不是回文\n");
return OK;
}
‘肆’ 关于c语言数据结构栈与队列的问题、、求帮助
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define PRIMAX 100000 //非优先级模式下
typedef struct qnode
{
char data[10];
struct qnode *next;
int priority;//优先级，0的优先级最高，1次之，逐步优先级递减
} QNODE; /*链队结点类型*/
QNODE *front,*rear;
void InitQueue()
{
front=(QNODE *)malloc(sizeof(QNODE));
rear=front;
front->next=NULL;
front->priority = 0;//lzl add
}
void AddQueue(char x[], int prioty)
{
if (prioty<0)
{
printf(" Priority is not right! ");
return ;
}
QNODE *p=NULL;
p=(QNODE *)malloc(sizeof(QNODE));
if(p==NULL)
{
printf("内存不足");
exit(1);
}
strcpy(p->data, x);
p->next=NULL;
p->priority = prioty;
//lzl Modify begin
if (front == rear || prioty==PRIMAX)//空队列或非优先级模式
{
rear->next = p;
rear = p;
return ;
}
if (front!=rear && rear->priority <= prioty)
{
rear->next = p;
rear = p;
}
else
{
if (p->priority<front->next->priority)
{
p->next = front->next;
front->next = p;
}
else
{
QNODE *temp = front;
while (temp != NULL && (temp->priority)>=(p->priority))
{
//实际上temp值是不会等于NULL
//因为前面已对尾部节点的优先级做判断
temp = temp->next;
}
p->next = temp->next;
temp->next = p;
}
}
//lzl Modify end
}
void HeadAddQueue(char x[])
{ //在队头插入
}
int DelQueue(char x[])
{
QNODE *p;
if (front==rear)
return 0; //队空
p=front->next;
strcpy(x, p->data);
front->next=p->next;
if (p->next==NULL) //最后一个元素出队
rear=front;
free(p);
return 1;
}
int QueueEmpty()
{
if(front==rear)
return 1; //队空
else
return 0;
}
void DispQueue(int iAll)
{
QNODE *p=front->next;
int i=1;
printf(" ");
if (iAll==1)//输出队列中全部名称
{
while (p!=NULL)
{
printf("第%d位 名字%s ",i,p->data);
p=p->next;
i++;
}
printf(" ");
}
else//单个客户查找
{
char cName[10]={0};
printf(" 用户名:");
scanf("%s",cName);
while (p!=NULL && strcmp(p->data,cName)!=0 )
{
p = p->next;
i++;
}
if (p == NULL)
{
printf(" 没有找到该客户");
}
else
{
printf(" 客户信息:第%d位 名字%s",i,p->data);
}
}
}
void main()
{
char sel;
char name[10];
int priority=0;
char ch;
InitQueue(); //初始化队
while (1)
{
printf(" 1:进入排队");
printf(" 2:办理业务");
printf(" 3:查看个体");
printf(" 4:查看全部");
printf(" 0:下班");
printf(" 请选择:");
//_flushall();
fflush(stdin);
scanf("%c",&sel);
switch(sel)
{
case Ɔ':
if (!QueueEmpty()) //队不空
printf("请排队的客户明天再来 ");
return;
case Ƈ':
printf("输入客户姓名: ");
scanf("%s",name);
_flushall();
printf("是否优先？（y/n）：");
scanf("%c",&ch);
if (ch=='Y'||ch=='y')
{
//读入优先级
printf("优先级:");
scanf("%d",&priority);
AddQueue(name,priority); //入队
}
else
{
AddQueue(name,PRIMAX);
}
break;
case ƈ':
if (!DelQueue(name)) //出队
printf("没有排队的客户 ");
else
printf("请客户%s办理 ",name);
break;
case Ɖ':
case Ɗ':
if (QueueEmpty()) //队空
printf("没有排队的客户 ");
else
{
printf("排队者:");
//sel-Ɖ'值为0表示单个客户查询,值为1表示查询全部
DispQueue(sel-Ɖ');
}
break;
default:
printf("选择错误，请重新选择。 ");
break;
}
}
}
‘伍’ 栈与队列的应用（C语言）求解
#include "stdio.h"
#include "malloc.h"
typedef struct node1{
int *data;
int top;
void init(void);
void del(void);
int pop(int&);
void push(int&);
}s;
void node1::init(){
data=(int*)malloc(sizeof(int)*100);
top=0;
}
void node1::del(){
free(data);
top=0;
}
int node1::pop(int &e){
if(top==0)return 0;
e=data[--top];
return 1;
}
void node1::push(int &e){
if(top==100)return;
data[top++]=e;
}
typedef struct node2{
int *data;
int top;
int bottom;
void init(void);
void del(void);
int pop(int&);
void push(int&);
void format(s&);
}q;
void node2::init(){
data=(int*)malloc(sizeof(int)*100);
top=bottom=0;
}
void node2::del(){
free(data);
top=bottom=0;
}
int node2::pop(int &e){
if(top==bottom)return 0;
e=data[top++];
return 1;
}
void node2::push(int &e){
if(bottom==100)return;
data[bottom++]=e;
}
void node2::format(s &e){
int a;
while(e.pop(a)){
push(a);
}
}
int main(){
s b;q c;
int a;
b.init();c.init();
printf("输入栈中的数,以0结尾\n");
while(1){
scanf("%d",&a);
if(a==0)break;
b.push(a);
}
c.format(b);
while(c.pop(a)){
printf("%d\n",a);
}
b.del();
c.del();
return 0;
}//b为栈,c为队列,c.format(b)为转换函数
‘陆’ C语言中的栈、堆是什么
C语言中的堆和栈都是一种数据项按序排列的数据结构。
栈就像装数据的桶或箱子
我们先从大家比较熟悉的栈说起吧，它是一种具有后进先出性质的数据结构，也就是说后存放的先取，先存放的后取。
这就如同我们要取出放在箱子里面底下的东西（放入的比较早的物体），我们首先要移开压在它上面的物体（放入的比较晚的物体）。
堆像一棵倒过来的树
而堆就不同了，堆是一种经过排序的树形数据结构，每个结点都有一个值。
通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。
由于堆的这个特性，常用来实现优先队列，堆的存取是随意，这就如同我们在图书馆的书架上取书。
虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。
(6)c语言栈队列扩展阅读：
关于堆和栈区别的比喻
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
参考资料来源：网络-堆栈
‘柒’ ，c语言，栈队列问题，为什么要两个栈，分别是干什么用的
想象空中有两个水杯，水杯的口对着另一个水杯的口。【】 用左边的这个中括号组成的图形形容下吧，左括号是个水杯，即栈，右括号也是个水杯，也是栈。如果你想要提取队列中间的元素，是不是可以把队列中间这个元素到队首之间的所有元素压入左栈中，而把队列中间这个元素到队尾之间的所有元素压入右栈中，提取了这个元素后，再把右栈中元素压到左栈恢复成和原先顺序不变的队列呢，想想是不是很方便。~\(≧▽≦)/~
其实这个也linux shell中，通过上下按键便能调出最近的命令使用记录一样的原理
‘捌’ c语言堆栈和队列
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
以上是从数据结构角度来看，从操作系统角度来看，所有的数据结构都是对虚拟内存的操作，堆是堆，栈是栈，栈指的是C语言函数所使用的自动有函数回收的虚拟内存空间，而堆则有操作系统堆管理器来管理的那部分虚拟内存，从C语言角度来看，使用malloc函数动态分配的内存，就是堆内存。
‘玖’ C语言写 栈队列(先进先出的)
#include<stdio.h>
#include<malloc.h>typedef
struct
node
/*定义新类型结构体结点*/
{
int
data;/*数据成员可以是多个不同类型的数据*/
struct
node
*next;/*指针变量成员只能是一个*/
}NODE;/*节点结束*/typedef
struct
qnode
/*定义结点类型的变量名*/
{
NODE
*front;/*设定结点头指针变量*/
NODE
*rear;/*
设定结点尾指针变量*/
}QNODE;
/*
链队列的结点定义
*/
void
InitQueue(QNODE
*Q)/*定义指针Q*/
{
NODE
*p;/*定义指针p*/
p=(NODE
*)malloc(sizeof(NODE));/*分配结点字节的容量*/
Q->front=p;
/*指定头指针p*/
Q->front->next=NULL;/*建立空队列*/
Q->rear=Q->front;/*改变Q的值*/
printf("The
init
is
complete!");}
void
*QueuePush(QNODE
*Q)
{
NODE
*p;
p=(NODE
*)malloc(sizeof(NODE));/*分配结点字节的容量*/
printf("Please
input
a
number
:");/*请输入一个数*/
scanf("%d",&p->data);/*给第一个结点赋值*/
p->next=NULL;/*指定尾结点*/
Q->rear->next=p;/*指定尾新结点p的地址*/
Q->rear=p;/*指定队尾结束*/
printf("The
%d
has
been
pushed
into
the
Queue!",p->data);/*显示数据成员*/
return
0;/*程序结束*/
}
void
*QueuePop(QNODE
*Q)
{
NODE
*p;/*定义结点指针*/
if(Q->front->next==NULL)
return
0;/*判断对前是否为空，如果是就结束*/
p=Q->front->next;/*指向下以个成员*/
Q->front->next=p->next;/*依次向下循环*/
if(Q->rear==p)
Q->rear=Q->front;/*队尾与对头相同*/
printf("The
%d
has
been
pop
from
the
queue!
\n",p->data);/*显示队列成员*/
free(p);
return
0;
}
void
*PrintQueue(QNODE
*Q)
{
NODE
*p;/*定义链结点*/
p=Q->front->next;/*指定对头*/
while(p!=NULL)/*如不为空*/
{
printf("%5d",p->data);/*显示数据成员*/
p=p->next;/*指定第二个成员*/
}
return
0;
}
void
main()
{
QNODE
*T;
int
i=0;/*取值*/
printf("1.InitQueue
2.QueuePush
3.QueuePop
4.PrintQueue
5.Quit
\n");
while(i!=5)
{
printf("Please
choose
the
gongneng:");
scanf("%d",&i);
printf("\n");
switch(i)
{
case
1:
InitQueue(T);
printf("\n");
break;
case
2:
QueuePush(T);
printf("\n");
break;
case
3:
QueuePop(T);
printf("\n");
break;
case
4:
printf("The
queue's
numbers
are:");
PrintQueue(T);
printf("\n");
break;
case
5:
printf("\n");
break;}
}
}
‘拾’ 计算机c语言中 什么是栈和队列
栈(Stack)是仅限制在表的一端进行插入和删除运算的线性表，称插入、删除这一端为栈顶，另一端称为栈底。表中无元素时为空栈。栈 的修改是按后进先出的原则进行的，我们又称栈为LIFO表(Last In First Out)。通常栈有顺序栈和链栈两种存储结构。 栈的基本运算有六种： ·构造空栈：InitStack(S) ·判栈空: StackEmpty(S) ·判栈满： StackFull(S) ·进栈： Push(S,x) ·退栈： Pop(S) ·取栈顶元素：StackTop(S) 在顺序栈中有"上溢"和"下溢"的现象。 ·"上溢"是栈顶指针指出栈的外面是出错状态。 ·"下溢"可以表示栈为空栈,因此用来作为控制转移的条件。 顺序栈中的基本操作有六种：·构造空栈·判栈空·判栈满·进栈·退栈·取栈顶元素 链栈则没有上溢的限制，因此进栈不要判栈满。链栈不需要在头部附加头结点，只要有链表的头指针就可以了。 链栈中的基本操作有五种：·构造空栈·判栈空·进栈·退栈·取栈顶元素 队列(Queue)是一种运算受限的线性表，插入在表的一端进行，而删除在表的另一端进行，允许删除的一端称为队头(front)，允许插入的 一端称为队尾(rear) ,队列的操作原则是先进先出的，又称作FIFO表(First In First Out) 。队列也有顺序存储和链式存储两种存储结 构。 队列的基本运算有六种： ·置空队：InitQueue(Q) ·判队空：QueueEmpty(Q) ·判队满：QueueFull(Q) ·入队：EnQueue(Q,x) ·出队：DeQueue(Q) ·取队头元素：QueueFront(Q) 顺序队列的"假上溢"现象：由于头尾指针不断前移，超出向量空间。这时整个向量空间及队列是空的却产生了"上溢"现象。 为了克服"假上溢"现象引入循环向量的概念，是把向量空间形成一个头尾相接的环形，这时队列称循环队列。 判定循环队列是空还是满，方法有三种： ·一种是另设一个布尔变量来判断； ·第二种是少用一个元素空间，入队时先测试（(rear+1)%m = front）? 满：空； ·第三种就是用一个计数器记录队列中的元素的总数。 队列的链式存储结构称为链队列，一个链队列就是一个操作受限的单链表。为了便于在表尾进行插入(入队)的操作，在表尾增加一个尾指 针，一个链队列就由一个头指针和一个尾指针唯一地确定。链队列不存在队满和上溢的问题。在链队列的出队算法中，要注意当原队中只 有一个结点时，出队后要同进修改头尾指针并使队列变空。