队列

定义

队列是一种特殊的线性表，它只允许对线性表的头尾进行操作，满足FIFO（先进先出）的规则。通常有两种实现方式，顺序结构和链式结构。一般顺序结构实现，都采用了循环队列的方式来减少空间的浪费。而链式结构则不需要做循环队列来减少空间浪费，因为本身就是动态生成结点的。对于入队和出队操作，两种方式都在对应在表头和表尾位置，时间复杂度都是相同的，这个会在相关操作和时间复杂度分析中具体分析。

循环队列图

链表队列图

相关操作以及时间复杂度分析

入队

队列里有两个指针front和rear分别指向线性表的表头和表尾，入队的时候将数据放入rear指针指向内存空间然后将rear指向下一个结点。对于这个操作，两种实现方式各部相同，顺序表实现的是循环队列，入队之后rear指针指向下一个结点的操作是rear = (rear+1)%CAPACITY； CAPACITY为队列的容量。而对于链表实现的队列来说，只要将入队结点插入到rear指向的队尾结点之前即可，不需要移动rear指针。这两个操作的时间复杂度都是O（1）；

出队

出队与入队刚好相反，它是对front指针进行的操作，对于顺序表实现的队列来说，就是将front = (front+1)%CAPACITY;CAPACITY为队列的容量。而对于链表实现的队列来说，就是将front指针指向的第一个结点删除。这两个操作的时间复杂度也是O（1）；

获取队头元素

对于顺序表实现的队列来说，获取队头元素，就是获取front指针指向内存单元的数据即可；对于链表实现的队列就是，front指向结点的data数据域。时间复杂度也都是O（1）。

队列判空和判满

对于顺序表实现的循环队列这是一个十分重要的地方，经常会用来考试。由于队列满和队列空front指针都会等于rear指针，所以我们有两种实现方式。第一种加标志位，如果front=rear并且标志位显示是满，则判断队列为满；如果front=rear，并且标志位显示为空，则判断队列为空。第二种是比较常见的实现方式，就是在队列中少放一个元素即文章最开始循环队列的实现图那样。这样子front=rear队列为空，当(rear+1)%CAPACITY = front; CAPACITY位队列容量; 队列为满。而对于链表实现的队列来说，通常在front指针数据域内记录当前队列元素个数，如果front->data = CAPACITY,则判断队列为满； 两种实现方式判断队列空或满的时间复杂度均为O（1）；

销毁队列

对于顺序表实现的队列来说，只需要free掉front指针指向的内存块即可销毁整个队列空间，然后将front=rear=0即可；而对于链表实现的队列来说，需要遍历整个队列，一个个释放队列的结点空间，并且将front=rear指针； 显然前者的时间复杂度为O（1）,后者的时间复杂度为O(n);

实现代码

循环队列

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

#define CAPACITY 10
#define ERROR -50000;

typedef struct{
    int *data;
    int front; // 队头指针
    int rear; // 队尾指针
}CycleQueue;

void init_queue(CycleQueue *queue)
{
    queue->data = (int *)malloc(CAPACITY*sizeof(int));
    queue->front = 0;
    queue->rear = 0;
}

/*
 * 判断循环队列是否为空有三种方法
 * 1. 如果循环队列是利用标志位来区分当front==rear的时候是满还是空的，只要结合标志位&&front==rear判断即可
 * 2. 如果循环队列是利用计数器count来判断是否为空的，只要count=0即为空，count!=0&&front==rear即为满
 * 3. 如果循环队列是利用少放一个元素的方式来判断的那么当front == rear为空，当(rear+1)%CAPACITY == front为满
 * 下列方法采用第三种
 */
int is_empty(CycleQueue queue)
{
    return queue.front == queue.rear;
}


/*
 * 判断队列是否满
 */
int is_full(CycleQueue queue)
{
    return (queue.rear+1)%CAPACITY == queue.front;
}

/*
 * 获取队列内元素个数
 */
int get_length(CycleQueue queue)
{
    return (queue.rear - queue.front + CAPACITY)%CAPACITY;
}

/*
 * 进队列
 */
void enter_queue(CycleQueue *queue, int value)
{
    if((queue->rear+1)%CAPACITY == queue->front)
        return; // 此时队列已经满了
    *(queue->data + queue->rear) = value;
    queue->rear = (queue->rear + 1)%CAPACITY;
}


/*
 * 出队列
 */
int pop_queue(CycleQueue *queue)
{
    if(queue->front == queue->rear)
        return ERROR; // 此时队列是空的
    int data = *(queue->data + queue->front);
    queue->front = (queue->front + 1)%CAPACITY;
    return data;
}

/*
 * 清空队列
 */
void clear(CycleQueue *queue)
{
    queue->front = queue->rear = 0;
}

/*
 * 销毁队列
 */
void destroy(CycleQueue *queue)
{
    free(queue->data);
    queue->front = queue->rear = 0;
}

/*
 * 打印队列信息
 */
void print_queue_info(CycleQueue queue)
{
    printf("The length of queue is %d\nData: ", get_length(queue));
    while(queue.front != queue.rear){
        printf("%d ", *(queue.data + queue.front));
        queue.front = (queue.front + 1)%CAPACITY;
    }
    printf("\n");
}

int main()
{
    CycleQueue queue;
    init_queue(&queue);

    for(int i=0; i<CAPACITY-1; i++)
        enter_queue(&queue, i);

    print_queue_info(queue);

    int out_data = pop_queue(&queue);
    printf("after pop the element %d\n", out_data);
    print_queue_info(queue);

    enter_queue(&queue, 1000);
    printf("after enter the element %d", 100);
    print_queue_info(queue);


    return 0;
}

链表队列

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

#define ERROR -500000

typedef struct QNode *PQNode;

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

typedef struct {
    PQNode front;
    PQNode rear;
}LinkedQueue;

void init_queue(LinkedQueue *queue)
{
    queue->front = queue->rear = (PQNode)malloc(sizeof(QNode));
    queue->front->next = NULL;
    queue->front->data = 0;
}

void destroy(LinkedQueue *queue)
{
    while(queue->front){
        queue->rear = queue->front->next;
        free(queue->front);
        queue->front = queue->rear;
    }
}

void enter_queue(LinkedQueue *queue, int value)
{
    PQNode node = (PQNode)malloc(sizeof(QNode));
    node->data = value;
    node->next = NULL;
    queue->rear->next = node;
    queue->rear = node;
    queue->front->data++;
}

int pop_queue(LinkedQueue *queue)
{
    if(!queue->front->next)
        return ERROR;
    PQNode p = queue->front->next;
    int data = p->data;
    queue->front->next = p->next;
    if(queue->rear == p)
        queue->rear = queue->front; // 这一步很重要，否则queue->rear会变为野指针
    free(p);
    queue->front->data--;
    return data;
}

int get_length(LinkedQueue queue)
{
    return queue.front->data;
}

int is_empty(LinkedQueue queue)
{
    return queue.front->data == 0;
}

void print_queue_info(LinkedQueue queue)
{
    printf("The length of linked queue is %d\nData: ", queue.front->data);
    while(queue.front->next){
        printf("%d ", queue.front->next->data);
        queue.front = queue.front->next;
    }

    printf("\n");
}


int main()
{
    LinkedQueue queue;
    init_queue(&queue);
    for(int i=0;i<10;i++)
        enter_queue(&queue, i);
    print_queue_info(queue);

    int front = pop_queue(&queue);
    printf("after pop the element %d\n", front);
    print_queue_info(queue);

    printf("queue is %s", is_empty(queue)?"empty":"not empty");

    return 0;
}