队列链表初始化 入队 出队 清空 判断队列满函数实现（实例源代码）

队列链表使用实例源代码，链队源代码。实用参考。C语言、C++、Linux、单片机开发参考源代码。

/* 队列链表头文件
 */
#ifndef _QUEUE_LINK_H
#define _QUEUE_LINK_H

typedef enum {false,true} bool;

#define MAXQUEUE 10

typedef int ItemType;

typedef struct node
{
    ItemType item;
    struct node *next;
} NodeType;

typedef struct queue
{
    NodeType *front;    // 首指针
    NodeType *tail;     // 尾指针
    int      items;     // 个数
} QueueType;

/*********************************************************************
*函数名称: InitializeQueue
*函数功能: 初始化队列
*输入参数: pq 指向一个队列
*输出参数: pq 指向队列
*返 回 值: 无
*********************************************************************/
void InitializeQueue(QueueType *pq);

/*********************************************************************
*函数名称: QueueIsEmpty
*函数功能: 判断是否是空表
*输入参数: pq 指向一个队列
*输出参数: 无
*返 回 值: true 空表，false 非空表
*********************************************************************/
bool QueueIsEmpty(const QueueType *pq);

/*********************************************************************
*函数名称: QueueIsFull
*函数功能: 判断是否已满
*输入参数: pq 指向一个队列
*输出参数: 无
*返 回 值: true 已满，false 未满
*********************************************************************/
bool QueueIsFull(const QueueType *pq);

/*********************************************************************
*函数名称: QueueItemCount
*函数功能: 获取表中节点个数
*输入参数: pq 指向一个队列
*输出参数: 无
*返 回 值: >0 个数
*********************************************************************/
int QueueItemCount(const QueueType *pq);

/*********************************************************************
*函数名称: QueueAddItem
*函数功能: 向队列尾添加节点
*输入参数: pq    指向一个队列
*          pItem 新节点的元素
*输出参数: pq 表头
*返 回 值: true 成功，false 失败
*********************************************************************/
bool QueueAddItem(QueueType *pq, ItemType *pItem);

/*********************************************************************
*函数名称: QueueDelItem
*函数功能: 从队列头删除一个节点
*输入参数: pq    指向一个队列
*          pItem 新节点的元素
*输出参数: pq 表头
*返 回 值: true 成功，false 失败
*********************************************************************/
bool QueueDelItem(QueueType *pq, ItemType *pItem);

/*********************************************************************
*函数名称: EmptyTheQueue
*函数功能: 清空队列
*输入参数: pq 指向一个队列
*输出参数: 无
*返 回 值: 无
*********************************************************************/
void EmptyTheQueue(QueueType *pq);

#endif



/* 队列链表，先进先出 FIFO
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "QueueLink.h"

// 拷贝元素数据到节点中
static void CopyDataToNode(NodeType *pNode, ItemType *pItem)
{
    if (pItem)
    {
        pNode->item = *pItem;
    }
}

// 初始化队列
void InitializeQueue(QueueType *pq)
{
    if (pq == NULL)
    {
        return ;
    }

    pq->front = pq->tail = NULL;
    pq->items = 0;
}

// 判断是否是空表
bool QueueIsEmpty(const QueueType *pq)
{
    if (pq == NULL)
    {
        return false;
    }

    if (pq->items == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

// 判断是否已满
bool QueueIsFull(const QueueType *pq)
{
    if (pq == NULL)
    {
        return false;
    }

    if (pq->items == MAXQUEUE)
    {
        return true;
    }
    else
    {
        return false;
    }
}

// 获取表中节点个数
int QueueItemCount(const QueueType *pq)
{
    if (pq == NULL)
    {
        return false;
    }

    return pq->items;
}

// 向链表尾添加节点
bool QueueAddItem(QueueType *pq, ItemType *pItem)
{
    NodeType *pNewNode;
    NodeType *p = pq->tail;

    if (pq == NULL)
    {
        return false;
    }

    pNewNode = (NodeType*)malloc(sizeof(NodeType));
    if (pNewNode == NULL)
    {
        return false;
    }
    CopyDataToNode(pNewNode, pItem);
    pNewNode->next = NULL;
    if (pq->items == 0)
    {
        pq->front = pNewNode;
    }
    else
    {
        pq->tail->next = pNewNode;
    }
    pq->tail = pNewNode;
    pq->items++;

    return true;
}

// 比较 返回 <0 p1<P2; =0 p1 = P2; >0 p1 > P2
int Compare(ItemType *p1, ItemType *p2)
{
    int res = 0;

    if (p1==NULL || p2 == NULL)
    {
        return 0;
    }
    res = *p1 - *p2;
    return res;
}

// 从队列头删除一个节点
bool QueueDelItem(QueueType *pq, ItemType *pItem)
{
    NodeType *p = NULL;

    if (pq == NULL)
    {
        return false;
    }

    if (pq->items == 0)
    {
        return false;
    }

    if (pq->front)
    {
        *pItem = pq->front->item;
        p = pq->front;
        pq->front = pq->front->next;
        free(p);
        pq->items--;
    }

    return true;
}


// 清空队列
void EmptyTheQueue(QueueType *pq)
{
    NodeType *p = pq->front;
    NodeType *pTemp = NULL;

    while (p != NULL)
    {
        pTemp = p->next;
        free(p);
        p = pTemp;
    }
    pq->front = NULL;
    pq->tail  = NULL;
    pq->items = 0;
}

//////////////////////////////////
// 测试fun
void PrintData(ItemType *pItem)
{
    //printf("Data:%d\n", pItem->rating);
}

int main(void)
{
    int sum = 0;
    int i = 0;
    QueueType queue;  // 队列指针
    ItemType  temp;

    InitializeQueue(&queue);
    if (QueueIsFull(&queue))
    {
        puts("err 1");
        exit(1);
    }
    
    for (i = 1; i <100; i++)
    {
        temp = i;
        QueueAddItem(&queue, &temp);
    }
    
    for (i = 1; i <120; i++)
    {
        temp = 0;
        if(QueueDelItem(&queue, &temp))
        {
            printf("%d ", temp);
        }
    }

    EmptyTheQueue(&queue); // 清空
    puts("Bye!");

    return 0;
} 

本文地址：https://blog.csdn.net/rabbit200808/article/details/107891179