C++入门-stack和queue（下）

最新推荐文章于 2024-08-22 17:47:37 发布

阿Chou在努力

最新推荐文章于 2024-08-22 17:47:37 发布

阅读量2.1k

点赞数 18

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/Choulqt/article/details/138770906

版权

大家好啊，在这先祝天下的母亲节日快乐啦！现在呢，给大家带来C++中priority_queue和容器适配器的相关知识点
在这里插入图片描述

3.1 C++ 中的优先队列（priority_queue）介绍

优先队列（priority_queue）是一种特殊的队列，它的特点是可以按照元素的优先级进行排序，每次取出的元素都是优先级最高（或最低）的元素。在 C++ 中，优先队列是通过标准库中的std::priority_queue实现的。

优先队列的介绍

优先队列是一种数据结构，它与队列类似，但是不同之处在于优先队列中的元素是按照一定的优先级顺序进行排序的。当我们向优先队列中插入元素时，元素会按照一定的规则进行排序，而取出元素时，会先取出优先级最高（或最低）的元素。

在 C++ 中，优先队列是一个适配器容器（adapter container），它基于另一个底层容器（通常是std::vector）实现，并提供了一些特殊的操作，使得元素按照优先级进行管理。

优先队列的使用

下面是一个简单的示例代码，演示了如何使用std::priority_queue创建一个最大堆（默认情况下是最大堆）：

#include <iostream>
#include <queue>

int main() {
    std::priority_queue<int> pq;

    pq.push(30);
    pq.push(10);
    pq.push(20);

    std::cout << "Top element: " << pq.top() << std::endl;

    pq.pop();
    std::cout << "Top element after pop: " << pq.top() << std::endl;

    return 0;
}

注释：

std::priority_queue是 C++ 标准库中实现优先队列的类。
push 方法用于将元素插入优先队列。
top 方法用于获取优先队列中的顶部元素（优先级最高的元素）。
pop 方法用于移除优先队列中的顶部元素。

在上面的示例中，我们创建了一个最大堆优先队列，并演示了插入元素、访问顶部元素和移除顶部元素的操作。

优先队列在实际应用中常用于任务调度、贪心算法等场景，可以方便地管理具有优先级的元素。

3.2 C++ 中的队列（queue）在 OJ 中的应用

在我们平时做的OJ题中，队列（queue）是一种常用的数据结构，能够帮助我们解决各种问题，如广度优先搜索（BFS）等。在 C++ 中，我们可以使用标准库中的std::queue来实现队列的功能。

在 OJ 中的使用

下面是一个示例代码，演示了如何在 OJ 中使用队列解决一个简单的问题：

问题描述：
给定一个整数数组，求解数组中所有元素的和。

#include <iostream>
#include <queue>

int main() {
    // 创建一个队列，元素类型为整数
    std::queue<int> q;

    // 将数组元素依次入队
    int arr[] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        q.push(arr[i]);
    }

    // 计算队列中所有元素的和
    int sum = 0;
    while (!q.empty()) {
        sum += q.front(); // 获取队首元素
        q.pop(); // 弹出队首元素
    }

    // 输出结果
    std::cout << "数组元素的和为：" << sum << std::endl;

    return 0;
}

注释：

std::queue是 C++ 标准库中实现队列的类，用于存储元素并支持先进先出（FIFO）的操作。
push 方法用于将元素入队。
front 方法用于获取队首元素。
pop 方法用于弹出队首元素。
empty 方法用于判断队列是否为空。

在上面的示例中，我们创建了一个队列，并将整数数组中的元素依次入队，然后计算队列中所有元素的和。通过队列的先进先出特性，我们可以方便地处理需要按顺序处理的数据。

在实际的算法竞赛中，队列常常与广度优先搜索（BFS）算法结合使用，用于遍历图中的节点或解决其他问题。

3.3 C++ 中的优先队列（priority_queue）的模拟实现

优先队列（priority_queue）是一种特殊的队列，它可以按照一定的优先级顺序存储元素，并且每次取出的元素都是优先级最高的。在 C++ 中，我们可以使用标准库中的std::priority_queue来实现优先队列的功能。下面我们将通过自定义类来模拟实现一个简单的优先队列。

模拟实现

下面是一个示例代码，演示了如何使用一个自定义类来模拟实现优先队列的基本功能：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数，用于优先级比较
struct Compare {
    bool operator()(int a, int b) {
        return a < b; // 定义优先级，这里是升序
    }
};

int main() {
    // 使用 vector 来模拟优先队列
    std::vector<int> vec = {3, 1, 4, 1, 5, 9};

    // 使用自定义的比较函数来定义优先队列
    std::priority_queue<int, std::vector<int>, Compare> pq(vec.begin(), vec.end());

    // 输出优先队列中的元素（按照优先级顺序）
    while (!pq.empty()) {
        std::cout << pq.top() << " "; // 获取优先级最高的元素
        pq.pop(); // 弹出优先级最高的元素
    }

    return 0;
}

注释：

