数据结构——队列的基本操作

队列：简称队，一种受限的线性表，只允许在表的一端进行插入，在表的另一端进行删除操作（先进先出）
队头：进行删除的一端
队尾：进行插入的一端
空队列：不含任何元素的空表

队列的基本操作：
队列分为顺序队列、循环队列和链式队列，顺序队列容易发生假溢出现象（队尾超过限定长度），故不常用，下面是循环队列和链式队列的基本操作

附上链式队列的指针变化图：

代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MaxSize 50

/*由于非循环队列会造成假溢出现象，故使用循环队列，提高空间利用率*/
/*==================循环队列基本操作================================*/
/*
typedef struct
{
    int data[MaxSize];
    int front;
    int rear;
}SqQueue;

void InitQueue(SqQueue &Q)
{
    Q.front = Q.rear = 0;
}

int QueueEmpty(SqQueue Q)
{
    if(Q.rear == Q.front)
    {
        printf("循环队列为空！\n");
        return 1;
    }
    else
    {
        printf("循环队列未空！\n");
        return 0;
    }
}

int QueueLength(SqQueue Q)
{
    if(Q.front == Q.rear)
    {
        return 0;
    }
    else
    {
        int t = (Q.rear-Q.front+MaxSize)%MaxSize;
        return t;
    }
}

void GetHead(SqQueue Q,int &x)
{
    if(Q.front == Q.rear)
    {
        printf("循环队列为空，没有对头元素！");
    }
    else
    {
        x = Q.data[Q.front];
    }
}

void EnQueue(SqQueue &Q,int x)
{
    if((Q.rear+1)%MaxSize == Q.front)
    {
        printf("循环队列已满，无法入队！");
    }
    else
    {
        Q.data[Q.rear] = x;
        Q.rear = (Q.rear+1)%MaxSize;
    }
}

void DeQueue(SqQueue &Q,int &x)
{
    if(Q.front == Q.rear)
    {
        printf("循环队列为空，无法出队！");
    }
    else
    {
        x = Q.data[Q.front];
        Q.front = (Q.front+1)%MaxSize;
    }
}

void Print(SqQueue Q)
{
    while(Q.front != Q.rear)
    {
        printf("%d ",Q.data[Q.front]);
        Q.front = (Q.front+1)%MaxSize;
    }
}
*/

/*==================链式队列基本操作(表头删除元素，表尾插入元素)===============================*/
typedef struct LinkNode
{
    int data;
    struct LinkNode *next;
}LinkQueueNode;

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

void InitQueue(LinkQueue *L)
{
    LinkQueueNode *head;
    head = (LinkQueueNode*)malloc(sizeof(LinkNode));
    head->next = NULL;
    L->front = L->rear = head;
}

int QueueEmpty(LinkQueue *L)
{
    if(L->front == L->rear)
    {
        printf("链队列为空！");
        return 1;
    }
    else
    {
        printf("链队列不为空！");
        return 0;
    }
}

int QueueLength(LinkQueue *L)
{
    LinkQueueNode *p;
    p = L->front->next;
    int count = 0;
    while(p->next != NULL)
    {
        p = p->next;
        count++;
    }
    return count;
}

void EnQueue(LinkQueue *L,int x)
{
    LinkQueueNode *newNode;
    LinkQueueNode *p;
    newNode = L->rear;
    p = (LinkQueueNode*)malloc(sizeof(LinkNode));
    p->data = x;
    p->next = newNode->next;
    newNode->next = p;
    L->rear = p;
}

void DeQueue(LinkQueue *L,int &x)
{
    if(L->front == L->rear)
    {
        printf("链队列为空，无元素可删除！");
    }
    else
    {
        LinkQueueNode *head;
        LinkQueueNode *p;
        head = L->front;
        p = head->next;
        head->next = p->next;
        x = p->data;
        free(p);
    }
}

void Print(LinkQueue *L)
{
    LinkQueueNode *head;
    head = L->front;
    while(head->next!=NULL)
    {
        printf("%d ",head->next->data);
        head = head->next;
    }
}
int main() {
    /*
    SqQueue Q;
    InitQueue(Q);
    int n;
    printf("请输入要存放的元素个数：");
    scanf("%d",&n);
    int x;
    printf("请输入要存放的元素：");
    for(int i=0; i<n; i++)
    {
        scanf("%d",&x);
        EnQueue(Q,x);
    }
    DeQueue(Q,x);
    printf("%d\n",x);
    Print(Q);
     */



    LinkQueue L;
    InitQueue(&L);
    EnQueue(&L,3);
    EnQueue(&L,5);
    Print(&L);
    int x;
    DeQueue(&L,x);
    printf("出队的元素为：%d\n",x);
    printf("剩余元素为：");
    Print(&L);
    return 0;
}