队列的顺序存储结构

1.队列的定义
队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（FIFO）的线性表，允许插入的一端成为队尾，允许删除的一端成为队头。

直接上代码

#include <stdio.h>

#define SUCCESS     0
#define FAILURE    -1
#define MAXSIZE  1000

struct Quene
{
    int data[MAXSIZE];
    int front;
    int rear;
};

typedef struct Quene SeQuene;

int QueneInit(SeQuene *Q)
{
    Q->front = 0;//队头指针
    Q->rear = 0;//队尾指针不存放数据
    return SUCCESS;
}

int QueneLength(SeQuene *Q)
{
    return (Q->rear - Q->front + MAXSIZE) % MAXSIZE;//队列的长度公式
}

int QueneEnter(SeQuene *Q, int e)//入队列
{
    if((Q->rear + 1) % MAXSIZE == Q->front)//队列满的情况
    {
        return FAILURE;
    }

    Q->data[Q->rear] = e;//将元素e赋值给队尾
    Q->rear = (Q->rear + 1) % MAXSIZE;//rear指针向后移动一个位置，若到最后则转到数组头部

    return SUCCESS;
}

int QueneDelete(SeQuene *Q, int *e)
{
    if(Q->rear == Q->front)//判断队列是否为空队列
    {
        return FAILURE;
    }

    *e = Q->data[Q->front];//将队头元素赋值给e
    Q->front = (Q->front + 1) % MAXSIZE;//front指针向后移动一个位置，若到最后则转到数组头部

    return *e;
}

int QueneGet(SeQuene *Q)//获取队头元素
{
    if(Q->rear == Q->front)
    {
        return FAILURE;
    }

    int e;

    e = Q->data[Q->front];

    return e;
}

int main()
{
    int ret, i, e;
    SeQuene Q;

    ret = QueneInit(&Q);
    if(ret == SUCCESS)
    {
        printf("Init Success!\n");
    }

    else
    {
        printf("Init Failure!\n");
    }

    ret = QueneLength(&Q);
    printf("the length is %d\n", ret);

    for(i = 0; i < 10; i++)
    {
        ret = QueneEnter(&Q, i);
        if(ret == SUCCESS)
        {
            printf("Enter %d success!\n", i);
        }

        else
        {
            printf("Enter %d failure!\n", i);
        }
    }

    ret = QueneLength(&Q);
    printf("the length is %d\n", ret);

    for(i = 0; i < 5; i++)
    {
        ret = QueneDelete(&Q, &e);
        printf("Delete %d success!\n", e);
    }

    ret = QueneLength(&Q);
    printf("the length is %d\n", ret);

    ret = QueneGet(&Q);
    printf("The front enum is %d\n", ret);
    return 0;
}