队列的相关接口实现 《完整版》

打开队列的同学，相信前面的栈也已经看过了，是不是觉得还可以，但是后来的二叉树可不是那么接单就能够理解的，所以，我觉得同学如果想学好一点，还是提前看一下，预习以下。点开下面的链接，或者是打开我的数据结构；
Queue.c

#ifndef    __QUEUE_H__
#define   __QUEUE_H__

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<malloc.h>
#include<time.h>


typedef int QUDataType;
typedef struct QueueNode
{
      struct QueueNode* _next;
      QUDataType _data;
}QueueNode;
typedef struct Queue
{
QueueNode* _head; // ¶ÓÍ·
QueueNode* _tail; // ¶Óβ
}Queue;



void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
QueueNode* BuyQueueNode(QUDataType x);

void QueuePush(Queue* pq, QUDataType x);
void QueuePop(Queue* pq);

QUDataType QueueFront(Queue* pq);
QUDataType QueueBack(Queue* pq);

int QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

void QueuePrint(Queue* pq);

void TestQueue();

#endif

Queue.c

#include "Queue.h"

void QueueInit(Queue* pq)
{
      assert(pq);
      pq->_head  = pq->_tail = NULL;
}

void QueueDestory(Queue* pq)
{
	struct QueueNode* cur = pq->_head ;
    assert(pq);
	while(cur)
	{
	  struct QueueNode* next = cur->_next ;
      free(cur);
	  cur = next;
	}
	pq->_head = pq->_tail = NULL;
}

QueueNode* BuyQueueNode(QUDataType x)
{
   QueueNode*  node = (QueueNode*)malloc(sizeof(QueueNode));
   node->_data = x;
   node->_next = NULL;
   return node;
}
void QueuePush(Queue* pq, QUDataType x)
{
    assert(pq);
    /*QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode)); 一样的代码，上面就是自己定义了一个
    newnode->_data = x;
	newnode->_next = NULL;
	if(pq->_tail == NULL)
	{
	   pq->_tail = pq->_head  = newnode;
	}
	else
	{
	    pq->_tail ->_next = newnode;
		pq->_tail = newnode;
	}*/   
    if(pq->_head  == NULL)
	{
	   pq->_head  = pq->_tail = BuyQueueNode(x);
	}
	else
	{
	    pq->_tail ->_next = BuyQueueNode(x);
		pq->_tail = pq->_tail ->_next ;
	}

}

void QueuePop(Queue* pq)
{
    assert(pq);
	if(pq->_head )
	{
	    QueueNode* next = pq->_head ->_next ;
		free(pq->_head );
		pq->_head = next ; 
       if(pq->_head  == NULL)
		{
		   pq->_tail = NULL;
		}
	}
}

int QueueSize(Queue* pq)
{
    int size = 0;
	struct QueueNode* cur = pq->_head ;
	assert(pq);
	while(cur != NULL)
	{
	     ++size;
		 cur = cur->_next ;
	}
	return size;
}

int QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->_head == pq->_tail  ? 0 : 1;
}

QUDataType QueueFront(Queue* pq)
{
     assert(pq);
	 return pq->_head ->_data ;
}

QUDataType QueueBack(Queue* pq)
{
    assert(pq);
	return pq->_tail ->_data ;
}

void QueuePrint(Queue* pq)
{
	QueueNode* cur = pq->_head;
	assert(pq);
	while(cur != NULL)
	{
        printf("%d ",cur->_data);
		cur = cur ->_next ;
    }
   printf("\n");
}

test.c

**int main()
{
	Queue pq;
	QueueInit(&pq);
     QueuePush(&pq,1);
	QueuePush(&pq,2);
	QueuePush(&pq,3);
	QueuePush(&pq,4);
	QueuePush(&pq,5);
	QueuePrint(&pq);
    QueuePop(&pq);
	QueuePrint(&pq);
    QueueFront(&pq);
    QueuePrint(&pq);
    	while(QueueEmpty(&pq) != 0)  //后面的是显示头的数值，把这里屏蔽了，就可以了，
	{
	   printf("%d ",QueueFront(&pq));
	   QueuePop(&pq);
	   printf("\n");
	}
	QueueDestory(&pq);
 return 0;
}**

自我觉得队列和栈差不多，比较好理解，就是后面的二叉树，我比较迟一点，写的慢，而且用了好一段时间理解。所以我觉得同学们也应该提前预习一下。

栈的接口链接：
https://blog.csdn.net/dpfxaca6/article/details/88654703

二叉树的接口链接;
https://blog.csdn.net/dpfxaca6/article/details/88654466