队列

1. 基于数组的顺序队列

#include <stdio.h>
#include <stdbool.h>

#define MAX_SIZE 100

// 定义队列结构
typedef struct {
    int data[MAX_SIZE];  // 存储数据的数组
    int front;           // 队头指针
    int rear;           // 队尾指针
    int size;           // 当前队列大小
} Queue;

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

// 判断队列是否为空
bool isEmpty(Queue* q) {
    return q->size == 0;
}

// 判断队列是否已满
bool isFull(Queue* q) {
    return q->size == MAX_SIZE;
}

// 入队操作
bool enqueue(Queue* q, int value) {
    if (isFull(q)) {
        printf("队列已满，无法入队！\n");
        return false;
    }
    
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = value;
    q->size++;
    return true;
}

// 出队操作
bool dequeue(Queue* q, int* value) {
    if (isEmpty(q)) {
        printf("队列为空，无法出队！\n");
        return false;
    }
    
    *value = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    q->size--;
    return true;
}

// 获取队头元素
bool getFront(Queue* q, int* value) {
    if (isEmpty(q)) {
        printf("队列为空！\n");
        return false;
    }
    
    *value = q->data[q->front];
    return true;
}

// 获取队列大小
int size(Queue* q) {
    return q->size;
}

// 清空队列
void clearQueue(Queue* q) {
    initQueue(q);
}

// 测试队列操作
int main() {
    Queue queue;
    initQueue(&queue);
    
    // 入队测试
    enqueue(&queue, 10);
    enqueue(&queue, 20);
    enqueue(&queue, 30);
    
    printf("队列大小: %d\n", size(&queue));
    
    // 出队测试
    int value;
    while (dequeue(&queue, &value)) {
        printf("出队元素: %d\n", value);
    }
    
    return 0;
}

2. 基于链表的队列

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

// 定义队列节点
typedef struct QueueNode {
    int data;
    struct QueueNode* next;
} QueueNode;

// 定义队列结构
typedef struct {
    QueueNode* front;   // 队头指针
    QueueNode* rear;    // 队尾指针
    int size;           // 队列大小
} LinkedQueue;

// 初始化队列
void initQueue(LinkedQueue* q) {
    q->front = NULL;
    q->rear = NULL;
    q->size = 0;
}

// 判断队列是否为空
bool isEmpty(LinkedQueue* q) {
    return q->size == 0;
}

// 入队操作
bool enqueue(LinkedQueue* q, int value) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    if (newNode == NULL) {
        printf("内存分配失败！\n");
        return false;
    }
    
    newNode->data = value;
    newNode->next = NULL;
    
    if (isEmpty(q)) {
        q->front = newNode;
    } else {
        q->rear->next = newNode;
    }
    
    q->rear = newNode;
    q->size++;
    return true;
}

// 出队操作
bool dequeue(LinkedQueue* q, int* value) {
    if (isEmpty(q)) {
        printf("队列为空，无法出队！\n");
        return false;
    }
    
    QueueNode* temp = q->front;
    *value = temp->data;
    q->front = temp->next;
    
    if (q->front == NULL) {
        q->rear = NULL;
    }
    
    free(temp);
    q->size--;
    return true;
}

// 获取队头元素
bool getFront(LinkedQueue* q, int* value) {
    if (isEmpty(q)) {
        printf("队列为空！\n");
        return false;
    }
    
    *value = q->front->data;
    return true;
}

// 获取队列大小
int size(LinkedQueue* q) {
    return q->size;
}

// 清空队列
void clearQueue(LinkedQueue* q) {
    int value;
    while (dequeue(q, &value));
}

// 销毁队列
void destroyQueue(LinkedQueue* q) {
    clearQueue(q);
    q->front = NULL;
    q->rear = NULL;
    q->size = 0;
}

3. 循环队列

#include <stdio.h>
#include <stdbool.h>

#define MAX_SIZE 100

// 定义循环队列结构
typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
} CircularQueue;

// 初始化循环队列
void initQueue(CircularQueue* q) {
    q->front = q->rear = 0;
}

// 判断队列是否为空
bool isEmpty(CircularQueue* q) {
    return q->front == q->rear;
}

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

