双端队列(Deque)原理与C语言实现详解

1. 双端队列的概念与特性

双端队列（Deque，全称Double-Ended Queue）是一种特殊的线性数据结构，它允许在队列的两端（前端和后端）进行插入和删除操作。这种双向操作特性使得双端队列比普通队列更加灵活，能够适应更多样化的应用场景。

1.1 双端队列的基本操作

双端队列支持以下核心操作：

• push_front(x)：在队列前端插入元素x
• push_back(x)：在队列后端插入元素x
• pop_front()：删除并返回队列前端的元素
• pop_back()：删除并返回队列后端的元素
• get_front()：获取队列前端的元素但不删除
• get_back()：获取队列后端的元素但不删除
• is_empty()：判断队列是否为空
• size()：获取队列中元素的数量

在C语言中，我们可以通过数组或链表来实现双端队列。数组实现更简单但容量固定，链表实现更灵活但需要处理指针操作。

1.2 双端队列与普通队列、栈的关系

双端队列实际上是普通队列和栈的泛化形式：

• 当只使用push_back和pop_front操作时，双端队列表现为普通队列（FIFO）
• 当只使用push_back和pop_back（或只使用push_front和pop_front）操作时，双端队列表现为栈（LIFO）

这种灵活性使得双端队列成为许多算法实现中的重要工具，特别是在需要同时维护前后边界的场景中。

2. 双端队列的C语言实现

2.1 基于数组的实现

数组实现双端队列需要考虑循环使用数组空间以避免频繁移动元素。这种实现方式通常称为"循环双端队列"。

#define MAX_SIZE 100 // 定义队列最大容量 typedef struct { int data[MAX_SIZE]; int front; // 前端索引 int rear; // 后端索引 int size; // 当前元素数量 } Deque; // 初始化双端队列 void initDeque(Deque *dq) { dq->front = 0; dq->rear = MAX_SIZE - 1; dq->size = 0; } // 检查队列是否为空 int isEmpty(Deque *dq) { return dq->size == 0; } // 检查队列是否已满 int isFull(Deque *dq) { return dq->size == MAX_SIZE; } // 前端插入元素 void pushFront(Deque *dq, int item) { if (isFull(dq)) { printf("队列已满，无法插入\n"); return; } dq->front = (dq->front - 1 + MAX_SIZE) % MAX_SIZE; dq->data[dq->front] = item; dq->size++; } // 后端插入元素 void pushBack(Deque *dq, int item) { if (isFull(dq)) { printf("队列已满，无法插入\n"); return; } dq->rear = (dq->rear + 1) % MAX_SIZE; dq->data[dq->rear] = item; dq->size++; } // 前端删除元素 int popFront(Deque *dq) { if (isEmpty(dq)) { printf("队列为空，无法删除\n"); return -1; // 错误码 } int item = dq->data[dq->front]; dq->front = (dq->front + 1) % MAX_SIZE; dq->size--; return item; } // 后端删除元素 int popBack(Deque *dq) { if (isEmpty(dq)) { printf("队列为空，无法删除\n"); return -1; // 错误码 } int item = dq->data[dq->rear]; dq->rear = (dq->rear - 1 + MAX_SIZE) % MAX_SIZE; dq->size--; return item; }

注意：数组实现的双端队列有固定大小限制，实际应用中可能需要动态扩容机制。此外，循环数组的索引计算需要特别注意边界条件，避免出现负数索引或越界访问。

2.2 基于链表的实现

链表实现的双端队列没有固定大小限制，但需要处理更多的指针操作和内存管理。

typedef struct Node { int data; struct Node *prev; struct Node *next; } Node; typedef struct { Node *front; Node *rear; int size; } LinkedListDeque; // 初始化链表双端队列 void initLinkedListDeque(LinkedListDeque *dq) { dq->front = NULL; dq->rear = NULL; dq->size = 0; } // 前端插入元素 void pushFront(LinkedListDeque *dq, int item) { Node *newNode = (Node *)malloc(sizeof(Node)); newNode->data = item; newNode->prev = NULL; newNode->next = dq->front; if (dq->front != NULL) { dq->front->prev = newNode; } else { dq->rear = newNode; } dq->front = newNode; dq->size++; } // 后端插入元素 void pushBack(LinkedListDeque *dq, int item) { Node *newNode = (Node *)malloc(sizeof(Node)); newNode->data = item; newNode->next = NULL; newNode->prev = dq->rear; if (dq->rear != NULL) { dq->rear->next = newNode; } else { dq->front = newNode; } dq->rear = newNode; dq->size++; } // 前端删除元素 int popFront(LinkedListDeque *dq) { if (dq->front == NULL) { printf("队列为空，无法删除\n"); return -1; } Node *temp = dq->front; int item = temp->data; dq->front = dq->front->next; if (dq->front != NULL) { dq->front->prev = NULL; } else { dq->rear = NULL; } free(temp); dq->size--; return item; } // 后端删除元素 int popBack(LinkedListDeque *dq) { if (dq->rear == NULL) { printf("队列为空，无法删除\n"); return -1; } Node *temp = dq->rear; int item = temp->data; dq->rear = dq->rear->prev; if (dq->rear != NULL) { dq->rear->next = NULL; } else { dq->front = NULL; } free(temp); dq->size--; return item; }

