队列的基本操作

QUEUE.h

#ifndef __QUEUE_H__
#define __QUEUE_H__
typedef int 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); 
void QueuePrint(Queue* q);
QDataType QueueFront(Queue* q); 
QDataType QueueBack(Queue* q); 
int QueueSize(Queue* q); 
int QueueEmpty(Queue* q); 

#endif //__QUEUE_H__

QUEUE.c

#include "QUEUE.h"
#include <malloc.h>
#include <stdio.h>
#include <assert.h>
QListNode* BuyQueueNode(QDataType data)
{
    QListNode* pNewNode = (QListNode*)malloc(sizeof(QListNode));
    if(NULL == pNewNode)
    {
     return 0;

    }
    else
    {
        pNewNode->_data = data;
        pNewNode->_pNext = NULL; 
        return pNewNode;
    }


}
void QueueInit(Queue* q)
{
    assert(q);
    q->_pFront = NULL;
    q->_pBack = NULL;

}
void QueuePush(Queue* q, QDataType data) 
{ 
     QListNode* pNewNode = BuyQueueNode(data);
     pNewNode->_pNext = NULL;
     assert(q); 
     if(NULL == q->_pBack)
     {
         q->_pFront = pNewNode;
         q->_pBack = pNewNode;

     }
     else
     {
         q->_pBack->_pNext = pNewNode;
         q->_pBack = q->_pBack->_pNext;

     }
}

void QueuePop(Queue*q)
{
    assert(q);
    if(NULL == q->_pFront)
    {
        return;
    }
    else if(q->_pFront != q->_pBack)
    {
        QListNode* ret = q->_pFront;
        q->_pFront = q->_pFront->_pNext;
        free(ret);
        ret = NULL;
    }
    else
    {
        QListNode*ret = q->_pFront;
        free(ret);
        ret = NULL;
        q->_pFront = NULL;
        q->_pBack = NULL;
    }
}
void QueuePrint(Queue *q)
{

    QListNode *pCurNode;      
    pCurNode = q->_pFront;      
        if (pCurNode == NULL)
        {      
            printf("NULL\n");      
            return;      
        }      
        while (pCurNode != q->_pBack) 
        {      
            printf("%d ", pCurNode->_data);  
            pCurNode =pCurNode->_pNext;      
        }  
        printf("%d", pCurNode->_data);  
        putchar('\n');      
    } 

QDataType QueueFront(Queue* q)
{
    assert(q);
    return q->_pFront->_data;

}
QDataType QueueBack(Queue* q)
{
   assert(q);
   return q->_pBack->_data;

}
int QueueSize(Queue* q)
{
    int count = 1;
    QListNode* pCurNode = q->_pFront;
    while(pCurNode != q->_pBack)
    {
        count++;
        pCurNode = pCurNode->_pNext; 
    }
    return count;

}
int QueueEmpty(Queue* q)
{
 if(q->_pFront == NULL || q->_pBack == NULL)
        return 1;
    return 0;
}

test.c

#include "QUEUE.h"
#include <stdio.h>

void test()
{
    int e = 0;
    Queue queue = {0};
    QueueInit(&queue); 
    QueuePush(&queue,1); 
    QueuePush(&queue,2);
    QueuePush(&queue,3);
    QueuePush(&queue,4);
    QueuePush(&queue,5);
    QueuePrint(&queue);
    printf("\n");

    QueuePop(&queue);
    QueuePrint(&queue);
    printf("\n");

    e = QueueFront(&queue);
    printf("队头元素为：%d\n ",e);
    e = QueueBack(&queue);
    printf("队尾元素为：%d\n ",e );
    e = QueueSize(&queue);
    printf("该队列的长度为：%d\n ", e);

    QueueEmpty(&queue); 
}
int main()
{
    test();
  return 0;
}