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--;
}
② c语言实现出队入队，输入0表示出队，输入-1表示程序结束，其余整数表示入队，队列空或满，操作错误
#include<stdio.h>
#include<string.h>
#include<windows.h>
#defineMAX_STACK100
voidmain()
{
charchstr[100];
charstack[MAX_STACK];
intcur_pos=-1;
while(1)
{
system("cls");
printf("-----------------------队列操作------------------------- ");
printf("***0:POP***-1:GAMEOVER***1-9:PUSH ");
printf("Example: ");
printf("0[ENTER]-1[ENTER]1abcd[ENTER]或者2abcd[ENTER] ");
fflush(stdin);
gets(chstr);
if(chstr[0]=='-'&&chstr[1]=='1'&&strlen(chstr)==2)
break;
elseif(chstr[0]=='0'&&strlen(chstr)==1)
{
if(cur_pos==-1)
{
printf("%%error:stackempty,cannotpop! ");
continue;
}
cur_pos--;
printf("pop[%c]out ",stack[cur_pos+1]);
}
elseif(chstr[0]>='1'&&chstr[0]<='9')
{
intp=1;
while(chstr[p]!=0&&cur_pos<MAX_STACK)
{
cur_pos++;
stack[cur_pos]=chstr[p++];
printf("push[%c]in ",chstr[p-1]);
if(cur_pos==MAX_STACK-1&&chstr[p]!=0)
{
printf("%%error:cannnotpush[%c]:stackfull ",chstr[p]);
break;
}
}
}
else
printf("%%error:Unknowoperation! ");
}
}
③ C语言实现优先队列(priority queue)
堆排序是一个比较优秀的算法,堆这种数据结构在现实生活中有很多的应用,比如堆可以作为一个优先队列来使用,作为一个高效的优先队列,它与堆的结构一样,都有最大优先队列,最小优先队列.优先队列priority queue 是一种用来维护一组元素构成的集合S的数据结构，每一个元素都有一个相关的值，称为关键字（key）。
最大优先队列包含以下操作：
将元素x插入到S的集合中，等价于 ；
返回S中最大元素；
返回并且删除S中最大元含李素；
将元素x的关键字增加到key，要求 。
同样的，最小优先队列操作也包括： , , , 。只不过是对最小值进行操作。
在这里主要讨论最大优先队列，其应用很多，在共享计算机作业系统就是，类似于早期的unix主机，管理员root可以设置n个不同的用户，以及各个用户不同的操作权限，从主机那里接出多个终端，每个操作人员（程序员）在自己的工作终端 ，感觉像是自己拥有自己独立的作业主机一样，其实不是，通过一些任务调度来实现，其中就有任务等待执行相关队列，并且有各个任务有着自己优先级，以便确定调度执行具体任务，如果你学过操作系统相关知识，那么应该对系统调度有所了解。
当一个作业被完成或者被中断后，调度器会调用 来调用所有在队列中等待任务中优先级最高的任务执行，在新任务加入等待任务时会配稿调用 加入任务等待队列，当某个任务等待时间过长时可通过 提高其优先级培老孝，从而减少等待时间。
下面是具体实现C程序源码：
#include <stdio.h>
#define NAGE_INFINIT -99999
#define parent(i) i/2
#define left(i) 2*i+1
#define right(i) 2*i+2
//get array of A first element
int heap_maximum(int A[]){ return A[0];}
/***********************************************
*
* function max_heapify();
*
* args
* A[] inttype save elements of heap
* i index of A
* heap_size real length of A
*
* ********************************************/
void max_heapify(int A[],int i,int heap_size){
int l,r,largest,temp;
l=left(i);
r=right(i);
if((l<=heap_size)&&(A[l]>A[i]))
largest=l;
else
largest=i;
if((r<=heap_size)&&(A[r]>A[largest]))
largest=r;
if(largest!=i){
temp=A[i];
A[i]=A[largest];
A[largest]=temp;
max_heapify(A,largest,heap_size);
}
}
/*********************************************
*
* function heap_extract_max()
*
* args
* A[] inttype save elements of heap
* heap_size inttype the real length of A
*
* return max the parent node value
*
* ******************************************/
int heap_extract_max(int A[],int heap_size){
int max;
if(heap_size<0)
return -1; //heap underflow
max=A[0]; //parent node the max value of element
A[0]=A[heap_size];
heap_size--;
/**************************************
* dajust binary heap(or tree) to make
* sure heap fo A true every times
*
* ************************************/
max_heapify(A,0,heap_size);
return max;
}
/***********************************************
*
* function heap_increase_key();
*
* args
* A[] inttype save elemnts of heap
* i index of A
* key inserted element
*
* *********************************************/
void heap_increase_key(int A[],int i,int key){
int temp;
if(key<A[i]){
printf("new key is smaller than current key\n");
return; //over programming
}
A[i]=key;
//p=parent(i);
while ((i>0)&&(A[parent(i)]<A[i])) {
temp=A[i];
A[i]=A[parent(i)];
A[parent(i)]=temp;
i=parent(i); //update index of A
//p=parent(i);
}
}
/***************************************************
*
* function max_heap_insert();
*
* args
* A[] inttype save elements of A
* key inserted element to A
* heap_size real length of A
*
* **************************************************/
void max_heap_insert(int A[],int key,int heap_size){
heap_size+=1;
A[heap_size]=NAGE_INFINIT;
heap_increase_key(A,heap_size,key);
}
int main()
{
int heap_max,max,i,key;
int A[11],Temp[11];
int heap_size=0;
char c;
while (1) {
scanf("%d",&A[heap_size]);
c=getchar();
if(c=='\n')
break;
heap_size++;
}
// A to Temp
for(i=0;i<=heap_size;i++)
Temp[i]=A[i];
//get heap maximum element
heap_max=heap_maximum(A);
printf("heap of A maximum element: %d\n",heap_max);
// Temp to A
for(i=0;i<=heap_size;i++)
A[i]=Temp[i];
/*--extract maximum element--*/
max=heap_extract_max(A,heap_size);
printf("extract element: %d \n",max);
printf("new heap of A after extract maximum node\n");
for(i=0;i<heap_size;i++)
printf("%d ",A[i]);
printf("\n"); //next line
// Temp to A
for(i=0;i<=heap_size;i++)
A[i]=Temp[i];
/*--increase from A[i] to key--*/
printf("input i key ");
scanf("%d %d",&i,&key);
heap_increase_key(A,i,key);
for(i=0;i<=heap_size;i++)
printf("%d ",A[i]);
printf("\n");
// Temp to A
for(i=0;i<=heap_size;i++)
A[i]=Temp[i];
/*--insert queueu--*/
key=0; //init key;
printf("input key: ");
scanf("%d",&key);
max_heap_insert(A,key,heap_size);
for(i=0;i<=heap_size+1;i++)
printf("%d ",A[i]);
printf("\n");
return 0;
}
/****************************************
*
* input 16 14 10 8 7 9 3 2 4 1
* i: 8
* key: 15
*
* output in function main()
* **************************************/
其运行结果如下图：
欢迎留言交流，也感谢指正，一起进步。
④ 数据结构c语言版，出队入队及依次输出一个队列的操作。
#include<stdio.h>
#include<stdlib.h>
#defineElemTypeint
#defineStatusint
#defineOK1
#defineERROR0
typedefstructQNode{
ElemTypedata;
structQNode*next;
}QNode;
typedefstructLinkQueue{
QNode*front;
QNode*rear;
}LinkQueue;
StatusInitQueue(LinkQueue*q){//建立队列
q->front=q->rear=(QNode*)malloc(sizeof(QNode));
if(!q->front)
returnERROR;
q->front->next=NULL;
returnOK;
}
StatusEnQueue(LinkQueue*q,ElemTypee){//入队
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p->data=e;
p->next=NULL;
q->rear->next=p;//入队操作，从队尾(rear)进入
q->rear=p;
returnOK;
}
StatusDeQueue(LinkQueue*q,ElemType*e){//出队
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p=q->front->next;//q指向的是front指针的下一个位置，亦即队首元素
*e=p->data;
q->front->next=p->next;//出队操作后，front++
if(q->rear==p)//判断是否全部出队
q->rear=q->front;//如果全部出队，则将队列置为空
returnOK;
}
StatusPrintfQueue(LinkQueue*Q){
QNode*p;
for(p=Q->front->next;p!=NULL;p=p->next)
printf("%d ",p->data);
}
intmain(void)
{
inti,n;
ElemTypee,de;
LinkQueue*q=(LinkQueue*)malloc(sizeof(QNode));
if(!q)
returnERROR;
InitQueue(q);
printf("以下开始构造初始队列: ");
printf("请输入元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i){
printf("请输入第%d个元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf(" ");
printf("初始队列构造完毕！ ");
printf("初始队列： ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
printf("以下开始执行入队操作: ");
printf("请输入需入队的元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i){
printf("请输入第%d个元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf(" ");
printf("入队%d个元素操作完毕！ ",n);
printf("此时队列: ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
printf("以下开始执行出队操作: ");
printf("请输入需出队的元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i)
DeQueue(q,&de);
printf(" ");
printf("出队%d个元素操作完毕！ ",n);
printf("此时队列: ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
free(q);
return0;
}
执行结果
⑤ C语言中，队列是什么意思，有什么用途
队列是一种特殊的线性表。
队列一种可以实现“先进先出”的存储结构，即“一端入，一端出”，队首(front)出队，队尾(rear)入队，若front指向队首，则rear指向队尾最后一个有效元素的下一个元素；若rear指向队尾，则front指向队首第一个有效元素的下一个元素。
队列特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
(5)c语言出队列扩展阅读
循环队列各个参数的含义
1、队列初始化front和rear的值都是零,初始化时队列就是空的。
2、队列非空front代表队列的第一个元素rear代表了最后一个有效元素的下一个元素。
3、队列空front和rear的值相等，但是不一定是零。
⑥ 数据结构（使用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);
}
⑦ 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];