c语言队列库
A. 数据结构（使用c语言）队列
对顺序循环队列，常规的设计方法是使用队尾指针和队头指针，队尾指针用于指出当前胡队尾位置下标，队头指针用于指示当前队头位置下标。现要求：
（1）设计一个使用队头指针和计数器胡顺序循环循环队列抽象数据类型，其中包括：初始化，入队列，出队列，取队头元素肯判断队列是否非空；
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"conio.h"
#defineMAX80
typedefstruct
{
intdata[MAX];
intfront,rear;
intnum;
}SeQue;
SeQue*Init_SeQue()
{
SeQue*s;
s=newSeQue;
s->front=s->rear=MAX-1;
s->num=0;
returns;
}
intEmpty_SeQue(SeQue*s)
{
if(s->num==0)
return1;
else
return0;
}
intIn_SeQue(SeQue*s,intx)
{
if(s->num==MAX)
return0;
else
{
s->rear=(s->rear+1)%MAX;
s->data[s->rear]=x;
s->num++;
return1;
}
}
intOut_SeQue(SeQue*s,int*x)
{
if(Empty_SeQue(s))
return0;
else
{
s->front=(s->front+1)%MAX;
*x=s->data[s->front];
s->num--;
return1;
}
}
voidPrint_SeQue(SeQue*s)
{
inti,n;
i=(s->front+1)%MAX;
n=s->num;
while(n>0)
{printf("%d",s->data[i]);
i=(i+1)%MAX;
n--;
}
}
voidmain()
{
SeQue*s;
intk,flag,x;
s=Init_SeQue();
do{
printf("\");
printf("\t\t\t循环顺序队列");
printf("\t\t\t***********************");
printf("\t\t\t**1-入队**");
printf("\t\t\t**2-出队**");
printf("\t\t\t**3-判队空**");
printf("\t\t\t**4-队列显示**");
printf("\t\t\t**0-返回**");
printf("\t\t\t***********************");
printf("\t\t\t请输入菜单项(0-4):");
scanf("%d",&k);
switch(k)
{
case1:
printf("请输入入队元素:");
scanf("%d",&x);
flag=In_SeQue(s,x);
if(flag==0)
printf("队满不能入队!按任意键返回..");
else
printf("元素已入队!按任意键返回..");
getch();
system("cls");
break;
case2:
flag=Out_SeQue(s,&x);
if(flag==0)
printf("队列空出队失败!按任意键返回..");
else
printf("队列头元素已出队~!按任意键返回..");
getch();
system("cls");
break;
case3:
flag=Empty_SeQue(s);
if(flag==1)
printf("该队列为空!按任意键返回..");
else
printf("该队列不为空!按任意键返回..");
getch();
system("cls");
break;
case4:
printf("该队列元素为:");
Print_SeQue(s);
printf("按任意键返回..");
getch();
system("cls");
break;
}
}while(k!=0);
}
B. C语言中，队列是什么意思，有什么用途
队列是一种特殊的线性表。
队列一种可以实现“先进先出”的存储结构，即“一端入，一端出”，队首(front)出队，队尾(rear)入队，若front指向队首，则rear指向队尾最后一个有效元素的下一个元素；若rear指向队尾，则front指向队首第一个有效元素的下一个元素。
队列特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
(2)c语言队列库扩展阅读
循环队列各个参数的含义
1、队列初始化front和rear的值都是零,初始化时队列就是空的。
2、队列非空front代表队列的第一个元素rear代表了最后一个有效元素的下一个元素。
3、队列空front和rear的值相等，但是不一定是零。
C. C语言中使用队列
如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是当你用的c++的STL，STL中没有真正的队列和栈，他们都是通过对双端队列的改造得到的，所以包含的文件可能和你想的不一样。而且这些头文件都没有.h结尾！很特别
如果你不是vc，当我没说
D. C语言的队列如何实现和表示
我能想到的有两种方法（假设队列元素都是int）
一，用链表的方法
struct A
{
int n;
struct A *a;
} *p,*head,*rear;
head=rear=NULL；/*头指针，尾指针*/
添加元素：p=(struct A*)malloc(sizeof(struct A));......给新元素赋值.....;rear->a=p;rear=p;
当然添加第一个元素的时候要给head赋值。
删除元素：p=head;head=head->a;free(p);
用的是单向链表，当然也可以用双向链表，不过删除，添加元素的过程要麻烦点。
二，利用数组，当然也可以开辟动态储存空间
int a[N]，*head,*rear; N就是个常数
head=rear=a;
添加元素：scanf("%d",rear-a==N?rear=a:++rear);
删除元素：head-a==N?head=a:head++;
当然要检查队列是否溢出，可以设变量n=0;
每次添加元素n++
每次删除元素n--
当n<0后n>N数据溢出
E. c语言调用队列库函数
q.push(m); // queue是C++STL模板库的东西，需要使用push来插入元素，详细信息你可以参考MSDN来了解其使用及内容。
F. C语言中队列怎样创建
队列是一种特殊的链表,在你写GET和PUT方法时只需要返回链表的第一个值,把你要输的值放链表的最后就是队列了!!!
G. c语言库函数queue可以定义string类队列吗，如图是我的代码，编译后显示有错误，如何修改
可以定义
不过q还是queue类型
所以 q和"END"比较肯定是不行的
你可以试试
q.top()!="END"
也就是queue的元素
H. c语言队列操作
pq->rear->next
=
pnew这个代码从队列的尾部增加新节点，
然后pq->rear
=
pnew更新队列尾部指针。队列的数据结构形式就是由一个头front指针，一个尾rear指针来表征，items的设计是用空间换时间，涉及队列大小的操作会非常方便。
队列的特征是先进先出，你给出的链式实现，其实就跟一个链表一样，链表的添加删除如果能理解了，队列只是链表的元素增加/删除
按先进先出特点的一种实现。
但对于队列来说，实现方式不是重点，先进先出的性质才是重点，这在实际应用中很多，比如排队叫号。
I. 用C语言编写队列程序
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define NULL 0
#define OK 1
#define OVERFLOW 0
#define ERROR 0
typedef int QElemType;
typedef int Status;
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear;//队头，队尾指针
};
//函数列表
void InitQueue(LinkQueue &Q)
{//初始化一个队列
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front)//生成头结点失败
exit(OVERFLOW);
Q.front->next=NULL;
}
void DestoryQueue(LinkQueue &Q)
{ //销毁队列
while(Q.front)
{
Q.rear=Q.front->next;//Q.rear指向Q.front的下一个结点
free(Q.front);//释放Q.front所指结点
Q.front=Q.rear;//Q.front指向Q.front的下一个结点
}
}
void ClearQueue(LinkQueue &Q)
{ //将队列清为空
DestoryQueue(Q);//销毁队列
InitQueue(Q);//重新构造队列
}
Status QueueEmpty(LinkQueue Q)
{ //判断队列是否为空
if(Q.front->next==NULL)
return TRUE;
else return FALSE;
}
int QueueLength(LinkQueue Q)
{ //求队列的长度
int i=0;//计数器清0
QueuePtr p=Q.front;//p指向结点
while(Q.rear!=p)//p所指向的不是尾结点
{
i++;//计数器加1
p=p->next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType &e)
{ //若队列不空，则用e返回队头元素
QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front->next;//p指向队头结点
e=p->data;//将队头元素的值赋给e
return OK;
}
void EnQueue(LinkQueue &Q,QElemType e)
{ //插入元素e为队列Q的新的队尾元素
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
//动态生成新结点
if(!p)
exit(OVERFLOW);
p->data=e;//将e的值赋给新结点
p->next=NULL;//新结点的指针为空
Q.rear->next=p;//原队尾结点的指针域为指向新结点
Q.rear=p;//尾指针指向新结点
}
Status DeQueue(LinkQueue &Q,QElemType &e)
{ //若队列不为空，删除Q的队头元素，用e返回其值
QueuePtr p;
if(Q.front==Q.rear)//队列为空
return ERROR;
p=Q.front->next;//p指向队头结点
e=p->data;//队头元素赋给e
Q.front->next=p->next;//头结点指向下一个结点
if(Q.rear==p)//如果删除的队尾结点
Q.rear=Q.front;//修改队尾指针指向头结点
free(p);
return OK;
}
void QueueTraverse(LinkQueue Q,void(*visit)(QElemType))
{ //对队头到队尾依次对队列中每个元素调用函数visit()
QueuePtr p;
p=Q.front->next;
while(p)
{
visit(p->data);//对p所指元素调用visit()
p=p->next;
}
printf("\n");
}
void print(QElemType e)
{
printf("%2d",e);
}
void main()
{
int i,k;
QElemType d;
LinkQueue q;
InitQueue(q);//构造一个空栈
for(i=1;i<=5;i++)
{
EnQueue(q,i);
}
printf("栈的元素为:");
QueueTraverse(q,print);
k=QueueEmpty(q);
printf("判断栈是否为空,k=%d(1:为空9;0:不为空)\n",k);
printf("将队头元素赋给d\n");
k=GetHead(q,d);
printf("队头元素为d=%d\n",d);
printf("删除队头元素:\n");
DeQueue(q,d);
k=GetHead(q,d);
printf("删除后新的队头元素为d=%d\n",d);
printf("此时队列的长度为%d\n",QueueLength(q));
ClearQueue(q);//清空队列
printf("清空队列后q.front=%u,q.rear=%u,q.front->next=%u\n",q.front,q.rear,q.front->next);
DestoryQueue(q);
printf("销毁队列后,q.front=%u,q.rear=%u\n",q.front,q.rear);