// 入队操作
bool enqueue(CircularQueue* q, int value) {
    if (isFull(q)) {
        printf("队列已满，无法入队！\n");
        return false;
    }
    
    q->data[q->rear] = value;
    q->rear = (q->rear + 1) % MAX_SIZE;
    return true;
}

// 出队操作
bool dequeue(CircularQueue* q, int* value) {
    if (isEmpty(q)) {
        printf("队列为空，无法出队！\n");
        return false;
    }
    
    *value = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    return true;
}

// 获取队列大小
int size(CircularQueue* q) {
    return (q->rear - q->front + MAX_SIZE) % MAX_SIZE;
}

4. 优先队列

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

// 定义优先队列节点
typedef struct PQNode {
    int data;
    int priority;
    struct PQNode* next;
} PQNode;

// 定义优先队列
typedef struct {
    PQNode* front;
} PriorityQueue;

// 初始化优先队列
void initPQueue(PriorityQueue* pq) {
    pq->front = NULL;
}

// 入队操作（按优先级插入）
bool enqueue(PriorityQueue* pq, int value, int priority) {
    PQNode* newNode = (PQNode*)malloc(sizeof(PQNode));
    if (newNode == NULL) {
        return false;
    }
    
    newNode->data = value;
    newNode->priority = priority;
    
    // 如果队列为空或新节点优先级高于队头
    if (pq->front == NULL || priority > pq->front->priority) {
        newNode->next = pq->front;
        pq->front = newNode;
    } else {
        PQNode* current = pq->front;
        while (current->next != NULL && 
               current->next->priority >= priority) {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }
    
    return true;
}

// 出队操作
bool dequeue(PriorityQueue* pq, int* value) {
    if (pq->front == NULL) {
        return false;
    }
    
    PQNode* temp = pq->front;
    *value = temp->data;
    pq->front = temp->next;
    free(temp);
    return true;
}

5. 双端队列

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

// 定义双端队列节点
typedef struct DequeNode {
    int data;
    struct DequeNode* prev;
    struct DequeNode* next;
} DequeNode;

// 定义双端队列
typedef struct {
    DequeNode* front;
    DequeNode* rear;
    int size;
} Deque;

// 初始化双端队列
void initDeque(Deque* dq) {
    dq->front = NULL;
    dq->rear = NULL;
    dq->size = 0;
}

// 在队首插入
bool pushFront(Deque* dq, int value) {
    DequeNode* newNode = (DequeNode*)malloc(sizeof(DequeNode));
    if (newNode == NULL) return false;
    
    newNode->data = value;
    newNode->prev = NULL;
    newNode->next = dq->front;
    
    if (isEmpty(dq)) {
        dq->rear = newNode;
    } else {
        dq->front->prev = newNode;
    }
    
    dq->front = newNode;
    dq->size++;
    return true;
}

// 在队尾插入
bool pushBack(Deque* dq, int value) {
    DequeNode* newNode = (DequeNode*)malloc(sizeof(DequeNode));
    if (newNode == NULL) return false;
    
    newNode->data = value;
    newNode->next = NULL;
    newNode->prev = dq->rear;
    
    if (isEmpty(dq)) {
        dq->front = newNode;
    } else {
        dq->rear->next = newNode;
    }
    
    dq->rear = newNode;
    dq->size++;
    return true;
}

// 从队首删除
bool popFront(Deque* dq, int* value) {
    if (isEmpty(dq)) return false;
    
    DequeNode* temp = dq->front;
    *value = temp->data;
    
    dq->front = temp->next;
    if (dq->front == NULL) {
        dq->rear = NULL;
    } else {
        dq->front->prev = NULL;
    }
    
    free(temp);
    dq->size--;
    return true;
}

// 从队尾删除
bool popBack(Deque* dq, int* value) {
    if (isEmpty(dq)) return false;
    
    DequeNode* temp = dq->rear;
    *value = temp->data;
    
    dq->rear = temp->prev;
    if (dq->rear == NULL) {
        dq->front = NULL;
    } else {
        dq->rear->next = NULL;
    }
    
    free(temp);
    dq->size--;
    return true;
}