数据结构队列的基本操作

#define MAXSIZE 1024

//顺序队列的结构定义
typedef struct
{
    int data[MAXSIZE];      //存储数据的数组
    int rear,front;         //头尾指针
    int m;                  //用于记录队列中的总人数
}SeQueueNode,* SeQueue;


//创建一个队列
SeQueue Create_SeQueue()
{
    SeQueue p;
    p = (SeQueue)malloc(sizeof(SeQueueNode));
    p->rear = -1;
    p->front = -1;
    p->m = 0;
    return p;
}


//判断队列是否为空
int isEmpty_SeQueue(SeQueue p)
{
    if(p->rear == p->front == -1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}


//入队操作
int Push_SeQueue(SeQueue p,int x)
{
    if(p->m == MAXSIZE)
        return 0;
    else
    {
        p->data[++(p->rear)] = x;
        return 1;
    }
}

//出队操作
int Pop_SeQueue(SeQueue p,int *x)
{
    if(p->m == 0)
        return 0;
    else
    {
        x = p->data[++(p->front)];
        return 1;
    }
}

//顺序的队列如果数据数组的容量够大则不太容易发生假溢出
//但是如果数据数组的容量很小则非常容易发生假溢出
//假溢出：双指针已经到达了数组最后但是前面的数据位置没有使用的情况


//循环队列
typedef struct
{
    int data[MAXSIZE];
    int front,rear;
    int num;
}CSeQueueNode,* CSeQueue;

//构建一个空的循环队列
CSeQueue Create_CSeQueue()
{
    CSeQueue p;
    p = (CSeQueue)malloc(sizeof(CSeQueueNode));
    p->front = p->rear = MAXSIZE - 1;
    p->num = 0;
    return p;
}

//循环队列入队
int Push_CSeQueue(CSeQueue p,int x)
{
    if(p->num == MAXSIZE)
        return 0;
    else
    {
        p->rear = (p->rear + 1) % MAXSIZE;
        p->data[p->rear] = x;
        p->num++;
        return 1;
    }
}

//循环队列出队
int Pop_CSeQueue(CSeQueue p,int *x)
{
    if(p->num == 0)
        return 0;
    else
    {
        *x = p->data[p->front];
        p->front = (p->front + 1) % MAXSIZE;
        p->num--;
        return 1;
    }
}

//循环队列判空
int isEmpty_CSeQueue(CSeQueue p)
{
    if(p->num == 0)
        return 1;
    else
        return 0;
}






//链队列实现
//结构构造
typedef struct node
{
    int data;
    struct node *next;
}QNode;

typedef struct
{
    QNode *front,*rear;
}LQueueNode,* LQueue;


//创建一个空队列
LQueue Create_LQueue()
{
    LQueue q;
    QNode *p;
    q = (LQueue)malloc(sizeof(LQueueNode));
    p = (QNode *)malloc(sizeof(QNode));
    p->next = NULL;
    q->front = p;
    q->rear = p;
    return q;
}


//链队入队
void Push_LQueue(LQueue q,int x)
{
    QNode *p;
    p = (QNode *)malloc(sizeof(QNode));
    p->data = x;
    p->next = NULL;
    q->rear->next = p;
    q->rear = p;
    return ;
}

//链队出队
int Pop_LQueue(LQueue q,int *x)
{
    QNode *p;
    if(isEmpty_LQueue(q))
        return 0;
    else
    {
         p = q->front->next;
         q->front->next = p->next;
         *x = p->data;
         free(p);
         if(q->front->next == NULL)
         {
             q->rear = q->front;
         }
         return 1;
    }
}

//判断链队是否为空
int isEmpty_LQueue(LQueue p)
{
    if(p->front == p->rear)
        return 1;
    else
        return 0;
}