C语言环形队列程序

C语言环形队列程序

环形队列是一种常见的数据结构，它具有固定大小并使用循环方式来存储和访问数据元素。环形队列常用于需要对数据进行循环利用的场景，例如缓冲区管理、数据传输等。

下述的 C 语言环形队列程序实现了一个简单的环形队列，包括了队列的初始化、入队、出队、强制入队、强制入队多个元素、出队多个元素、清空队列、显示队列元素、获取队首元素和获取队列大小等操作。程序中使用了结构体来表示队列，并实现了相应的操作函数。通过这些函数，用户可以方便地对环形队列进行操作，包括数据的存储、获取和管理。

环形队列的特点是可以高效地利用内存空间，同时支持元素的循环利用。但需要注意的是，在使用环形队列时，需要格外小心队列的溢出和下溢问题，即队列满时的入队操作和队列空时的出队操作。除此之外，环形队列也需要考虑多线程并发操作时的同步与互斥问题。

#include <stdio.h>
#include <stdint.h>
#define MAX_SIZE 5

typedef struct {
    uint8_t items[MAX_SIZE];
    int front, rear;
} Queue;

// 初始化队列
void qu_init(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

// 判断队列是否已满
int qu_is_full(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

// 判断队列是否为空
int qu_is_empty(Queue *q) {
    return q->front == -1;
}

// 入队
void qu_enqueue(Queue *q, uint8_t data) {
    if (qu_is_full(q)) {
        printf("Queue is full\n");
    } else {
        if (qu_is_empty(q)) {
            q->front = 0;
        }
        q->rear = (q->rear + 1) % MAX_SIZE;
        q->items[q->rear] = data;
        printf("%d enqueued to queue\n", data);
    }
}

// 出队
uint8_t qu_dequeue(Queue *q) {
    uint8_t data;
    if (qu_is_empty(q)) {
        printf("Queue is empty\n");
        return 0;
    } else {
        data = q->items[q->front];
        if (q->front == q->rear) {
            q->front = -1;
            q->rear = -1;
        } else {
            q->front = (q->front + 1) % MAX_SIZE;
        }
        return data;
    }
}

// 强制入队
void qu_enqueue_force(Queue *q, uint8_t data) {
    if (qu_is_full(q)) {
        qu_dequeue(q);  // Remove the oldest element to make space
    }
    if (qu_is_empty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->items[q->rear] = data;
    printf("%d enqueued to queue\n", data);
}

// 强制入队多个元素
void qu_enqueue_multiple_force(Queue *q, uint8_t *data, int num) {
    for (int i = 0; i < num; i++) {
        qu_enqueue_force(q, data[i]);
    }
}

// 入队多个元素
void qu_enqueue_multiple(Queue *q, uint8_t *data, int num) {
    for (int i = 0; i < num; i++) {
        qu_enqueue(q, data[i]);
    }
}

// 清空队列
void qu_reset(Queue *q) {
    q->front = -1;
    q->rear = -1;
    printf("Queue has been reset\n");
}



// 出队多个元素
void qu_dequeue_multiple(Queue *q, uint8_t *output, int num) {
    if (qu_is_empty(q)) {
        printf("Queue is empty\n");
        return;
    }
    for (int i = 0; i < num; i++) {
        output[i] = qu_dequeue(q);
    }
}

// 显示队列元素
void qu_display(Queue *q) {
    int i;
    if (qu_is_empty(q)) {
        printf("Queue is empty\n");
    } else {
        printf("Front -> ");
        for (i = q->front; i != q->rear; i = (i + 1) % MAX_SIZE) {
            printf("%d ", q->items[i]);
        }
        printf("%d ", q->items[i]);
        printf(" <- Rear\n");
    }
}

// 获取队首元素
int qu_peek(Queue *q) {
    if (qu_is_empty(q)) {
        printf("Queue is empty\n");
        return -1;
    } else {
        return q->items[q->front];
    }
}

// 获取队列大小
int qu_size(Queue *q) {
    if (qu_is_empty(q)) {
        return 0;
    } else {
        return (MAX_SIZE - q->front + q->rear + 1) % MAX_SIZE;
    }
}

// 从队列中获取多个元素
void qu_get_elements(Queue *q, uint8_t *output, int num) {
    if (qu_is_empty(q)) {
        printf("Queue is empty\n");
        return;
    }
    int count = 0;
    int index = q->front;
    while (count < num) {
        output[count] = q->items[index];
        index = (index + 1) % MAX_SIZE;
        count++;
        if (index == q->front) {
            break;
        }
    }
}

int main() {
    Queue q;
    qu_init(&q);
    uint8_t elements[] = {1, 2, 3, 4, 5};
    qu_enqueue_multiple_force(&q, elements, 5);  // Forces multiple elements into the queue
    qu_display(&q);
    printf("Queue size: %d\n", qu_size(&q));
    
    uint8_t output[3];
    qu_dequeue_multiple(&q, output, 3);
    printf("Dequeue elements: ");
    for (int i = 0; i < 3; i++) {
        printf("%d ", output[i]);
    }
    printf("\n");

    qu_display(&q);
    printf("Queue size: %d\n", qu_size(&q));

    return 0;
}