提示：链表实现中要特别注意内存管理，每次删除节点后要释放内存，插入新节点时要分配内存。此外，边界条件处理（如队列为空时的操作）需要格外小心。

3. 双端队列的应用场景

双端队列的独特特性使其在多种算法和系统设计中都有广泛应用。

3.1 滑动窗口问题

双端队列是解决滑动窗口类问题的理想数据结构。例如，在求滑动窗口最大值的问题中，我们可以维护一个双端队列来存储当前窗口内可能成为最大值的元素索引。

// 使用双端队列求滑动窗口最大值 void maxSlidingWindow(int nums[], int numsSize, int k, int result[]) { LinkedListDeque dq; initLinkedListDeque(&dq); for (int i = 0; i < numsSize; i++) { // 移除队列中不在当前窗口的元素 while (!isEmpty(&dq) && dq.front->data < i - k + 1) { popFront(&dq); } // 移除队列中比当前元素小的元素 while (!isEmpty(&dq) && nums[dq.rear->data] < nums[i]) { popBack(&dq); } pushBack(&dq, i); // 当前窗口的最大值是队列前端元素 if (i >= k - 1) { result[i - k + 1] = nums[dq.front->data]; } } }

3.2 撤销操作实现

许多编辑器或图形软件中的撤销/重做功能可以使用双端队列实现。前端用于撤销操作，后端用于重做操作，当执行新操作时清空重做队列。

3.3 工作窃取算法

在多线程编程中，工作窃取算法（Work Stealing）使用双端队列来平衡线程间的工作负载。每个线程维护自己的双端队列，从队列前端获取任务执行，当自己的队列为空时，可以从其他线程队列的后端"窃取"任务。

3.4 回文检查

双端队列可以高效地检查一个字符串是否是回文。我们可以从双端队列的两端同时取出字符进行比较，直到队列为空或只剩一个元素。

int isPalindrome(char *str) { LinkedListDeque dq; initLinkedListDeque(&dq); // 将字符串所有字符加入双端队列 for (int i = 0; str[i] != '\0'; i++) { pushBack(&dq, str[i]); } // 从两端同时取出字符比较 while (dq.size > 1) { if (popFront(&dq) != popBack(&dq)) { return 0; // 不是回文 } } return 1; // 是回文 }

4. 双端队列的性能分析与优化

4.1 时间复杂度分析

不同实现方式下双端队列操作的时间复杂度：

虽然两种实现的时间复杂度相同，但实际性能会受到内存分配、缓存命中率等因素影响。数组实现通常更快，因为内存连续，缓存友好；链表实现则更灵活，没有大小限制。

4.2 空间复杂度分析

• 数组实现：固定空间占用，O(n)预分配空间，可能有空间浪费
• 链表实现：动态空间占用，精确分配所需空间，但有额外指针开销

4.3 实现优化技巧

1. 动态扩容数组：当数组实现的双端队列满时，可以动态扩容（通常加倍），避免固定大小限制。需要注意扩容时要正确复制元素顺序。

2. 内存池技术：对于链表实现，可以使用内存池预先分配节点，减少频繁malloc/free的开销。

3. 批量操作：某些场景下可以支持批量插入/删除操作，减少函数调用开销。

4. 无锁实现：在多线程环境下，可以考虑无锁（lock-free）双端队列实现，提高并发性能。

4.4 实际应用中的选择建议

• 小型固定大小队列：优先选择数组实现，性能更好
• 大型或大小不确定队列：选择链表实现，避免空间浪费
• 高频插入删除：考虑链表实现，避免数组元素移动
• 随机访问需求：数组实现更适合随机访问中间元素

在实际项目中，C++ STL中的deque实现结合了数组和链表的优点，使用多个固定大小的数组块（通常512字节）并通过索引数组管理，既保证了随机访问性能，又支持动态扩容。在纯C环境中，可以根据具体需求选择上述实现方式或参考类似思路进行优化。