【数据结构】队列的实现

队列：

队列是一种受限制的线性表，特殊之处在于它只允许在表的前端进行删除操作，只能在表的后端进行插入操作。我们称只允许删除的一端为队头，只进行插入的一端为队尾。
即队列是一种先进先出（First In First Out）的线性表，简称FIFO。

队列的顺序存储结构：是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针 front指向队头元素，队尾指针 rear 指向队尾元素的下一个位置。

Queue.h

    #define _CRT_SECURE_NO_WARNINGS 1
    #include <stdlib.h>
    #include <stdio.h>
    #include <assert.h>
    
    typedef int QDataType;
    typedef struct QueueNode
    {
    	QDataType _data;    //当前结点存储数据
    	struct QueueNode* _next;   //指向下一个节点
    }QNode;
    
    typedef struct Queue
    {
    	QNode* _head;     //指向队列的头
    	QNode* _tail;     //指向队列的尾
    }Qu;
    
    void QueueInit(Qu*pq);   
    //队列的初始化：构造一个空队
    void QueueDestory(Qu* pq);    
    //队列的销毁：置空队列
    void QueuePrint(Qu* pq);      
    // 队列的打印：输出队列中数据
    QNode* BuyQueueNode(QDataType x);    
    //新建结点：单独结点
    void QueuePush(Qu* pq, QDataType x);    
    // 队尾插入（入队）：对已存在的队列，插入一个元素到队尾，队发生变化
    void QueuePop(Qu* pq);               
    //队头删除（出队）：对已存在队列，删除一个队首元素，队发生变化
    QDataType QueueFront(Qu* pq);        
    //取队头元素：读队首元素，并返回其值，队不变
    QDataType QueueBack(Qu*pq);        
    //取队头元素：读队尾元素，并返回其值，队不变
    int QueueEmpty(Qu* pq);         
    //判断队列是否为空：若为空队列则返回0，否则返回1
    int QueueSize(Qu* pq);        
    //计算队列的元素个数并返回此值，队不变
    
    void TestQueue();           
    //测试函数：测试上述函数功能

Queue.c

    #define _CRT_SECURE_NO_WARNINGS 1
    #include "Queue.h"
        
    void QueueInit(Qu* pq)
    {
    	QDataType x = 0;
    	assert(pq);
    	pq->_head = BuyQueueNode(x);    //定义一个头结点
    	pq->_tail = pq->_head;
    }
    
    void QueueDestory(Qu* pq)
    {
    	QNode* cur = pq->_head->_next;    //cur是当前队列的第一个结点
    	while (cur != NULL)              //释放所有结点
    	{
    		QNode* next = cur->_next;
    		free(cur);
    		cur = next;
    	}
    }
    
    QNode* BuyQueueNode(QDataType x)
    {
    	QNode* newNode = (QNode*)malloc(sizeof(QNode));
    	newNode->_data = x;
    	newNode->_next = NULL;
    	return newNode;
    }
    
    void QueuePush(Qu* pq, QDataType x)
    {
    	QNode* newnode = BuyQueueNode(x);
    	pq->_tail->_next = newnode;    //将新结点放在队尾
    	pq->_tail = newnode;
    }
    
    void QueuePop(Qu* pq)
    {
    	assert(pq);
    	QNode* 	cur = pq->_head->_next;
    	if (cur == NULL)       // 若队列中无元素
    	{
    		return;
    	}
    	if (cur == pq->_tail)     //若队列中只有一个元素
    	{
    		pq->_tail = pq->_head;
    	}
    	pq->_head->_next = cur->_next;
    	free(cur);
    }
    
    QDataType QueueFront(Qu* pq)
    {
    	QNode* 	cur = pq->_head->_next;
    	assert(pq);
    	return cur->_data;
    }
    
    QDataType QueueBack(Qu*pq)
    {
    	assert(pq);
    	return pq->_tail->_data;
    }
    
    int QueueEmpty(Qu* pq)
    {
    	QNode* 	cur = pq->_head->_next;
    	if (cur == NULL)
    		return 0;
    	else return 1;
    }
    
    int QueueSize(Qu* pq)
    {
    	int count = 0;
    	QNode* 	cur = pq->_head->_next;
    	if (cur == NULL)
    		return 0;
    	while (cur)
    	{
    		count++;
    		cur = cur->_next;
    	}
    	return count;
    }
    
    void QueuePrint(Qu* pq)
    {
    	QNode* 	cur = pq->_head->_next;
    	assert(pq);
    	while (cur != NULL)
    	{
    		printf("%d  ", cur->_data);
    		cur = cur->_next;
    	}
    	printf("\n");
    }
    
    void TestQueue()
    {
    	int i = 0;
    	Qu queue;
    	QueueInit(&queue);
    	printf("初始化队列完成 \n");
    	printf("尾插的结果是： ");
    	QueuePush(&queue, 1);
    	QueuePush(&queue, 2);
    	QueuePush(&queue, 3);
    	QueuePush(&queue, 4);
    	QueuePrint(&queue);
    	printf("头删的结果是： ");
    	QueuePop(&queue);
    	QueuePrint(&queue);
    	printf("队列的头结点是： %d \n", QueueFront(&queue));
    	printf("队列的尾结点是： %d \n", QueueBack(&queue));
    	i = QueueEmpty(&queue);
    	if (i == 0)  printf("队列为空！\n ");
    	else   printf("队列非空 \n ");
    	printf("队列的个数是： %d \n", QueueSize(&queue));
    	QueueDestory(&queue);
    	printf("销毁成功！\n");
    }
   

Test.c

    #define _CRT_SECURE_NO_WARNINGS 1
    #include "Queue.h"

    int main()
    {
    	printf("      *******队列的实现******\n");
    	TestQueue();
    	printf("\n");
    	printf("\n");
    	printf("\n");
    	system("pause");
    	return 0;
    }