队列的链式表示

/*
	主题：队列的链式表示
	作者：nixindong
	开发环境：Visual Studio
	开发语言：C
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int ElemType;
typedef enum {TRUE = 1, FALSE = 0}boolean;

//结点
typedef struct QNode
{
	ElemType data;
	struct QNode *pNext;
}QNODE, *PQNODE;
//队列
typedef struct LinkQueue
{
	QNODE * pFront;
	QNODE * pRear;
}LinkQueue;

//函数声明
boolean initList(LinkQueue *L);
boolean enQueue(LinkQueue *L, ElemType value);
boolean queueEmpty(LinkQueue *L);
boolean deQueue(LinkQueue *L, ElemType *value);
boolean getHead(LinkQueue *L, ElemType *value);
boolean clearQueue(LinkQueue *L);
boolean destroyQueue(LinkQueue *L);
//主函数
int main(void)
{
	LinkQueue L;
	boolean index = FALSE;
	ElemType value;
	ElemType temp;

	index = initList(&L);

	if (index)
	{
		puts("Init Success!");
	}
	else
	{
		puts("error");
	}

	printf("是否是空队列？%d（1：空， 0：否）\n", queueEmpty(&L));
	enQueue(&L, -5);
	enQueue(&L, 5);
	enQueue(&L, 10);

	getHead(&L, &temp);
	printf("队头元素为temp = %d\n", temp);

	deQueue(&L, &value);
	printf("删除了队头元素value = %d\n", value);
	getHead(&L, &temp);
	printf("新的队头元素为temp = %d\n", temp);
	
	if(clearQueue(&L))
	{
		printf("清空队列后， L.front = %u L.pRear = %u L.pFront->pNext = %u\n", L.pFront, L.pRear, L.pFront->pNext);
	}
	if (destroyQueue(&L))
	{
		printf("销毁队列后， L.front = %u L.pRear = %u\n", L.pFront, L.pRear);
	}
	
	return 0;
}

/*
	函数名称：initList
	函数功能：初始化一个队列
	函数参数：L（队列）
	函数返回值：
				boolean(类型)：
					TRUE：成功
					FALSE:失败
*/
boolean initList(LinkQueue *L)
{
	(L)->pFront = (QNODE *) malloc(sizeof(QNODE));
	if (NULL == (L)->pFront)
	{
		return FALSE;
	}
	(L)->pRear = (L)->pFront;
	(L)->pFront->pNext = NULL;

	return TRUE;
}
/*
	函数名称：enQueue
	函数功能：向队列中插入元素
	函数参数：L（队列）
				value（元素）
	函数返回值：
				boolean(类型)：
					TRUE：成功
					FALSE:失败
*/
boolean enQueue(LinkQueue *L, ElemType value)
{
	QNODE *pNew = NULL;
	//判断参数的合法性
	if (NULL == L)
	{
		return FALSE;
	}
	//给元素分配空间
	pNew = (QNODE *) malloc(sizeof(QNODE));
	if (NULL == pNew)
	{
		return FALSE;
	}
	pNew->data = value;							//将数据存放在新结点
	pNew->pNext = NULL;
	L->pRear->pNext = pNew;						//将结点插入到队列里
	L->pRear = pNew;							//保证pRear指针始终指向队列的最后一个元素

	return TRUE;
}
/*
	函数名称：deQueue
	函数功能：如果队列不为空，则删除队列的一个元素
	函数参数：L（队列）
				value（删除元素的存放区域）
	函数返回值：
				boolean(类型)：
					TRUE：删除成功
					FALSE:删除失败
*/
boolean deQueue(LinkQueue *L, ElemType *value)
{
	QNODE *pNew = NULL;
	//判断队列是否为空
	if (queueEmpty(L))
	{
		return FALSE;
	}
	//使pNew指向队列的第一个元素
	pNew = L->pFront->pNext;
	*value = pNew->data;
	L->pFront->pNext = pNew->pNext;					//pFront指针指向第一个元素的下一个元素
	if (pNew == L->pRear)							//如果要删除的元素是最后一个元素
	{
		L->pFront = L->pRear;						//将队列置为空
		L->pRear->pNext = NULL;
	}
	free(pNew);
	pNew = NULL;

	return TRUE;
}

/*
	函数名称：queueEmpty
	函数功能：判断一个队列是否为空
	函数参数：L（队列）
	函数返回值：
				boolean(类型)：
					TRUE：空
					FALSE:非空
*/
boolean queueEmpty(LinkQueue *L)
{
	if (L->pFront == L->pRear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
/*
	函数名称：getHead
	函数功能：如果队列不为空，则返回队列的头元素
	函数参数：L（队列）
				value（返回元素的存放区域）
	函数返回值：
				boolean(类型)：
					TRUE：删除成功
					FALSE:删除失败
*/
boolean getHead(LinkQueue *L, ElemType *value)
{
	if (queueEmpty(L))
	{
		return FALSE;
	}

	*value = L->pFront->pNext->data;

	return TRUE;
}
/*
	函数名称：clearQueue
	函数功能：清空整个队列
	函数参数：L（队列）
	函数返回值：
				boolean(类型)：
					TRUE：清空成功
					FALSE:失败
*/
boolean clearQueue(LinkQueue *L)
{
	QNODE *pCurrent = NULL;
	QNODE *pDelete = NULL;
	
	if (queueEmpty(L))
	{
		return FALSE;
	}
	//使尾指针指向头指针位置
	L->pRear = L->pFront;
	pDelete = L->pFront->pNext;
	L->pFront->pNext = NULL;
	//循环删除队列里的元素
	while(pDelete)
	{
		pCurrent = pDelete->pNext;
		free(pDelete);
		pDelete = pCurrent;
	}
	//释放临时指针
	free(pCurrent);
	free(pDelete);

	return TRUE;
}
/*
	函数名称：destroyQueue
	函数功能：销毁整个队列
	函数参数：L（队列）
	函数返回值：
				boolean(类型)：
					TRUE：清空成功
					FALSE:失败
*/
boolean destroyQueue(LinkQueue *L)
{
	while(L->pFront)
	{
		L->pRear = L->pFront->pNext;
		free(L->pFront);
		L->pFront = L->pRear;
	}

	return TRUE;
}

运行结果：