栈与队列：常见的线性数据结构

栈（Stack）和队列（Queue）是计算机科学中常见的线性数据结构，它们在许多算法和编程场景中发挥着重要作用。它们的不同特点和用途使得它们适用于不同的问题和应用。

栈（Stack）

栈，作为一种线性数据结构，其特点在于遵循后进先出（Last-In-First-Out，LIFO）的原则。这意味着最后一个进入栈的元素将第一个被弹出，而最先进入的元素将成为最后被弹出的。这一奇妙的特性使得栈在许多实际问题中得到广泛应用。

回想一下现实生活中的例子，我们可以将栈类比为堆叠的盘子。当我们往堆叠中放入一叠盘子时，最后放入的盘子会在顶部，而取出盘子时也是从顶部开始取。这种方式保证了后放入的盘子最先被取走，而先放入的盘子则被压在下面。

栈的操作

栈支持以下两种主要操作：

1. 入栈（Push）：将元素放入栈的顶部。
2. 出栈（Pop）：从栈的顶部取出元素。

栈的一个重要特性是，只能访问栈顶的元素，其他元素都无法直接访问。这种特性使得栈在许多问题中都有用处，如逆波兰表达式求值、括号匹配、函数调用的调用栈等。

括号匹配

这里我们举一个括号字符串，需要判断其中的括号是否匹配。

#include 
#include 
#include 

bool isBracketMatched(const std::string& expression) {
    std::stack brackets; // 创建字符栈

    for (char ch : expression) {
        if (ch == '(' || ch == '[' || ch == '{') {
            brackets.push(ch); // 将左括号入栈
        } else if (ch == ')' || ch == ']' || ch == '}') {
            if (brackets.empty()) {
                return false; // 出现未匹配的右括号
            }

            char topBracket = brackets.top(); // 获取栈顶元素
            brackets.pop(); // 弹出栈顶元素

            if ((ch == ')' && topBracket != '(') ||
                (ch == ']' && topBracket != '[') ||
                (ch == '}' && topBracket != '{')) {
                return false; // 括号不匹配
            }
        }
    }

    return brackets.empty(); // 检查是否还有未匹配的括号
}

int main() {
    std::string expression = "{[()]()}";
    if (isBracketMatched(expression)) {
        std::cout << "括号匹配。" << std::endl;
    } else {
        std::cout << "括号不匹配。" << std::endl;
    }
    return 0;
}

队列（Queue）

队列是另一种具有特定操作规则的线性数据结构，遵循先进先出的原则。队列可以想象成排队的人，先到先得，后到后得。

与栈不同，队列是另一种常见的线性数据结构，它遵循先进先出（First-In-First-Out，FIFO）的原则。这意味着最早进入队列的元素将最先被弹出，而最后进入的元素将成为最后被弹出的。这一特性使得队列在诸多场景中都能发挥出色的效果。

在日常生活中，队列的例子随处可见。想象一下排队购买电影票的场景：最早来排队的人会最早买到票，而后来的人则会排在后面依次等候。这种先来先服务的原则保证了排队者的公平性。

在计算机领域，队列同样扮演着重要角色。操作系统中的任务调度、打印队列管理以及网络数据传输等领域都广泛使用队列来管理任务和数据。例如，操作系统会使用队列来管理待执行的任务，确保每个任务都能按照顺序得到执行。

队列的操作

队列支持以下两种主要操作：

1. 入队（Enqueue）：将元素放入队列的末尾。
2. 出队（Dequeue）：从队列的开头取出元素。

队列的一个关键特点是，只有队列头部的元素可以被访问和移除，而队列尾部的元素只能被插入。队列在许多应用中都很有用，如任务调度、广度优先搜索等。

任务调度

这里笔者举一个任务调度的案例，有多个任务需要执行，但每个任务需要等待一段时间才能执行。

#include 
#include 
#include 

void scheduleTasks(const std::vector& tasks, int delay) {
    std::queue taskQueue; // 创建字符串队列

    for (const std::string& task : tasks) {
        taskQueue.push(task); // 将任务入队
    }

    while (!taskQueue.empty()) {
        std::string currentTask = taskQueue.front(); // 获取队头任务
        taskQueue.pop(); // 出队
        std::cout << "执行任务：" << currentTask << std::endl;

        if (!taskQueue.empty()) {
            std::cout << "等待 " << delay << " 秒..." << std::endl;
            // 模拟延迟（以秒为单位）
            // 在实际场景中，可能会使用 sleep 函数
            // std::this_thread::sleep_for(std::chrono::seconds(delay));
        }
    }
}

int main() {
    std::vector tasks = {"任务1", "任务2", "任务3", "任务4"};
    int delay = 2;
    scheduleTasks(tasks, delay);
    return 0;
}

总结

栈和队列作为常见的线性数据结构，分别以后进先出和先进先出的原则为基础，广泛应用于算法、编程和软件开发等领域。它们的独特特性使得它们能够优雅地解决各种问题，从模拟现实场景到优化算法流程。通过深入理解栈和队列的原理和应用，我们能够更加灵活地运用它们来解决复杂的计算机科学问题，为软件开发和算法设计带来更多可能性。