队列学习、队列封装

1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：

（1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构；

（2）在队尾添加元素，在队头删除元素。

2、队列的相关概念：

（1）队头与队尾： 允许元素插入的一端称为队尾，允许元素删除的一端称为队头；

（2）入队：队列的插入操作；

（3）出队：队列的删除操作。

3、队列的操作：

（1）入队： 通常命名为push()

（2）出队： 通常命名为pop()

（3）求队列中元素个数

（4）判断队列是否为空

（5）获取队首元素

4、队列的分类：

（1）基于数组的循环队列（循环队列）

（2）基于链表的队列（链队列）

5.基于链表的队列实现
queue.h

//封装队列

typedef int QDataType; 
//typedef struct BTNode* QDataType;

typedef struct QListNode
{
	struct QListNode* _pNext;
	QDataType _data;

}QListNode;

typedef struct Queue
{
	QListNode* _pFront;
	QListNode* _pBack;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueuePrint(Queue* q);

Queue.c

#include "Queue.h"
#include <stdio.h>
#include <assert.h>

QListNode* BuyListNode(QDataType data)
{
	QListNode* pNewNode = (QListNode*)malloc(sizeof(QListNode));
	if (NULL == pNewNode)
	{
		assert(0);
		return NULL;
	}
	pNewNode->_data = data;
	pNewNode->_pNext = NULL;
	return pNewNode;
}

//初始化(底层链表：带头结点的单链表)
void QueueInit(Queue* q)
{
	assert(q);

	q->_pFront = q->_pBack = BuyListNode(0);
}

//入队列
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	q->_pBack->_pNext = BuyListNode(data);
	q->_pBack = q->_pBack->_pNext;
}

//出队列
void QueuePop(Queue* q)
{
	assert(q);

	if (q->_pFront != q->_pBack)
	{
		QListNode* pDelNode = q->_pFront->_pNext;
		q->_pFront->_pNext = pDelNode->_pNext;
		free(pDelNode);
		pDelNode = NULL;
	}
}

//获取队头元素
QDataType QueueFront(Queue* q)
{
	assert(q);

	return q->_pFront->_pNext->_data;
}

//获取队尾元素
QDataType QueueBack(Queue* q)
{
	assert(q);

	return q->_pBack->_data;
}

//求队列的大小
int QueueSize(Queue* q)
{
	assert(q);

	int size = 0;
	QListNode* pCur = q->_pFront->_pNext;
	while (pCur)
	{
		size++;
		pCur = pCur->_pNext;
	}
	return size;
}

//判断队列是否为空
int QueueEmpty(Queue* q)
{
	assert(q);

	return 0 == QueueSize(q);
}

void QueuePrint(Queue* q)
{
	assert(q);

	QListNode* pCur = q->_pFront;
	while (pCur)
	{
		printf("%d->", pCur->_data);
		pCur = pCur->_pNext;
	}
	printf("NULL\n");
}

main.cpp

#include "Queue.h"
#include <stdio.h>
#include <stdlib.h>

void Test()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePrint(&q);
	printf("q->_Front = %d\n", QueueFront(&q));
	printf("q->_Back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));
	if (QueueEmpty(&q))
		printf("队列为空\n");
	else
		printf("队列非空\n");

	QueuePop(&q);
	QueuePop(&q);
	QueuePrint(&q);

}

int main()
{
	Test();
	system("pause");
	return 0;
}