C语言入队出队功能函数,队列入队函数

数据结构c语言版，出队入队及依次输出一个队列的操作。

#include stdio.h

成都创新互联公司专注于汪清企业网站建设,自适应网站建设,成都做商城网站。汪清网站建设公司,为汪清等地区提供建站服务。全流程按需定制制作，专业设计，全程项目跟踪，成都创新互联公司专业和态度为您提供的服务

#include stdlib.h

#define ElemType int 

#define Status int

#define OK 1

#define ERROR 0

typedef struct QNode{

ElemType data;

struct QNode *next;

}QNode;

typedef struct LinkQueue{

QNode *front;

QNode *rear;

}LinkQueue;

Status InitQueue(LinkQueue *q) { //建立队列 

q-front=q-rear=(QNode *)malloc(sizeof(QNode));

if(!q-front)

return ERROR;

q-front-next=NULL;

return OK;

}

Status EnQueue(LinkQueue *q,ElemType e) { //入队 

QNode *p=(QNode *)malloc(sizeof(QNode));

if(!p)

return ERROR;

p-data=e;

p-next=NULL;

q-rear-next=p; //入队操作，从队尾(rear)进入

q-rear=p;

return OK;

}

Status DeQueue(LinkQueue *q,ElemType *e) { //出队 

QNode *p=(QNode *)malloc(sizeof(QNode));

if(!p)

return ERROR;

p=q-front-next; //q指向的是front指针的下一个位置，亦即队首元素 

*e=p-data;

q-front-next=p-next; //出队操作后，front++

if(q-rear==p) //判断是否全部出队

q-rear=q-front; //如果全部出队，则将队列置为空

return OK;

}

Status PrintfQueue(LinkQueue *Q) {

QNode *p;

for(p=Q-front-next;p!=NULL;p=p-next)

printf("%d\t",p-data);

}

int main(void)

{

int i,n;

ElemType e,de;

LinkQueue *q=(LinkQueue *)malloc(sizeof(QNode));

if(!q)

return ERROR;

InitQueue(q);

printf("以下开始构造初始队列:\n\n");

printf("请输入元素个数：");

scanf("%d",n);

printf("\n");

for(i=0;in;++i) {

printf("请输入第%d个元素：",i+1);

scanf("%d",e);

EnQueue(q,e);

}

printf("\n");

printf ("初始队列构造完毕！\n\n");

printf ("初始队列：\n");

PrintfQueue(q);

printf("\n\n");

printf ("======================================================\n\n");

printf("以下开始执行入队操作:\n\n");

printf("请输入需入队的元素个数：");

scanf("%d",n);

printf("\n");

for(i=0;in;++i) {

printf("请输入第%d个元素：",i+1);

scanf("%d",e);

EnQueue(q,e);

}

printf("\n");

printf ("入队%d个元素操作完毕！\n\n",n);

printf("此时队列:\n");

PrintfQueue(q);

printf("\n\n");

printf ("======================================================\n\n");

printf("以下开始执行出队操作:\n\n");

printf("请输入需出队的元素个数：");

scanf("%d",n);

printf("\n");

for(i=0;in;++i)

DeQueue(q,de);

printf("\n");

printf ("出队%d个元素操作完毕！\n\n",n);

printf("此时队列:\n");

PrintfQueue(q);

printf("\n\n");

printf ("======================================================\n\n");

free(q);

return 0;

}

执行结果

C语言用数组实现循环队列的入队出队

//定义一个int型数组que,长度为N(常量切大于2).

int que[N];

int rear=0,front=0; //队尾 队头

判断队列已满：

if((front+1)%N==rear%N)  //成立则队列已满

判断队列为空

if((rear==front)) //成立则队列空

入队(一般在入队前判断队列是否已满)

//将val入队

que[front++]=val;

front%=N;

出队(一般在出队前判断队列是否为空)

rear=(rear+1)%N;

下一个要出队的元素(一般先判断是否为空)

que[rear];

c语言入栈出栈，出队入队问题

int pop(seqstack *s,char *x) {

if(s-top == 0) { // 初始化时，s-top = -1，此处以s-top == 0 判断栈为空，有矛盾

printf("栈空\n");

return -1;

}

else {

*x = s-c[s-top];

s-top--;

}

return 1;

}

通常，top指的位置是待压入的空结点，所以top == 0时，栈为空，top == MAXSIZE时，栈满，故应该修改初始化函数，建议蟹盖如下:

seqstack *Initstack(void) {

seqstack *s;

s = (seqstack *)malloc(sizeof(seqstack));

s-top = 0;

return s;

}

用c语言编写12345的入队，然后出队

#include "stdafx.h"

#include "stdio.h"

