数据结构--线性表--队列的代码实现（C语言）

基本概念

队列是一种先进先出（first in first out,缩写为FIFO）的线性表。只允许表的一端进行插入在另一端删除元素。允许插入的一端叫队尾（rear）,允许删除的一端叫队头（front）。队列的基础结构如下所示：

队列的链式表示和实现

   队列的链表表示称为链队列。一个链队列显然需要两个分别指示队头和队尾的指针才能唯一确定。
  链队列的操作即为单链表的插入和删除操作的特殊情况，只是尚需修改尾指针和头指针。
                              
代码实现：

/*
* 队列的链式实现
*/
#include <stdlib.h>
#include <stdbool.h>

/*
* 定义队列的结构体
*/
typedef int Element;

typedef struct ElEMTYPE
{
	Element e;
	struct ElEMTYPE* next;
}ElemType;

typedef struct QUEUE_Linked
{
	int size;			//队列的存在的元素个数
	ElemType* front;    //指向栈底元素
	ElemType* rear;		//指向栈顶元素
}linkedQueue;
/*
* 初始化队列
*/
bool InitLinkedQueue(linkedQueue* lp);

/*
* 插入元素到队列中
* 队尾插入
*/
bool enLinkedQueue(linkedQueue* lp, Element e);
/*
* 若队列不空则删除队列队头元素并用e返回值，返回true 否则返回false
*/
bool deLinkedQueue(linkedQueue* sp, Element* e);
/*
* 将函数作用于每个元素上
*/
bool linkedQueueTraverse(linkedQueue* lp, void(*pFun)(Element e));
/*
* 返回队列中元素的个数
*/
int linkedQueueLength(linkedQueue* lp);
/*
* 若队列不为空，用e返回队头的数据
*/
bool getHeadLinkedQueue(linkedQueue* lp,Element* e);
/*
* 每个元素加一
*/
void element_add_linkedQueue(ElemType* e);
/*
* 具体实现部分
*/
bool InitLinkedQueue(linkedQueue* lp)
{
	ElemType* temp;
	 temp= (ElemType*)malloc(sizeof(ElemType));
	 if (temp == NULL)
	 {
		 printf("申请动态内存失败！");
		 exit(-1);
	 }
	 lp->front = lp->rear = temp;
	 lp->size = 0;
	 return true;
}

bool enLinkedQueue(linkedQueue* lp, Element e)
{
	ElemType* temp;
	temp = (ElemType*)malloc(sizeof(ElemType));
	if (temp == NULL)
	{
		printf("申请动态内存失败！");
		exit(-1);
	}
	temp->e = e;
	temp->next = NULL;
	if (lp->size==0) //空
	{
		lp->front = lp->rear = temp;
	}
	else
	{
		lp->rear->next = temp;
		lp->rear = temp;
	}
	
	lp->size++;
	return true;
}
bool deLinkedQueue(linkedQueue* lp, Element* e)
{
	if (lp->size==0)  //队列中没有元素
	{
		return false;
	}
	*e = lp->front->e;
	lp->front = lp->front->next;
	lp->size--;
}

int linkedQueueLength(linkedQueue* lp)
{
	if (lp->front == lp->rear)
	{
		return 0;
	}
	return lp->size;
}
bool getHeadLinkedQueue(linkedQueue* lp,Element* e)
{
	if (lp->size==0)  //队列中没有元素
	{
		return false;
	}
	*e = lp->front->e;
}
void element_add_linkedQueue(ElemType* e)
{
	e->e += 3;
}
bool linkedQueueTraverse(linkedQueue* lp, void(*pFun)(Element e))
{
	if (lp->front == lp->rear)
	{
		return false;
	}
	ElemType* p = lp->front;
	while (p!= NULL)
	{
		(*pFun)(p->e);
		p = p->next;
	}
	return true;
}

