队列的链式存储和实现（C语言）【队列】（8）

LinkQueue.h

#pragma once

#include "DataType.h"

//链式队列的结构定义

typedef struct _Node
{
	DataType data;		//数据元素
	struct _Node* next; //链式队列中结点元素的指针
}Node,* NodePtr;

typedef struct _Queue
{
	NodePtr front;		//队列头指针
	NodePtr rear;		//队列尾指针
}Queue;

//链式队列的基本操作

void InitQueue(Queue* Q);		//初始化
void DestroyQueue(Queue* Q);	//销毁
bool QueueEmpty(Queue Q);		//判空
int QueueLength(Queue Q);		//获得队列长度
bool GetHead(Queue Q, DataType* val); //获得队列头部元素
bool GetTail(Queue Q, DataType* val); //获得队列尾部元素
void QueueTraverse(Queue Q, void(*fp)(DataType)); //遍历队列
bool InsertQueue(Queue* Q, DataType e);  //入队列
bool OutQueue(Queue* Q, DataType *e);  //出队列

DataType.h

#pragma once
//DataType 的定义
typedef int DataType;
int compare(DataType x, DataType y);
void visit(DataType e);

DataType.cpp

#include "DataType.h"
#include 

//DataType 的实现

int compare(DataType x, DataType y)
{
	return (x - y);
}
void visit(DataType e)
{
	printf("%d\t", e);
}

LinkQueue.cpp

#include "LinkQueue.h"
#include 
#include 
#include 
/* ------------------------------------------------------------
操作目的：	初始化队列
初始条件：	无
操作结果：	构造一个空队列
函数参数：
Queue* Q    待初始化的队列
返回值：
void  无返回值
------------------------------------------------------------*/

void InitQueue(Queue* Q)		//初始化
{
	Q->front = (NodePtr)malloc(sizeof(Node));
	if (!Q->front)
	{
		printf("%d->%serror\n", __LINE__, __FILE__);
		exit(-1);
	}
	Q->rear = Q->front;
	Q->front->next = NULL;
}

/* ------------------------------------------------------------
操作目的：	销毁队列
初始条件：	队列Q已存在
操作结果：	销毁队列Q
函数参数：
Queue* Q   待销毁的队列
返回值：
void  无返回值
------------------------------------------------------------*/
void DestroyQueue(Queue* Q)	//销毁
{
	while (Q->front->next)
	{
		Q->rear = Q->front->next;
		Q->front->next = Q->rear->next;
		free(Q->rear);
	}
	free(Q->front);
	Q->front = Q->rear = NULL;
}

/* ------------------------------------------------------------
操作目的：	判断队列是否为空
初始条件：	队列Q存在,若队列为空返回true   否则返回 false
操作结果：	
函数参数：
Queue* Q    待判断的队列
返回值：
bool		是否为空
------------------------------------------------------------*/
bool QueueEmpty(Queue Q)		//判空
{
	return Q.front == Q.rear ? true : false;
}

/* ------------------------------------------------------------
操作目的：	得到队列的长度
初始条件：	队列Q已经存在
操作结果：	返回队列中元素的个数
函数参数：
Queue* Q    待求长度的队列
返回值：
void  无返回值
------------------------------------------------------------*/
int QueueLength(Queue Q)		//获得队列长度
{
	NodePtr tmp = Q.front->next;
	int Length = 0;
	while (tmp)
	{
		Length++;
		tmp = tmp->next;
	}
	return Length;
}

/* ------------------------------------------------------------
操作目的：	得到队列首元素
初始条件：	队列Q已存在
操作结果：	用e返回队列首元素
函数参数：
	Queue* Q    队列
	DataType* val 队列首元素的值
返回值：
void  无返回值
------------------------------------------------------------*/
bool GetHead(Queue Q, DataType* val) //获得队列头部元素
{
	if (Q.front == Q.rear)
		return false;
	*val = Q.front->next->data;
	return true;
}

/* ------------------------------------------------------------
操作目的：	获得队列头部元素
初始条件：	队列存在且不为空
操作结果：	获得队列Q的头部元素
函数参数：
Queue* Q    待操作的队列
返回值：
bool   操作是否成功
------------------------------------------------------------*/
bool GetTail(Queue Q, DataType* val) //获得队列尾部元素
{
	if (Q.front == Q.rear)
		return false;
	*val = Q.rear->data;
	return true;
}

/* ------------------------------------------------------------
操作目的：	遍历队列元素
初始条件：	队列存在且不为空
操作结果：	遍历队列Q的所有元素
函数参数：
Queue* Q    待遍历的队列
void(*fp)(DataType) 打印队列元素
返回值：
void  无返回值
------------------------------------------------------------*/
void QueueTraverse(Queue Q, void(*fp)(DataType)) //遍历队列
{
	while (Q.front != Q.rear)
	{
		Q.front = Q.front->next;
		(*fp)(Q.front->data);
	}
	printf("\n");
}


/* ------------------------------------------------------------
操作目的：	在队列尾部插入元素e
初始条件：	队列Q已存在
操作结果：	插入元素e作为队列新的尾结点
函数参数：
Queue* Q    待初始化的队列
DataType e  待插入的数据元素
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool InsertQueue(Queue* Q, DataType e)  //入队列
{
	NodePtr tmp = (NodePtr)malloc(sizeof(Node));
	if (!tmp)
		return false;
	tmp->data = e;
	tmp->next = NULL;
	Q->rear->next = tmp;
	Q->rear = tmp;
	return true;
}

/* ------------------------------------------------------------
操作目的：	删除队列的首元素结点
初始条件：	队列Q存在
操作结果：	删除Q队列的首元素结点
函数参数：
Queue* Q    待删除的队列
DataType* e 删除的队列元素
返回值：
bool   操作是否成功
------------------------------------------------------------*/
bool OutQueue(Queue* Q, DataType* e)  //出队列
{
	if (Q->front == Q->rear)
		return false;

	NodePtr tmp = Q->front->next;
	*e = tmp->data;
	Q->front->next = tmp->next;
	if (tmp == Q->rear)
		Q->rear = Q->front;
	free(tmp);
	return true;
}

测试结果