#include "malloc.h"

#define MAX 8

static int Queen[8][8];

static int a=1;

typedef struct

{

int *elem;

int top;

}ColStack;//栈：存放每一行放置皇后的列号

void InitQueen()

{

int i,j;

for(i = 0; i 8; i++)

{

for(j = 0; j 8; j++)

{

Queen[i][j] = 0;

}

}

}

int InitStack(ColStack CS)//初始化栈

{

CS.elem = (int *)malloc(MAX*sizeof(int));

if(!CS.elem) return 0;

CS.top = -1;

return 1;

}

int Push(ColStack CS, int e)//进栈

{

if(CS.top = 8) return 0;

CS.top++;

CS.elem[CS.top] = e;

return 1;

}

int Pop(ColStack CS, int e)//退栈

{

if(CS.top == -1)return 0;

e = CS.elem[CS.top];

CS.top--;

return 1;

}

int Back(ColStack CS,int e)//回溯

{

Pop(CS,e);

Queen[CS.top+1][e] = 0;

if(e == 7 CS.top == -1)

{

return 0;

}

if(e == 7 CS.top != -1)

{

Back(CS,e);

}

return 1;

}

int OK(int i, int j)//检查(i,j)上能否放棋子

{

int k, m;

for(k = i; k = 0; k--)//检查同列

{

if(Queen[k][j] == 1) return 0;

}

k = i; m = j;

while(k = 0 m = 0)

{

if(Queen[k][m] == 1) return 0;

k--; m--;

}

k = i; m = j;

while(k = 0 m 8)

{

if(Queen[k][m] == 1) return 0;

k--;m++;

}

return 1;

}

//进入本函数时，在8*8棋盘前i-1行已放置了互不攻

// 击的i-1个棋子。现从第 i 行起继续为后续棋子选择

// 满足约束条件的位置。当求得(i8)的一个合法布局

// 时，输出之。

int queen(int i, ColStack CS, int start)

{

int j, k,e;

if(i=8)

{

printf("第%d种情况：\n",a);

for(j = 0; j 8; j++)

{

for(k = 0; k 8; k++)

{

if(Queen[j][k] == 0)

{

printf("# ");

}

else

{

printf("@ ");

}

}

printf("\n");

}

a++;

}else

{

for(j = start+1; j 8; j++)

{

if(OK(i,j) == 1)

{

Queen[i][j]=1;

Push(CS,j);

queen(i+1,CS,-1);

return 1;

}

}

}

if(j == 8)

{

if(Back(CS,e) == 1)

{

queen(CS.top+1,CS,e);

}

if(Back(CS,e) == 0)

{

return 1;

}

}

}

int main()

{

InitQueen();

ColStack cs;

InitStack(cs);

queen(0,cs,-1);

return 0;

}

这是一个八皇后问题，是个典型的出队列、入队列问题

在循环队列中怎样实现入队和出队操作? 数据结构 C语言

入队操作

功能：将元素 x 插入到Q的队尾。

算法：Status EnQueue(SqQueue Q, QElemType e) {

if ((Q.rear+1) % MaxQsize == Q.front) return ERROR; // 队列满

Q.base[Q.rear]=e;

Q.rear=(Q.rear+1) % MaxQsize;

return OK;

}

出队操作

功能：删除Q的队头元素，并返回其值。

算法： Status DeQueue(SqQueue Q, QElemType e) {

if (Q.front == Q. rear) return ERROR; // 队列空

e = Q.base[Q.front];

Q.front=(Q.front+1) % MaxQsize;

return OK;

}

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

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

#includestdio.h

void add(int queue[],int x);

int Top(int queue[]);

void del(int queue[]);

int end=0;

int main()

{

int n;

scanf("%d",n);//将要入队列n个元素

int queue[1000];

for(int i=1;i=n;i++)//输入n个元素

{

add(queue,i);//将i加入队列

}

//验证加入队列的元素，将队列中的元素按照输入的顺序输出：

for( i=1;i=n;i++)

{

printf("%d ",Top(queue));//Top函数返回队头元素

del(queue);//删除队头元素

}

//验证输出已经出队列后的队列（数组）元素：

printf("\n");

for(i=1;i=n;i++)

printf("%d ",queue[i]);

printf("\n");

return 0;

}

void add(int queue[],int x)

{

queue[++end]=x;

}

int Top(int queue[])

{

return queue[1];//注意，这里的函数始终return queue[1];这里是和将普通数组中的元素输出最大的不同之处。！！！！！！

}

void del(int queue[])

{

for(int i=2;i=end;i++)

{

queue[i-1]=queue[i];

}

queue=0;//将删除后的地方置0

end--;

}