C语言中如何实现enqueue操作？

C语言中的入队操作（Enqueue）

在C语言中实现队列的入队操作（enqueue）通常需要结合数据结构（如数组或链表）来实现，下面我将展示两种常见的实现方式：基于数组的循环队列和基于链表的队列。

基于数组的循环队列实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX_SIZE 5
typedef struct {
    int items[MAX_SIZE];
    int front;
    int rear;
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}
// 检查队列是否已满
bool isFull(Queue *q) {
    if ((q->rear + 1) % MAX_SIZE == q->front) {
        return true;
    }
    return false;
}
// 检查队列是否为空
bool isEmpty(Queue *q) {
    if (q->front == -1) {
        return true;
    }
    return false;
}
// 入队操作
void enqueue(Queue *q, int value) {
    if (isFull(q)) {
        printf("Queue is full\n");
        return;
    }
    if (q->front == -1) { // 如果队列为空
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->items[q->rear] = value;
    printf("Enqueued: %d\n", value);
}
// 出队操作
void dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return;
    }
    printf("Dequeued: %d\n", q->items[q->front]);
    if (q->front == q->rear) { // 如果只有一个元素
        q->front = -1;
        q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
}
// 打印队列
void printQueue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return;
    }
    printf("Queue: ");
    int i = q->front;
    while (i != q->rear) {
        printf("%d ", q->items[i]);
        i = (i + 1) % MAX_SIZE;
    }
    printf("%d\n", q->items[q->rear]);
}
int main() {
    Queue q;
    initQueue(&q);
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);
    enqueue(&q, 4);
    enqueue(&q, 5);
    printQueue(&q);
    dequeue(&q);
    dequeue(&q);
    enqueue(&q, 6);
    enqueue(&q, 7);
    printQueue(&q);
    return 0;
}

基于链表的队列实现

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
    int data;
    struct Node *next;
} Node;
typedef struct {
    Node *front;
    Node *rear;
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = NULL;
    q->rear = NULL;
}
// 检查队列是否为空
bool isEmpty(Queue *q) {
    return q->front == NULL;
}
// 入队操作
void enqueue(Queue *q, int value) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        return;
    }
    newNode->data = value;
    newNode->next = NULL;
    if (isEmpty(q)) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
    printf("Enqueued: %d\n", value);
}
// 出队操作
void dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return;
    }
    Node *temp = q->front;
    printf("Dequeued: %d\n", temp->data);
    q->front = q->front->next;
    if (q->front == NULL) {
        q->rear = NULL;
    }
    free(temp);
}
// 打印队列
void printQueue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return;
    }
    printf("Queue: ");
    Node *current = q->front;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}
int main() {
    Queue q;
    initQueue(&q);
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);
    enqueue(&q, 4);
    enqueue(&q, 5);
    printQueue(&q);
    dequeue(&q);
    dequeue(&q);
    enqueue(&q, 6);
    enqueue(&q, 7);
    printQueue(&q);
    return 0;
}

关键点说明

1. 数组实现：

   • 使用循环数组避免假溢出
   • front和rear指针需要模运算
   • 固定大小，需要检查队列是否已满

2. 链表实现：

   • 动态大小，不需要检查队列是否已满
   • 只需要维护front和rear指针
   • 需要动态内存分配

3. 入队操作核心：

   • 检查队列是否已满（数组实现）
   • 创建新节点/元素
   • 更新rear指针
   • 处理空队列的特殊情况

两种实现各有优缺点，数组实现更节省内存但大小固定,链表实现更灵活但需要额外内存管理。