c语言之队列结构

1.什么是队列

队列是一种操作受限的线性表，其限制条件为允许在表的一端进行插入，而在表的另一端进行删除。插入的一端叫做队尾，删除的一端叫做队头。向队列中插入新元素的行为称为进队，从队列中删除元素的行为称为出队。

2.队列的特点

队列的特点是先进先出。举例：火车从山洞一端开进，从山洞另一端开出，车厢好比一个个元素，最先进入山洞的车厢先出，后进山洞的车厢后出。

3.循环队列

循环队列的结构：

代码：

typedef struct SqQueue{
	int data[maxsize];
	int front;//队首指针
	int rear;//队尾指针
}SqQueue;

循环队列的状态：

（1）队空状态：

qu.front ==qu.rear

（2）队满状态：

(qu->rear+1)%maxsize ==qu->front

循环队列的操作：

（1）进队列：

qu->rear=(qu->rear+1)%maxsize;
qu->data[qu->rear]=x;

（2）出队列：

*y=qu->data[qu->front];
qu->front=(qu->front+1)%maxsize;

循环队列的实现：

#include
#include
#define maxsize 50
typedef struct SqQueue{
	int data[maxsize];
	int front;//队首指针
	int rear;//队尾指针
}SqQueue;
//创建循环队列
SqQueue initQueue(){
	SqQueue *sq=(SqQueue *)malloc(sizeof(SqQueue));
	if(sq ==NULL){
		return;
	}
	sq->rear=sq->front=0;
	return *sq;
}
//判断循环队列是否为空
int isEmpty(SqQueue qu){
	return (qu.front ==qu.rear?1:0);
}
//元素进循环队列
int enQueue(SqQueue *qu,int x){
	if((qu->rear+1)%maxsize ==qu->front){
		return 0;
	}
	qu->rear=(qu->rear+1)%maxsize;
	qu->data[qu->rear]=x;
	return 1;
}
//元素出循环队列
int deQueue(SqQueue *qu,int *y){
	if(qu->rear ==qu->front){
		return 0;
	}
	*y=qu->data[qu->front];
	qu->front=(qu->front+1)%maxsize;
	return 1;
}
//打印循环队列
int printQueue(SqQueue qu){
	if(qu.rear ==qu.front){
		return 0;
	}
	while(qu.rear !=qu.front){
		qu.front=(qu.front+1)%maxsize;
		printf("当前队列值=%d\n",qu.data[qu.front]);
	}
	return 1;
}
void main(){
	int y=0;
	SqQueue sq =initQueue();
	enQueue(&sq,1);
	enQueue(&sq,2);
	enQueue(&sq,3);
	enQueue(&sq,4);
	deQueue(&sq,&y);
	printQueue(sq);
	printf("当前的front=%d\n",sq.front);
	printf("当前的rear=%d\n",sq.rear);
	
}

结果：

4.链队列

链队列的结构：

代码：

//链队列结点结构
typedef struct QNode{
	int data;
	struct QNode *next;
}QNode;
//链队列结构
typedef struct LiQueue{
	QNode *front;
	QNode *rear;
}LiQueue;

链队列的状态：

（1）队空

lq->front==NULL || lq->rear==NULL

链队列的操作：

（1）进队列：

lq->rear->next=p;
lq->rear=p;

（2）出队列：

p=lq->front;
lq->front=p->next;
x=p->data;
free(p);

链队列的实现：

#include
#include
//链队列结点结构
typedef struct QNode{
	int data;
	struct QNode *next;
}QNode;
//链队列结构
typedef struct LiQueue{
	QNode *front;
	QNode *rear;
}LiQueue;
//创建链队列
LiQueue initQueue(){
	LiQueue *lq=(LiQueue *)malloc(sizeof(LiQueue));
	if(lq ==NULL){
		return;
	}
	lq->front=lq->rear=NULL;
	return *lq;
}
//判断链队列是否为空
int isEmpty(LiQueue *lq){
	if(lq->front==NULL || lq->rear==NULL){
		return 0;
	}else{
		return 1;
	}
}
//元素进链队列
void enQueue(LiQueue *lq,int x){
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	p->data=x;
	p->next=NULL;
	if(lq->rear==NULL){
		lq->front=lq->rear=p;//如果第一次插入则设置头指针和尾指针为p
	}else{
		lq->rear->next=p;//链队列的尾部插入p
		lq->rear=p;//设置链队列的尾指针指向p
	}
}
//元素出链队列
int deQueue(LiQueue *lq,int *y){
	QNode *p=lq->front;
	if(lq->rear==NULL || lq->front==NULL){
		return 0;
	}
	if(lq->front==lq->rear){
		lq->front=lq->rear=NULL;
	}else{
		lq->front=lq->front->next;
	}
	*y=p->data;
	free(p);
	return 1;
}
//打印链队列
void printQueue(LiQueue lq){
	if(lq.front==NULL || lq.rear==NULL){
		return;
	}
	while(lq.front!=NULL){
		printf("%d\n",lq.front->data);
		lq.front=lq.front->next;
	}
}
void main(){
	int y=0;
	LiQueue lq=initQueue();
	enQueue(&lq,1);
	enQueue(&lq,2);
	enQueue(&lq,3);
	enQueue(&lq,4);
	enQueue(&lq,5);
	deQueue(&lq,&y);
	printQueue(lq);
	printf("出队列元素=%d\n",y);
}

结果：