队列

链队列
用链表表示的队列简称为链队列。
空链队列的判决条件为头指针和尾指针均指向头结点。

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

 typedef struct QNode{
        int data;
        struct QNode *next;
    }QNode, *QueuePtr;

    typedef struct {
        QueuePtr front;
        QueuePtr rear;
    }* LinkQueue;

    int InitQueue(LinkQueue p){
        p->front = p->rear = (QueuePtr)malloc(sizeof(QueuePtr));
        if(!p->front) return 0;
        p->front->next = NULL;
        return 1 ;
    }



    void DestoryQueue(LinkQueue p){
        while(p->front){
            p->rear = p->front->next;
            free(p->front);
            p->front = p->rear;
        }
    }

    void EnQueue(LinkQueue p,int item){
        QueuePtr PtrQ;
        PtrQ = (QueuePtr)malloc(sizeof(QueuePtr));
        if(!PtrQ) return;
        PtrQ->data = item;
        PtrQ->next = NULL;
        p->rear->next = PtrQ;
        p->rear = PtrQ;
    }

    int DeQueue(LinkQueue p){
        QueuePtr PtrQ;
        int e;
        if(p->front == p->rear) return 0;
        PtrQ = p->front->next;
        e = PtrQ->data;
        p->front->next = PtrQ->next;
        if(p->rear == PtrQ) p->rear = p->front;
        free(p);
        return 1;
    }

循环队列

初始化建空队列时，令front=rear=0,每当插入新的队列元素时，头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个位置

//循环队列
    #define MAXSIZE 100;
    typedef struct {
        ElementType Data[MAXSIZE];
        int rear;
        int front;
    } Queue;

    // 入队
    void AddQ(Queue *PtrQ ,ElementType item){
        if((PtrQ->rear+1)%MAXSIZE == PtrQ->front){
            printf("队列已满\n");
            return；
        }else{
            PtrQ->Data[rear] = item;
            PtrQ->rear = (PtrQ->rear+1)%MAXSIZE;
        }
    }
    //出队
    ElementType DeleteQ(Queue *PtrQ){
        ElementType e;
        if(PtrQ->front == PtrQ->rear){
            printf("队列为空\n");
            return;
        }else{
            e = PtrQ->Data[PtrQ->front];
            PtrQ->front = (PtrQ->front+1)%MAXSIZE;
            return e;
        }
    }