int main(void)
{
	linkedQueue lq;
	InitLinkedQueue(&lq);
	enLinkedQueue(&lq, 45);
	Element e1 = 0;
	bool get_res=getHeadLinkedQueue(&lq, &e1);
	if (get_res)
		printf("获取到的结果是：%d\n", e1);
	else
		printf("获取队列头元素失败\n");
	bool del_res = deLinkedQueue(&lq, &e1);
	if (del_res)
		printf("删除成功，删除的元素是：%d\n", e1);
	else
		printf("删除元素失败\n");
	bool del_res1 = deLinkedQueue(&lq, &e1);
	if (del_res1)
		printf("删除成功，删除的元素是：%d\n", e1);
	else
		printf("删除元素失败\n");
	
}

运行结果：

队列的顺序表示和实现—循环队列

循环队列需要使用数组实现，判断队列空的条件是队列头和队列尾相等，判断队列满的条件是队列头等于队尾+1。
代码实现

/*
* 循环队列的实现---顺序实现 需要用数组实现
* 队列满的条件是rear+1==front
*/

#include <stdlib.h>
#include <stdbool.h>
#define MAXQUEUESIZE 100  //队列的最大长度
/*
* 定义队列的结构体
*/
typedef int Element;


typedef struct QUEUE
{
	Element* base;		//初始化动态分配存储空间	
	int front;		//指向栈底元素
	int rear;		//指向栈顶元素
}queue;
/*
* 初始化队列
*/
bool InitQueue(queue* qp);

/*
* 插入元素到队列中
* 队尾插入
*/
bool endQueue(queue* qp, Element e);
/*
* 若队列不空则删除队列队头元素并用e返回值，返回true 否则返回false
*/
bool deQueue(queue* qp, Element* e);
/*
* 将函数作用于每个元素上
*/
bool queueTraverse(queue* qp, void(*pFun)(Element e));
/*
* 返回队列中元素的个数
*/
int queueLength(queue* qp);
/*
* 若队列不为空，用e返回队头的数据
*/
bool getHeadQueue(queue* qp, Element* e);
/*
* 每个元素加一
*/
void element_add_queue(Element* e);
/*
* 具体实现部分
*/
bool InitQueue(queue* qp)
{
	qp->base= (Element*)malloc(sizeof(Element)*MAXQUEUESIZE);
	qp->front = qp->rear = NULL;
	return true;
}

bool enQueue(queue* qp, Element e)
{
	//先判断队列是否已经满了
	if ((qp->rear + 1) % MAXQUEUESIZE == qp->front)
		return false;
	qp->base[qp->rear] = e;
	qp->rear = (qp->rear + 1) % MAXQUEUESIZE;    
	return true;
}
bool deQueue(queue* qp, Element* e)
{
	if (qp->rear==qp->front)  //队列中没有元素
	{
		return false;
	}
	*e = qp->base[qp->front];
	qp->front = (qp->front+1) % MAXQUEUESIZE;
	return true;
}

int queueLength(queue* qp)
{
	if (qp->front == qp->rear)
	{
		return 0;
	}
	return qp->rear;
}
bool getHeadQueue(queue* qp, Element* e)
{
	if (qp->rear == qp->front)  //队列中没有元素
	{
		return false;
	}
	*e = qp->base[qp->front];
}
void element_add_queue(Element e)
{
	e += 3;
}
bool queueTraverse(queue* qp, void(*pFun)(Element e))
{
	if (qp->front == qp->rear)
	{
		return false;
	}
	for (int a = qp->front; a < qp->rear; a++)
	{
		(*pFun)(qp->base[a]);
	}
	return true;
}

int main(void)
{
	queue q;
	InitQueue(&q);
	enQueue(&q, 45);
	Element e1 = 0;
	bool get_res = getHeadQueue(&q, &e1);
	if (get_res)
		printf("获取到的结果是：%d\n", e1);
	else
		printf("获取队列头元素失败\n");
	bool del_res = deQueue(&q, &e1);
	if (del_res)
		printf("删除成功，删除的元素是：%d\n", e1);
	else
		printf("删除元素失败\n");
	bool del_res1 = deQueue(&q, &e1);
	if (del_res1)
		printf("删除成功，删除的元素是：%d\n", e1);
	else
		printf("删除元素失败\n");

}

运行结果：