队列 （链式结构）

头文件MyQueue.h

#ifndef _MYQUEUE_H_
#define _MYQUEUE_H_

#include <stdlib.h>
#include <stdbool.h>

typedef struct Node *pNode;
typedef struct Queue *pQueue;               // 相当于 pHead

struct Node
{
    int data;
    pNode next;
};

struct Queue
{
    int length;

    pNode front;                            // 指向队列中的第一个节点，相当于链表中的头节点里的 next
    pNode rear;                             // 指向队列中的最后一个节点，指向队尾
};

pQueue Create (void);                       // 创建队列
int GetLength (pQueue queue);               // 获取队列长度
bool IsEmpty (pQueue queue);                // 判断队列是否为空
void Insert (pQueue queue, int val);        // 插入元素 （入列）
int GetHead (pQueue queue);                 // 获取队首元素值
pNode Delete (pQueue queue);                // 删除元素 （出列）
void CLear (pQueue queue);                  // 销毁队列

pQueue
Create (void)
{
    pQueue queue = (pQueue)malloc (sizeof (struct Queue));

    queue -> front = NULL;
    queue -> rear = NULL;
    queue -> length = 0;

    return queue;
}

int
GetLength (pQueue queue)
{
    return queue -> length;
}

bool
IsEmpty (pQueue queue)
{
    if (queue -> length == 0)
    {
        return true;
    }

    return false;
}

void
Insert (pQueue queue, int val)
{
    pNode p = (pNode)malloc (sizeof (struct Node));
    p -> data = val;
    p -> next = NULL;

    if (IsEmpty (queue))                                // 若队列为空，这队首队尾都指向新节点
    {
        queue -> front = p;
        queue -> rear = p;
    }
    else                                                // 非空时，从队尾入列
    {
        queue -> rear -> next = p;
        queue -> rear = p;
    }

    queue -> length ++;
}

int
GetHead (pQueue queue)
{
    if (IsEmpty (queue))
    {
        printf ("Empty Queue!");

        return -1;
    }

    return queue -> front -> data;
}

pNode
Delete (pQueue queue)
{
    if (IsEmpty (queue))
    {
        printf ("Empty Queue!");

        return NULL;
    }

    pNode p = queue -> front;                           // 从队首出列
    queue -> front = p -> next;

    queue -> length --;

    return p;
}

void
Clear (pQueue queue)
{
    if (IsEmpty (queue))
    {
        printf ("Empty Queue needn't clear !\n");
    }

    pNode p = queue -> front;

    while (p -> next != NULL)
    {
        free (p);

        p = p -> next;
    }

    queue -> length = 0;

    printf ("Clear !\n");
}

#endif // _MYQUEUE_H_

测试文件main.h

#include "MyQueue.h"

#define MAXN 10                                     // 队列长度

int main (void)
{
    pQueue queue = Create ();
    srand ((unsigned) time (0));                    // 生成随机数

    for (int i = 0; i < MAXN; i ++)                 // 随机数入列
    {
        Insert (queue, rand () % 100);
    }

    printf ("队列长度: %d \n", GetLength (queue));
    printf ("队首元素: %d \n", GetHead (queue));
    printf ("队首元素\t出队元素\n");

    while (GetLength (queue) != 0)
    {
        int ret = GetHead (queue);                  // 获取当前队首值
        printf ("%2d  \t\t", ret);

        ret = Delete (queue) -> data;               // 获取出列元素值
        printf ("%2d \n", ret);
    }

    Clear (queue);

    system ("pause");
    return 0;
}

结语

        用链表来实现队列也成为链式队列，在链式队列中用 front 和 rear 指针指向队首和队尾，在队首 front 处删除元素，在队尾 rear 处插入元素， 简言之 从头出列，从后入列。