队列的实现：数组实现和链表实现

队列：一种先进先出的线性表（FIFO）

1，链表实现的队列：

• 数据定义：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NODE_LEN 4
typedef struct
{
    int num;
    char auch[NODE_LEN];
}Q_NODE_T;
typedef struct
{
    Q_NODE_T stNode;
    struct QList_T *pNext;
}QList_T;

• 入队列操作：

入队操作包括了创建队列。

队列入队原则：插入链表尾部

int InQueue(Q_NODE_T Date,QList_T **pHead)
{
    QList_T *Node=NULL;
    QList_T *pTemp=NULL;
    Node=(QList_T*)malloc(sizeof(Qlist_T));
    memset(Node,0,sizeof(Qlist_T));
    memcpy(&Node->stNode,&Date,sizeof(Q_NODE_T));
    //如果是新建队列，则新建节点即为头节点
    if(NULL==*pHead)
    {
        *pHead=Node;
    }
    //如果是已有队列，则将新节点插入队尾
    else
    {
        pTemp=*pHead;
        //循环到队尾
        while(NULL!=pTemp->pNext)
        {
            pTemp=pTemp->pNext;
        }
        pTemp->pNext=Node;
    }
    return 0;
}

• 出队列操作：

出队原则：从队首取节点，赋值，释放节点

int OutQueue(Q_NODE_T *Date,Qlist_T **pHead)
{
    Qlist_T ptmp=NULL;
    
    ptmp=*pHead;
    memcpy(Date,&ptmp->stNode,sizeof(Q_NODE_T));
    *pHead=ptmp->pNext;
    free(ptmp);
    return 0;
}

• 测试main函数：

测试了几种情况：

1，节点循环入队；2，单节点入队后是不是按队列要求出队；3，循环出队

void main()
{
    Qlist_T *pHead=NULL;
    Q_NODE_T stNode={0};
    int i=0;
    //循环入队测试
    for(i=1;i<100;i++)
    {
        stNode.num=i;
        InQueue(stNode,&pHead);
    }
    //单节点入队，再出队，看看是否按照FIFO原则出队
    stNode.num=100;
    InQueue(stNode,&pHead);
    OutQueue(&stNode,&pHead);
    printf("\n[%d]\n",stNode.num);
    
    stNode.num=101;
    InQueue(stNode,&pHead);
    OutQueue(&stNode,&pHead);
    printf("\n[%d]\n",stNode.num);
    //循环出队
    for(i=1;i<50;i++)
    {
        OutQueue(&stNode,&pHead);
        printf("\n[%d]\n",stNode.num);
    }
    getchar();
}

2，数组实现的队列：

数组队列的奥义在于：

1，固定长度的队列

2，队头，队尾指针的走动

3，到达数组最大长度后的指针反转（从指向数组最后反转到指向数组的最前）

• 数据定义：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NODE_LEN 4
#define QUEUE_LEN 100
typedef struct
{
    int num;
    char auch[NODE_LEN];
}Q_NODE_T;

Q_NODE_T g_QueueList[QUEUE_LEN];
Q_NODE_T *g_Head=NULL;
Q_NODE_T *g_Tail=NULL;

• 初始化队列：

int init_queue()
{
    g_Head=&g_QueueList[0];
    g_Tail=&g_QueueList[0];
    return 0;
}

• 入队操作：

int InQueue(Q_NODE_T Node)
{
    if(g_Tail!=&g_QueueList[QUEUE_LEN-1])
    {
        memcpy(g_Tail,&Node,sizeof(Q_NODE_T));
        g_Tail++;
    }
    //到达数组最大值后需要反转指针
    else
        g_Tail=&g_QueueList[0];
    if(g_Head==g_Tail)
    {
        printf("\nQueue is Full!\n");
        return -1;
    }
    return 0;
}

• 出队操作：

int OutQueue(Q_NODE_T *Node)
{
    if(g_Head==g_Tail)
    {
        printf("\nQueue is Empty\n");
        return -1;
    }
    memcpy(Node,g_Head,sizeof(Q_NODE_T));
    memset(g_Head,0,sizeof(Q_NODE_T));
    g_Head++;
    //到达数组最大值后需要反转指针
    if(g_Head=&g_QueueList[QUEUE_LEN-1])
    {
        g_Head=&g_QueueList[0];
    }
    return 0;
}

• 测试main函数：

    这次做这个数组队列其实有bug：如果队首不动，一直增加队列的节点会导致，当节点大于数组长度时会覆盖以前队首的数据内容。想到的解决办法是增加一个变量记录当前队列长度，用这个长度去卡最大节点数，自己没写。

void main()
{
    Q_NODE_T stNode={0};
    int i=0;
    init_queue();
    for(i=1;i<QUEUE_LEN;i++)
    {    
        stNode.num=i;
        InQueue(stNode);
    }
    for(i=1;i<50;i++)
    {    
        OutQueue(&stNode);
        printf("\n[%d]\n",stNode.num);
    }

}

代码都是经过测试的，如果有编译问题的话那就是手打失误引起的。