STL中的栈和队列：剖析、模拟实现与优先级队列深度解析

2023-05-29 03:43:35

理解 STL 中的栈、队列和优先级队列：一个深入指南

在编程的世界中，栈和队列是两个不可或缺的数据结构，它们以其卓越的性能和广泛的应用而备受推崇。标准模板库 (STL) 为 C++ 程序员提供了 stack 和 queue 类，用于处理栈和队列操作。本文将深入探究这些数据结构，揭示它们的功能、实现和实际应用。

栈与队列：理解基础

栈是一种后进先出 (LIFO) 数据结构，这意味着您最后添加的元素将首先被删除。想象一下一叠盘子，当您添加一个新盘子时，它会被放在堆栈的顶部，而当您需要一个盘子时，您从顶部移除它。

队列是一种先进先出 (FIFO) 数据结构，这意味着您首先添加的元素将首先被删除。它就像一个排队的人群，先到的人先得。

STL 中的栈和队列：丰富的接口

STL 提供的 stack 和 queue 类提供了丰富的接口，使您可以轻松地操作这些数据结构：

stack 函数：

push(x)：将元素 x 压入栈顶
pop()：弹出并删除栈顶元素
top()：返回栈顶元素
size()：返回栈中元素的数量
empty()：检查栈是否为空

queue 函数：

push(x)：将元素 x 插入队尾
pop()：弹出并删除队首元素
front()：返回队首元素
back()：返回队尾元素
size()：返回队列中元素的数量
empty()：检查队列是否为空

适配器：连接不同数据结构

适配器是一种设计模式，可将一种数据结构转换为另一种数据结构，从而允许原本不兼容的系统协同工作。STL 提供了 queue 和 priority_queue 两个适配器，它们可以将顺序容器（如 vector 和 list）转换为队列和优先级队列。

模拟实现：从头开始

栈和队列可以使用顺序容器进行模拟实现。以下是用 vector 模拟栈和队列的示例代码：

栈：

class Stack {
public:
  void push(int x) { v.push_back(x); }
  int pop() { int x = v.back(); v.pop_back(); return x; }
  int top() { return v.back(); }
  int size() { return v.size(); }
  bool empty() { return v.empty(); }
private:
  vector<int> v;
};

队列：

class Queue {
public:
  void push(int x) { v.push_back(x); }
  int pop() { int x = v.front(); v.erase(v.begin()); return x; }
  int front() { return v.front(); }
  int back() { return v.back(); }
  int size() { return v.size(); }
  bool empty() { return v.empty(); }
private:
  vector<int> v;
};

deque：一种双向队列

deque（双端队列）是一种特殊类型的线性表，允许在两端进行插入和删除操作。STL 中的 deque<T> 类提供了丰富的接口，支持各种操作。

优先级队列：按优先级排列

优先级队列是一种特殊的队列，它根据元素的优先级确定出队顺序。STL 中的 priority_queue<T> 类提供了丰富的接口，支持各种操作。

模拟实现：优先级队列

优先级队列可以使用堆数据结构进行模拟实现。以下是用 vector 模拟优先级队列的示例代码：

class PriorityQueue {
public:
  void push(int x) { v.push_back(x); heapify_up(); }
  int pop() { int x = v.front(); v.front() = v.back(); v.pop_back(); heapify_down(); return x; }
  int top() { return v.front(); }
  int size() { return v.size(); }
  bool empty() { return v.empty(); }
private:
  vector<int> v;
  void heapify_up() { int i = v.size() - 1; while (i > 0 && v[i] > v[(i - 1) / 2]) { swap(v[i], v[(i - 1) / 2]); i = (i - 1) / 2; } }
  void heapify_down() { int i = 0; while (i < v.size() && (2 * i + 1 < v.size() || 2 * i + 2 < v.size())) { int left = 2 * i + 1; int right = 2 * i + 2; int largest = i; if (left < v.size() && v[left] > v[i]) { largest = left; } if (right < v.size() && v[right] > v[largest]) { largest = right; } if (largest != i) { swap(v[i], v[largest]); i = largest; } else { break; } } }
};