std::priority_queue是 C++ 标准库中实现优先队列的类，它默认使用std::less来定义优先级，也可以自定义比较函数。
在示例代码中，我们自定义了一个比较函数Compare，用于定义优先级的比较规则。
我们使用std::vector来存储元素，并将其作为参数传递给std::priority_queue来初始化优先队列。
通过循环遍历优先队列并输出元素，我们可以看到元素按照优先级顺序被取出。

4.1 C++ 中的适配器（Adapter）

适配器是 C++ STL 中的一种重要概念，它可以将一个容器或者类的接口适配成另一个容器或者类的接口，使得原本不兼容的接口可以互相转换和使用。在 STL 中，常见的适配器包括 stack、queue、priority_queue 等。

什么是适配器

适配器是一种设计模式，用于将一个类的接口转换成另一个类的接口。在 C++ STL 中，适配器通常用于将不同容器的接口进行适配，使得它们可以以统一的方式使用。适配器隐藏了容器的具体实现细节，提供了一致的接口，方便开发者使用不同的容器。

示例代码

下面是一个简单的示例代码，演示了如何使用适配器 stack 来实现一个基本的栈功能：

#include <iostream>
#include <stack>

int main() {
    // 创建一个 stack 容器
    std::stack<int> mystack;

    // 向栈中压入元素
    mystack.push(1);
    mystack.push(2);
    mystack.push(3);

    // 输出栈顶元素
    std::cout << "栈顶元素：" << mystack.top() << std::endl;

    // 弹出栈顶元素
    mystack.pop();

    // 再次输出栈顶元素
    std::cout << "弹出后的栈顶元素：" << mystack.top() << std::endl;

    // 检查栈是否为空
    if (mystack.empty()) {
        std::cout << "栈为空" << std::endl;
    } else {
        std::cout << "栈不为空" << std::endl;
    }

    return 0;
}

注释：

在示例代码中，我们使用std::stack适配器来实现栈的功能。
通过push向栈中压入元素，top获取栈顶元素，pop弹出栈顶元素，empty检查栈是否为空。
使用适配器可以方便地实现栈的功能，而不必关心具体的实现细节。

适配器在 C++ STL 中扮演着重要的角色，它提供了一种灵活的方式来使用不同的容器，使得开发更加高效和便捷。在实际开发中，适配器能够帮助我们快速实现各种数据结构和算法，提高代码的可复用性和可维护性。

4.2 C++ STL 中 stack 和 queue 的底层结构详解

在 C++ STL 中，stack（栈）和queue（队列）是两种常用的数据结构，它们分别基于不同的底层结构实现。本文将详细介绍 STL 中 stack 和 queue 的底层结构，并通过示例代码演示它们的使用。

stack 的底层结构

在 C++ STL 中，stack 是基于 deque（双端队列）实现的。deque 是一种双端队列，支持在两端进行高效地插入和删除操作，因此非常适合用来实现栈这种数据结构。stack 在 deque 的基础上封装了一些接口，提供了栈的常用操作，如 push、pop、top 等。

下面是一个示例代码，演示了如何使用 stack：

#include <iostream>
#include <stack>

int main() {
    std::stack<int> mystack;

    mystack.push(1);
    mystack.push(2);
    mystack.push(3);

    while (!mystack.empty()) {
        std::cout << mystack.top() << " ";
        mystack.pop();
    }

    return 0;
}

注释：

在示例代码中，我们使用std::stack适配器来实现栈的功能，底层结构是基于 deque 实现的。
使用push向栈中压入元素，top获取栈顶元素，pop弹出栈顶元素，empty检查栈是否为空。
stack 封装了 deque 的接口，提供了栈的功能，使得开发者可以方便地使用栈数据结构。

queue 的底层结构

在 C++ STL 中，queue 是基于 deque 或 list 实现的。如果使用 deque 作为底层容器，queue 的操作复杂度会更低；如果使用 list 作为底层容器，queue 的空间复杂度会更低。queue 提供了队列的常用操作，如 push、pop、front、back 等。

下面是一个示例代码，演示了如何使用 queue：

#include <iostream>
#include <queue>

int main() {
    std::queue<int> myqueue;

    myqueue.push(1);
    myqueue.push(2);
    myqueue.push(3);

    while (!myqueue.empty()) {
        std::cout << myqueue.front() << " ";
        myqueue.pop();
    }

    return 0;
}

注释：

在示例代码中，我们使用std::queue适配器来实现队列的功能，底层结构可以是 deque 或 list。
使用push向队列中插入元素，front获取队首元素，pop弹出队首元素，empty检查队列是否为空。
queue 封装了 deque 或 list 的接口，提供了队列的功能，使得开发者可以方便地使用队列数据结构。

4.3 deque 的简单介绍

deque（双端队列）是 C++ STL 中的一种容器，它是一种双向开口的序列容器，支持在两端进行高效地插入和删除操作。deque 允许在序列的任意位置进行快速插入和删除操作，比 vector 更加灵活。

下面是一个简单的示例代码，演示了如何使用 deque：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> mydeque;

    mydeque.push_back(1);
    mydeque.push_back(2);
    mydeque.push_front(3);

    for (int i : mydeque) {
        std::cout << i << " ";
    }

    return 0;
}

