数据结构-队列(queue)

队列（queue）是一种采用先进先出(FIFO)策略的抽象数据结构，它的想法来自于生活中排队的策略。顾客在付款结账的时候，按照到来的先后顺序排队结账，先来的顾客先结账，后来的顾客后结账。

队列实现

同栈的实现一样，队列的实现也有数组实现和链表实现两种方式。

数组实现

先来看看数组实现的方法。栈使用top变量记录栈顶的位置，而队列则使用front和rear分别队列第一个元素和最后一个元素的位置。

#define SIZE 20
typedef struct queue
{
    int arr[SIZE];
    int front;
    int rear;

} Queue;

入队、出队操作很简单。入队时，通过rear的位置判断队列是否已满。如果没有满，则将rear后移一位，将新元素放置在rear所在位置。出队时，也可以通过rear的位置判断队列是否为空。如果不空，则只需将front后移一位即可。 获取队头元素，判断队列不空，则只需返回front指向位置的元素即可。

哇塞！好简单啊！这样就完成了队列的实现啊！太天真了。。。想一下，通过出队操作将数据弹出队列后，front之前的空间还能够再次得到吗？不能。所以使用普通数组实现队列，就再也不能使用front之前的空间了，这会导致大量空间丢失。

循环数组

为了解决这个问题，将普通数组换成循环数组。在循环数组中，末尾元素的下一个元素不是数组外，而是数组的头元素。这样就能够再次使用front之前的存储空间了。

哇塞！有解决了这个问题。可以开始码代码了！且慢，在实现修改入队和出队操作之前，再深思一步，这时是否还能简单通过判断rear的位置来判断队列空或满呢？当然不可以。那是否可以考虑front和rear之间的位置关系呢？考虑如下两种边界情况：

在这两种情况下，rear都在front前一个位置，无法判断此时队列满还是空。为了解决这个问题，通常采用的最简单的方法就是，使用一个counter记录队列中元素个数。修改队列定义为下：

#define SIZE 20

typedef struct queue
{
    int arr[SIZE];
    int front;
    int rear;
    int counter;

} Queue;

Init(Queue *q)
{
    q->front = 0;
    q->rear = -1;
    q->counter = 0;
} 


bool IsFull(Queue *q)
{
    return (q->counter >= SIZE);
}

void EnQueue(Queue *q, int val)
{
    if(IsFull(q))
        return;

    q->rear = (q->rear + 1) % SIZE;
    q->arr[q->rear] = val;
    q->counter++;
}


bool IsEmpty(Queue *q)
{
    return (q->counter <= 0);
}


void DeQueue(Queue *q)
{
    if (IsEmpty(q))
        return;

    q->front = (q->front + 1) % SIZE;
    q->counter--;

}

//get the front element from queue
int Front(Queue *q)
{
    if (IsEmpty(q))
        return;

    return q->arr[q->front];
}

另外一种方法是，在数组中空出一个位置，用以标记队列是否已满。

bool IsFull(Queue *q)
{
    return ((q->rear + 2) % SIZE == q->front);
}

bool IsEmpty(Queue *q)
{
    return ((q->rear + 1) % SIZE == q->front);
}

有时候，rear表示队尾元素的下一个位置，即表示即将插入元素的位置。

此时，判断队列的操作应该修改如下：

#define SIZE 20

typedef struct queue
{
    int arr[SIZE];
    int front;
    int rear;

} Queue;


Init(Queue *q)
{
    q->front = 0;
    q->rear = 0;
} 


bool IsFull(Queue *q)
{
    return ((q->rear + 1) % SIZE == q->front);
}

void EnQueue(Queue *q, int val)
{
    if(IsFull(q))
        return;

    q->arr[q->rear] = val;
    q->rear = (q->rear + 1) % SIZE;
}


bool IsEmpty(Queue *q)
{
    return (q->rear == q->front);
}


void DeQueue(Queue *q)
{
    if (IsEmpty(q))
        return;

    q->front = (q->front + 1) % SIZE;

}


int Front(Queue *q)
{
    if (IsEmpty(q))
        return;

    return q->arr[q->front];
}

链表实现

队列的数组实现比较麻烦，需要考虑各种边界情况，所以通常使用链表形式来实现队列。

使用单向链表来实现链式队列，链式队列中存储front和rear即可。

typedef struct node
{
    int val;
    struct node *next;
}Node;

typedef struct queue
{
    Node *front;
    Node *rear;
};

为了方便实现，链式队列中的front表示链表的头节点，而front的next才表示队头。链式队列的入队和出队操作如下图所示。从图中可以看出链式队列的实现采用尾进头出的策略。

在链式队列中，不需要考虑队列是否已满，只要内存足够就可以一直分配空间。而当front和rear都指向头节点的时候，则表示此时队列为空。

bool IsEmpty(Queue *q)
{
    return (q->front == q->rear);
}

入队时移动rear指向最后一个元素即可。

Node* CreateNode(int val)
{
    Node *newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL)
        return NULL;
    else {
        newNode->val = val;
        newNode->next = NULL;
        return newNode;
    }
}


void EnQueue(Queue *q, int val)
{
    Node *newNode = CreateNode(val);
    if (newNode == NULL)
        return;
    else {
        q->rear->next = newNode;
        q->rear = q->rear->next;
    }
}

出队时，不需要移动front指针，只需将其next指针指向下一个next元素即可。q->front->next = q->front->next->next; 但是需要考虑一种特殊情况，即当队列中只剩下一个元素时，还需要使rear指针重新指向头节点。

int Front(Queue *q)
{
    if (IsEmpty(q))
        return -1;
    else
        return (q->front->next->val);
}

void DeQueue(Queue *q)
{
    if (IsEmpty(q))
        return;
    else 
    {
        Node *deNode = q->front->next;
        q->front->next = deNode->next;

        if (q->rear == deNode) //only one element
            q->rear = q->front;

        free(deNode);
    }
}