队列数组c语言实现

1. 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，这个数位杨辉三角的行数上面是用循环队列做的，你看看

2. C语言用数组实现顺序队列求大神帮助

#include "stdio.h" main() { int que[200] = {0} ; int start = 0, end = 0; int i; char ch; printf("please enter 6 num:"); for(i=0;i<6;i++) scanf("%d",&que[i]); end = 5; for(i=start;i<=end;i++) printf("%d ",que[i]); printf("\n"); while(1) { printf("What do you want to do? \n'i' to insert\n'd' to delete\n'q' to quit\n"); switch(ch = getch()) { case 'i': end++; printf("please enter the num:"); scanf("%d",&que[end]); for(i=start;i<=end;i++) printf("%d ",que[i]); printf("\n"); break; case 'd': start++; for(i=start;i<=end;i++) printf("%d ",que[i]); printf("\n"); break; case 'q': exit(0); } } }

3. 数组实现队列

#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
typedef struct
{
int first;//fist保存了数组第一个元素的索引。
int last;//last保存了数组最后一个元素的索引的下一个位置。
int max_size;//max_size成员保存了数组的总大小
long* ele;//保存了数组的首地址
} Queue;
bool InQueue(Queue *que,long element)
{
if(que->last-que->first>=que->max_size)//空间不够
{
que->max_size+=10;
long *temp=(long*)malloc(sizeof(long)*(que->max_size));
if(temp)
{
if(que->ele)
{
memcpy(temp,que->ele,que->max_size);
free(que->ele);
}
que->ele=temp;
return InQueue(que,element);
}
return false;
}
else if(que->last<que->max_size)//尾部有空间
{
que->ele[que->last++]=element;
return true;
}
else if(que->first>=1)//首部有空间
{
for(int i=que->first-1;i<que->last-1;i++)
{
que->ele[i]=que->ele[i+1];
}
que->last--;
return InQueue(que,element);
}
return false;
}
bool QuitQueue(Queue *que,long *x)
{
if(que->last>que->first)
{
*x=que->ele[que->first];
que->first++;
return true;
}
return false;
}
bool GetTop(Queue*que,long *x)
{
if(que->last>que->first)
{
*x=que->ele[que->first];
return true;
}
return false;
}
void ClearQueue(Queue *que)
{
que->first=que->last=0;
que->max_size=0;
free(que->ele);
}
int main()
{
Queue que={0};
InQueue(&que,10);
long x;
GetTop(&que,&x);
printf("%d",x);

}

4. 用C语言编写队列的各种基本操作，我不是非常明白：注释里有些问题：请大家讲讲，如果可能，请详细讲讲各种

ont）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 在队列这种数据结构中，最先插入在元素将是最先被删除；反之最后插入的元素将最后被删除，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。 队列空的条件：front=rear 队列满的条件： rear = MAXSIZE 队列可以用数组Q[1…m]来存储，数组的上界m即是队列所容许的最大容量。在队列的运算中需设两个指针：head，队头指针，指向实际队头元素的前一个位置；tail，队尾指针，指向实际队尾元素所在的位置。一般情况下，两个指针的初值设为0，这时队列为空，没有元素。图1 ( a)画出了一个由6个元素构成的队列，数组定义Q[1…10]。Q(i) i=3,4,5,6,7,8头指针head＝2，尾指针tail＝8。队列中拥有的元素个数为:L=tail-head现要让排头的元素出队，则需将头指针加1。即head=head+1这时头指针向上移动一个位置，指向Q(3)，表示Q(3)已出队。见图1 (b)。如果想让一个新元素入队，则需尾指针向上移动一个位置。即tail=tail+1这时Q(9)入队，见图1 (c)。当队尾已经处理在最上面时，即tail=10，如果还要执行入队操作，则要发生"上溢"，但实际上队列中还有三个空位置，所以这种溢出称为"假溢出"。 克服假溢出的方法有两种。一种是将队列中的所有元素均向低地址区移动，显然这种方法是很浪费时间的；另一种方法是将数组存储区看成是一个首尾相接的环形区域。当存放到n地址后，下一个地址就"翻转"为1。在结构上采用这种技巧来存储的队列称为循环队列。 队列和栈一样只允许在断点处插入和删除元素。 循环队的入队算法如下： 1、tail=tail+1； 2、若tail=n+1，则tail=1； 3、若head=tail尾指针与头指针重合了，表示元素已装满队列，则作上溢出错处理； 4、否则，Q(tail)=X，结束（X为新入出元素）。 队列和栈一样，有着非常广泛的应用。

具体网上查:

另外,虚机团上产品团购,超级便宜

5. C语言数组 队列

intpoint[2][10]={0};
voidaddline(x,y)
{
inti;
for(i=0;i<10;i++)
if(point[1][i]==0&&point[2][i]==0)
break;
if(i<10)
{
point[1][i]=x;
point[2][i]=y;
}
else
{
for(i=0;i<9;i++)
{
point[1][i]=point[1][i+1];
point[2][i]=point[2][i+1];
｝
point[1][9]=x;
point[2][9]=y;
}
}

存进去的坐标不能是0，0

6. C语言，用数组实现队列的入队，出队函数编程

这样的话应该符合你的要求：

#include<stdio.h>
voidadd(intqueue[],intx);
intTop(intqueue[]);
voiddel(intqueue[]);
intend=0;
intmain()
{
intn;
scanf("%d",&n);//将要入队列n个元素
intqueue[1000];
for(inti=1;i<=n;i++)//输入n个元素
{
add(queue,i);//将i加入队列
}
//验证加入队列的元素，将队列中的元素按照输入的顺序输出：
for(i=1;i<=n;i++)
{
printf("%d",Top(queue));//Top函数返回队头元素
del(queue);//删除队头元素
}
//验证输出已经出队列后的队列（数组）元素：
printf("
");
for(i=1;i<=n;i++)
printf("%d",queue[i]);
printf("
");
return0;
}
voidadd(intqueue[],intx)
{
queue[++end]=x;
}
intTop(intqueue[])
{
returnqueue[1];//注意，这里的函数始终returnqueue[1];这里是和将普通数组中的元素输出最大的不同之处。！！！！！！
}
voiddel(intqueue[])
{
for(inti=2;i<=end;i++)
{
queue[i-1]=queue[i];
}
queue[end]=0;//将删除后的地方置0
end--;
}

7. c语言循环队列

队列是一种特殊的线性表，循环队列是将向量空间想象为一个首尾相接的圆环。

队列是一个特殊的线性表，它的特殊之处在于它只允许表的前面的操作删除，而在表的后面的操作插入，就像堆栈一样，队列100是一个线性表，具有有限的操作。

循环队列就是把向量空间想象成一个首尾相连的环，把这样的向量称为循环向量。存储学位的队列称为循环队列。

在顺序队列中，当指向队列末端的指针到达数组的上界时，不能有更多的队列条目，但数组中仍然有一个空位置。这称为“假溢出”。

(7)队列数组c语言实现扩展阅读：

判断满队列状态：

1．计数；你通常使用count

Count等于队列的MAXSIZE

2．国旗int

Queueinflag＝1Queueoutflag＝0

= && flag = = 0的前面和后面

3．放一个存储应答单元为空，不存储数据

后面＋1＝前面

注：（不）顺序结构，SeqQueuemyQueue；

8. 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数据溢出

9. 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];

10. 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;
}