注释：

在示例代码中，我们使用std::deque容器来创建一个双端队列。
使用push_back在队尾插入元素，push_front在队首插入元素。
deque 支持在两端高效地插入和删除元素，是一种灵活的序列容器。

4.4 为什么选择 deque 作为 stack 和 queue 的底层默认容器

在 C++ STL 中，stack 和 queue 这两种容器适配器的底层默认容器是 deque（双端队列）。为什么选择 deque 作为底层容器呢？让我们来详细探讨一下。

为什么选择 deque

高效的插入和删除操作：deque 支持在两端进行高效的插入和删除操作，这非常适合用来实现栈（stack）和队列（queue）这样需要频繁在两端操作的数据结构。
随机访问：deque 支持快速的随机访问，可以通过索引直接访问任意位置的元素，这对于实现优先队列（priority_queue）等需要随机访问的数据结构非常重要。
动态扩展：deque 的内部实现是由多个连续的缓冲区组成的，当需要扩展容量时，可以在两端添加新的缓冲区，这样可以避免频繁的内存重新分配，提高了性能。
内存分配效率：deque 在内存分配方面相对灵活，可以避免 vector 的频繁内存搬迁，因此在大部分情况下，deque 的性能表现更好。

演示代码

下面是一个简单的示例代码，演示了如何使用 deque 作为 stack 和 queue 的底层容器：

#include <iostream>
#include <stack>
#include <queue>
#include <deque>

int main() {
    // 使用 deque 作为 stack 的底层容器
    std::stack<int, std::deque<int>> mystack;
    mystack.push(1);
    mystack.push(2);
    mystack.push(3);

    while (!mystack.empty()) {
        std::cout << mystack.top() << " ";
        mystack.pop();
    }

    std::cout << std::endl;

    // 使用 deque 作为 queue 的底层容器
    std::queue<int, std::deque<int>> myqueue;
    myqueue.push(1);
    myqueue.push(2);
    myqueue.push(3);

    while (!myqueue.empty()) {
        std::cout << myqueue.front() << " ";
        myqueue.pop();
    }

    return 0;
}

注释：

在示例代码中，我们使用 deque 作为 stack 和 queue 的底层容器，展示了它们的基本用法。
deque 的灵活性和高效性使其成为 stack 和 queue 的理想底层容器选择。

4.5 STL 标准库中对于 stack 和 queue 的模拟实现

在 C++ STL 中，stack 和 queue 是两种常用的容器适配器，它们分别基于 deque（双端队列）实现。让我们来看看如何使用 STL 标准库中的 stack 和 queue，并进行模拟实现。

stack 的模拟实现

#include <iostream>
#include <stack>

int main() {
    // 创建一个 stack 容器
    std::stack<int> mystack;

    // 向 stack 中压入元素
    mystack.push(1);
    mystack.push(2);
    mystack.push(3);

    // 访问栈顶元素
    std::cout << "栈顶元素：" << mystack.top() << std::endl;

    // 弹出栈顶元素
    mystack.pop();

    // 打印栈中剩余元素
    std::cout << "剩余元素：";
    while (!mystack.empty()) {
        std::cout << mystack.top() << " ";
        mystack.pop();
    }

    return 0;
}

注释：

在示例代码中，我们使用 STL 的 stack 容器模拟了栈的基本操作：压入元素、访问栈顶元素、弹出栈顶元素等。

queue 的模拟实现

#include <iostream>
#include <queue>

int main() {
    // 创建一个 queue 容器
    std::queue<int> myqueue;

    // 向 queue 中插入元素
    myqueue.push(1);
    myqueue.push(2);
    myqueue.push(3);

    // 访问队首元素
    std::cout << "队首元素：" << myqueue.front() << std::endl;

    // 弹出队首元素
    myqueue.pop();

    // 打印队列中剩余元素
    std::cout << "剩余元素：";
    while (!myqueue.empty()) {
        std::cout << myqueue.front() << " ";
        myqueue.pop();
    }

    return 0;
}

注释：

在示例代码中，我们使用 STL 的 queue 容器模拟了队列的基本操作：插入元素、访问队首元素、弹出队首元素等。

好了，感谢大家看到这，如果觉得本篇文章对你有帮助的话，还请点个赞支持一下，有什么问题也可以评论区留言，那么我们下次再见了，Peace~

阿Chou在努力

关注

18
点赞
踩
27

收藏

觉得还不错? 一键收藏
1
评论
C++入门-stack和queue（下）

优先队列（priority_queue）是一种特殊的队列，它的特点是可以按照元素的优先级进行排序，每次取出的元素都是优先级最高（或最低）的元素。在 C++ 中，优先队列是通过标准库中的实现的。优先队列是一种数据结构，它与队列类似，但是不同之处在于优先队列中的元素是按照一定的优先级顺序进行排序的。当我们向优先队列中插入元素时，元素会按照一定的规则进行排序，而取出元素时，会先取出优先级最高（或最低）的元素。
复制链接

扫一扫