循环队列实现

定义

循环队列是一种基于数组的队列实现，它在队列满时可以循环利用空间，使得队列的操作更加高效。循环队列通过将队列的首尾相连，形成一个环状结构，从而避免了队列元素的搬移。在循环队列中，队尾指针紧接着指向队头位置，形成一个循环。

特点

循环队列需要维护两个指针：队头指针 front 和队尾指针 rear，以及一个固定大小的数组 data 来存储队列元素。初始时，队头和队尾指针都指向队列的第一个位置，即 front = rear = 0。

在循环队列中，入队和出队操作分别对应于队尾指针的后移和队头指针的后移。当队尾指针 rear 到达数组的末尾时，需要循环回到数组的起始位置，即 rear = (rear + 1) % MAX_SIZE。同样，当队头指针 front 到达数组的末尾时，也需要循环回到数组的起始位置，即 front = (front + 1) % MAX_SIZE。

在循环队列中，判断队列是否为空的条件是 front == rear，判断队列是否为满的条件是 (rear + 1) % MAX_SIZE == front。

优点

当队列满时，可以将新元素添加到队尾，而无需进行数据搬移，从而提高了入队操作的效率。同时，出队操作也无需进行数据搬移，只需要移动队头指针即可。

主要区别

1. 实现方式：

   • 普通队列使用数组或链表实现，每当队列满时，需要进行数据搬移，即在队列的末尾添加新元素时，可能需要将之前的元素向后移动，以腾出空间。这样的实现方式可能导致频繁的数据搬移操作，影响队列的性能。
   • 循环队列使用数组实现，通过将队尾指针和队头指针连接在一起，形成一个环状结构，避免了数据搬移。当队列满时，可以将新元素添加到队尾，而无需进行数据搬移，从而提高了入队操作的效率。

2. 操作效率：

   • 在普通队列中，入队和出队操作的时间复杂度为 O(1)。但是当队列满时，入队操作可能需要进行数据搬移，导致时间复杂度为 O(n)，其中 n 是队列的大小。
   • 在循环队列中，入队和出队操作的平均时间复杂度为 O(1)，并且始终保持为 O(1)。这是因为循环队列使用了取模操作来循环利用数组空间，避免了数据搬移，使得入队和出队操作都具有恒定的时间复杂度。

3. typedef struct CycleQueue {
   	int data[SIZE];
   	int head, tail;
   }CycleQueue;

   队列满和空的判断：

   • 在普通队列中，队列满的判断是当队尾指针 rear 等于队列大小 MAX_SIZE 时，队列为空的判断是当队头指针 front 等于队尾指针 rear 时。
   • 在循环队列中，队列满的判断是当 (rear + 1) % MAX_SIZE 等于队头指针 front 时，队列为空的判断是当队头指针 front 等于队尾指针 rear 时。注意，循环队列中需要保留一个空闲位置，因此队列中最多可以容纳 MAX_SIZE - 1 个元素。

代码实现

定义

typedef struct CycleQueue {
	int data[SIZE];
	int head, tail;
}CycleQueue;

初始化

void InitCycleQueue(CycleQueue* q) {
	memset(&q->data, 0, sizeof(int)*SIZE);
	q->head = q->tail = 0;
}

判空

bool IsEmpty(CycleQueue* p) {
	return p->head == p->tail;
}

判满

bool IsFull(CycleQueue* p) {
	return (p->tail + 1) % SIZE == p->head;
}

入队

bool Push(CycleQueue* p, int val) {
    if (IsFull(p)) {
        return false;
    }
    else {
        p->data[p->tail] = val;
        p->tail = (p->tail + 1) % SIZE;
        return true;
    }
}

出队

bool Pop(CycleQueue* p) {
    if (IsEmpty(p)) {
        return false;
    }
    else {
        p->head = (p->head + 1) % SIZE;
        return true;
    }
}

获取队头元素

int GetTop(CycleQueue* p) {
    if (IsEmpty(p)) {
        return -1;
    }
    else {
        return p->data[p->head];
    }
}

完整代码含测试用例

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#define SIZE 10
typedef struct CycleQueue {
	int data[SIZE];
	int head, tail;
}CycleQueue;
void InitCycleQueue(CycleQueue* q) {
	memset(&q->data, 0, sizeof(int)*SIZE);
	q->head = q->tail = 0;
}
bool IsEmpty(CycleQueue* p) {
	return p->head == p->tail;
}
bool IsFull(CycleQueue* p) {
	return (p->tail + 1) % SIZE == p->head;
}
bool Push(CycleQueue* p, int val) {
    if (IsFull(p)) {
        return false;
    }
    else {
        p->data[p->tail] = val;
        p->tail = (p->tail + 1) % SIZE;
        return true;
    }
}

bool Pop(CycleQueue* p) {
    if (IsEmpty(p)) {
        return false;
    }
    else {
        p->head = (p->head + 1) % SIZE;
        return true;
    }
}

int GetTop(CycleQueue* p) {
    if (IsEmpty(p)) {
        return -1;
    }
    else {
        return p->data[p->head];
    }
}

int main() {
    CycleQueue q;
    InitCycleQueue(&q);

    for (int i = 0; i < SIZE - 1; i++) {
        Push(&q, i);
    }

    while (!IsEmpty(&q)) {
        printf("%d ", GetTop(&q));
        Pop(&q);
    }

    return 0;
}