1. c语言中循环队列的队满和队空的判断条件各是什么有什么不同
队空时： Q.front == Q.rear;
队满时： Q.front == (Q.rear + 1) % MAXSIZE;
front指向队首元素，rear指向队尾元素的下一个元素。
maxsize是队列长度。
(1)c语言循环队列扩展阅读：
实现的代码：
#include <stdio.h>
#include <malloc.h>
#define MAXSIZE 100 //最大队列长度
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
typedef struct {
ElemType *base; //队列空间
int front; //队头指针
int rear; //队尾指针，若队尾不为空，则指向队尾元素的下一个位置
}SqQueue;
//初始化循环队列
Status initQueue(SqQueue &Q) {
Q.base = (ElemType *) malloc(MAXSIZE * sizeof(ElemType)); //申请空间
Q.front = Q.rear = 0; //队空
return OK;
}
//入队
Status enQueue(SqQueue &Q, ElemType e) {
if ((Q.rear + 1) % MAXSIZE == Q.front) return ERROR; //队满，无法添加
Q.base[Q.rear] = e; //插入元素
Q.rear = (Q.rear + 1) % MAXSIZE; //队尾指针+1
return OK;
}
//出队
Status deQueue(SqQueue &Q, ElemType &e) {
if (Q.front == Q.rear) return ERROR; //队空，无法删除
e = Q.base[Q.front]
Q.front = (Q.front + 1) % MAXSIZE; //队头指针+1
return OK;
}
//返回队列长度
Status length(SqQueue &Q) {
return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}
2. C语言循环队列
简单的程序,先构造一个循环链表，包括N个缓寸区和一个额外的区域（便于队列的操作）．
输入1时，消费者输出．
输入其他数字时，生成者输入．
#include <stdio.h>
#define N 10
struct queue
{
int data;
queue *front;
};
int main()
{
int i, choice;
queue *head;
queue *tail;
queue *temp;
head = tail = new queue;
temp = new queue;
temp->front = head;
tail->front = temp;
for(i=1; i<N; i++)
{
temp->front = new queue;
temp = temp->front;
temp->front = head;
}
tail = temp;
while(true)
{
scanf("%d", &choice);
if(choice == 1) //consumer
{
if(head == tail->front) break;
printf("消费：%d\n", head->data);
head = head->front;
}
else //proctor
{
if(tail->front->front == head) break;
printf("生产：\n");
scanf("%d", &tail->front->data);
tail = tail->front;
}
}
return 0;
}
3. C语言这道题循环队列元素个数怎么算
应该是：Q->front=(Q->front+1)%QueueSize循环队列的设计思路是：设想向量Q->data[QueueSize]是一个首尾相接的圆环，即Q->data[0]接在Q->data[QueueSize-1]之后，这种意义下的向量称为循环向量，并将循环向量中的队列称为循环队列。针对你这道题，QueueSize为10，所以数组最大下标为9,则array[9]的下一个元素为array[0]来实现循环。举个例子来说吧，出队操作，在循环意义下头指针加1，如果Q->front现在为9(即指向下标为9的元素)，则(Q->front+1)%10为（9+1）%10结果为0,所以代表出队后Q->front为0(即指向下标为0的元素)，从而实现循环。
4. C语言用数组实现循环队列的入队出队
//定义一个int型数组que,长度为N(常量切大于2).
intque[N];
intrear=0,front=0;//队尾队头
判断队列已满：
if((front+1)%N==rear%N)//成立则队列已满
判断队列为空
if((rear==front))//成立则队列空
入队(一般在入队前判断队列是否已满)
//将val入队
que[front++]=val;
front%=N;
出队(一般在出队前判断队列是否为空)
rear=(rear+1)%N;
下一个要出队的元素(一般先判断是否为空)
que[rear];
5. C语言中循环队列中的元素是怎么计算的
开始、结束的地址
~~~~~
6. c语言循环队列的错误修改
函数visit定义时形参char（q.base)不可用，改成一个指针char *a即可；
main函数里：第一个for循环结束后第二行：queuetraverse_sq(q, int(*e));
e不能做queuetraverse_sq（这个函数名太长了....我后面写函数1好吧）的实参。函数1的形参2是一个指向函数的指针。实际上函数1不需要第二个参数，在定义的时候直接写queuestraverse_sq(sqqueue q){/*....*/}就可以了。
最后把所有函数1的第二参数都删掉就行了。
7. C语言，请用数组作个循环队列
a#include
"Stdio.h"
#include
<stdlib.h>
#include
"Conio.h"
#include
"malloc.h"
#define
TRUE
1
#define
FALSE
0
#define
INFEASIBLE
1
#define
OVERFLOW
-2
#define
OK
1
#define
ERROR
0
#define
MAXQSEZE
100
/*最大队列长度*/
typedef
int
QElemType;
typedef
int
Status;
typedef
struct{
QElemType
*base;
/*初始化的动态分配存储空间*/
int
front;
/*头指针，若队列不空，指向队列头元素*/
int
rear;
/*尾指针，若队列不空，指向队列尾元素的下一位置*/
}SqQueue;
Status
Queuelength(SqQueue
*Q){
/*构造一个空的循环队列*/
Q->base=(QElemType
*)malloc(MAXQSEZE*sizeof(SqQueue));
if(!Q->base)
exit(OVERFLOW);
/*存储分配失败*/
Q->front=Q->rear=0;
return
OK;
}
Status
EnQueue(SqQueue
*Q,QElemType
e){
/*插入元素e为Q的新的队尾元素*/
if((Q->rear+1)%MAXQSEZE==Q->front)
return
ERROR;/*队列满*/
Q->base[Q->rear]=e;
Q->rear=(Q->rear+1)%MAXQSEZE;
return
OK;
}
Status
DeQueue(SqQueue
*Q,QElemType
*e){
/*若队列不空，则删除Q的队头元素，用e返回其值*/
/*否则返回ERROR*/
if(Q->front==Q->rear)
return
ERROR;
*e=Q->base[Q->front];
Q->front=(Q->front+1)%MAXQSEZE;
return
OK;
}
Status
GetHead(SqQueue
*Q,QElemType
*e){
/*队列不为空用e返回Q的头元素，并返回OK，否则返回ERROR*/
if(Q->front==Q->rear)
return
ERROR;
*e=Q->base[Q->front];
return
OK;
}
Status
QueueEmpty(SqQueue
*Q){
/*队列为空时返回OK否则返回FALSE*/
if(Q->front==Q->rear)
return
OK;
return
FALSE;
}
void
yanghuiTriangle(int
n){
/*打印输出杨辉三角的钱n(n>0)行*/
SqQueue
Q;
char
ch='
';
int
i,k;
QElemType
s,e;
FILE
*fq;
if((fq=fopen("output.txt","w"))==NULL){
/*打开写入文件*/
printf("error
on
open\n");
exit
(1);
}
Queuelength(&Q);
/*创建空的队列*/
for(i=1;i<n;i++)
{
printf("
");
fputc(ch,fq);}
/*输出n个空格以保持三角形的队形*/
printf("1\n");
fprintf(fq,"%d\n",1);
EnQueue(&Q,0);
/*添加第一行末尾的行分界0并入队*/
EnQueue(&Q,1);
/*第二行的两个1值入队列*/
EnQueue(&Q,1);
k=2;
while(k<n){
/*通过循环队列输出第2行到第n-1行的值*/
for(i=1;i<=n-k;i++)
{printf("
");
fputc(ch,fq);}
/*输出n-k个空格以保持三角形*/
EnQueue(&Q,0);
do{
/*输出第k行，计算第k+1行*/
DeQueue(&Q,&s);
GetHead(&Q,&e);
if(e)
/*若e为非行分界值0，则打印输出e的值,并加一空格*/
{printf("%d
",e);
fprintf(fq,"%d%c",e,ch);
}
else
{
printf("\n");
fputc('\n',fq);}
/*回车换行，为下一行输出做准备*/
EnQueue(&Q,s+e);
/*计算所得抵k+1行的值入队列*/
}while(e!=0);
k++;
}
DeQueue(&Q,&e);
/*行界值“0“出队列*/
while(!QueueEmpty(&Q)){
/*单独处理第n行的值的输出*/
DeQueue(&Q,&e);
{
printf("%d
",e);
fprintf(fq,"%d%c",e,ch);
}
}
}
int
main(void)
{
FILE
*
fp;
QElemType
n;
if((fp=fopen("input.txt","r"))==NULL){
/*打开写入文件*/
printf("error
on
open\n");
exit
(1);
}
fscanf(fp,"%d",&n);
/*读入n*/
fclose(fp);
yanghuiTriangle(n);
getch();
return
0;
}
用一个文件输入一个N，这个数位杨辉三角的行数上面是用循环队列做的，你看看
8. 数据结构循环队列（C语言实现）
这是约瑟夫问题，参见
http://ke..com/link?url=T1pJ7-
9. c语言循环队列
队列是一种特殊的线性表，循环队列是将向量空间想象为一个首尾相接的圆环。
队列是一个特殊的线性表，它的特殊之处在于它只允许表的前面的操作删除，而在表的后面的操作插入，就像堆栈一样，队列100是一个线性表，具有有限的操作。
循环队列就是把向量空间想象成一个首尾相连的环，把这样的向量称为循环向量。存储学位的队列称为循环队列。
在顺序队列中，当指向队列末端的指针到达数组的上界时，不能有更多的队列条目，但数组中仍然有一个空位置。这称为“假溢出”。
(9)c语言循环队列扩展阅读：
判断满队列状态：
1．计数；你通常使用count
Count等于队列的MAXSIZE
2．国旗int
Queueinflag＝1Queueoutflag＝0
= && flag = = 0的前面和后面
3．放一个存储应答单元为空，不存储数据
后面＋1＝前面
注：（不）顺序结构，SeqQueuemyQueue；
10. 二级c语言，队列、循环队列是什么
队列是一种特殊的线性表，循环队列是将向量空间想象为一个首尾相接的圆环。
1、队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。
2、循环队列是将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列。在顺序队列中，当队尾指针已经到数组的上界，不能再有入队操作，但其实数组中还有空位置，这就叫做“假溢出”，解决假溢出的途径----采用循环队列。
(10)c语言循环队列扩展阅读
判断队列满的情况：
1、count来计数；通常使用count
Count等于队列的MAXSIZE
2、Flag标志 int
入队列 flag=1 出队列flag=0
Front=rear&&flag==0
3、把一个存储单元空出来，不存放数据
Rear+1==front
注意事项：（不要） 顺序结构，SeqQueue myQueue；