priority_queue

最新推荐文章于 2024-08-20 20:17:17 发布
最新推荐文章于 2024-08-20 20:17:17 发布
阅读量35 收藏
点赞数
分类专栏： C++学习之路 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ayf9999/article/details/134428555
版权

模拟实现 priority_queue

基本实现思路

在优先级队列中，插入数据和删除数据的时间复杂度为 O(logN) 。

默认情况下的优先级队列是大堆，我们先不考虑用仿函数去实现兼容大堆小队排列问题，

我们先去实现大堆，先把基本的功能实现好，带着讲解完仿函数后再去进行优化实现。

 优先级队列相较于普通的队列，其区别主要是在 push 和 pop 上，

即需要在插入 / 删除数据的同时，增添调整的功能，并且 STL 的优先级队列是由堆来维护的：

void push(const T& x) {
    _con.push_back(x);
    AdjustUp(_con.size() - 1);
}

 入队时将数据推入后，从最后一个元素开始进行上调。

出队时采用堆的删除手法，将根元素（即队头）和最后一个元素进行交换，并调用尾删掉队头。

既然用了头尾交换法，我们就不得不对队列重新调整，所以从根位置进行下调，即可完成出队。

void pop() {
    assert(!_con.empty());
    swap(_con[0], _con[_con.size() - 1]);
    _con.pop_back();
 
    AdjustDown(0);
}

既然需要上调和下调操作，我们不可避免地需要实现上调和下调的算法。

我们这里暂时写死，设计成大堆的 AdjustUp 和 AdjustDown：

/* 向上调整算法 */
void AdjustUp(size_t child) {
    size_t father = (child - 1) / 2;
    while (child > 0) {
        if (_con[father] < _con[child]) {
            swap(_con[father], _con[child]);
            child = father;
            father = (child - 1) / 2;
        }
        else {
            break;
        }
    }
}
/* 向下调整算法 */
void AdjustDown(size_t father) {
    size_t child = father * 2 + 1; // 默认认为左孩子大
    while (child < _con.size()) {
        // 判断右孩子是否存在，并且是否比左孩子大？
        if (child + 1 < _con.size() && _con[child] < _con[child + 1]) {
            child += 1;
        }
 
        if (_con[father] < _con[child]) {
            swap(_con[father], _con[child]);
            father = child;
            child = father * 2 + 1;
        }
        else {
            break;
        }
    }
}

向上调整算法和向下调整算法实现完后，我们把剩下的可以直接用 _con 转换的接口实现一下：

const T& top() {
    return _con[0];
}
 
size_t size() {
    return _con.size();
}
 
bool empty() {
    return _con.empty();
}

很简单，不过值得注意的是，返回堆顶数据的 top 接口，我们用了 const 引用返回。

 

思考：为什么这里要用引用？为什么还要加个 const？

① 考虑到如果这里 T 是 string，甚至是更大的对象，传值返回就有一次拷贝构造，代价就大了。

② 如果能让你随随便便修改我堆顶的数据，那岂不是  显得我很随便？   很危险？

大堆优先级队列 

代码：大堆优先级队列 demo 

#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
 
namespace foxny {
    template<class T, class Container = vector<T>>
    class priority_queue {
    public:
        /* 向上调整算法 */
        void AdjustUp(size_t child) {
            size_t father = (child - 1) / 2;
            while (child > 0) {
                if (_con[father] < _con[child]) {
                    swap(_con[father], _con[child]);
                    child = father;
                    father = (child - 1) / 2;
                }
                else {
                    break;
                }
            }
        }
        /* 向下调整算法 */
        void AdjustDown(size_t father) {
            size_t child = father * 2 + 1; // 默认认为左孩子大
            while (child < _con.size()) {
                // 判断右孩子是否存在，并且是否比左孩子大？
                if (child + 1 < _con.size() && _con[child] < _con[child + 1]) {
                    child += 1;
                }
 
                if (_con[father] < _con[child]) {
                    swap(_con[father], _con[child]);
                    father = child;
                    child = father * 2 + 1;
                }
                else {
                    break;
                }
            }
        }
 
        /* 入数据 */
        void push(const T& x) {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }
 
        /* 出数据 */
        void pop() {
            assert(!_con.empty());
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
 
            AdjustDown(0);
        }
 
        /* 返回堆顶数据 */
        const T& top() {
            return _con[0];
        }
 
        /* 返回大小 */
        size_t size() {
            return _con.size();
        }
 
        /* 判断是否为空 */
        bool empty() {
            return _con.empty();
        }
 
    private:
        Container _con;
    };
}

 测试：目前我们是写死了的大堆，还没有加入仿函数，我们先跑一下看看

void test_priority_queue1() {
    priority_queue<int> pQ;
    pQ.push(2);
    pQ.push(5);
    pQ.push(1);
    pQ.push(6);
    pQ.push(8);
 
    while (!pQ.empty()) {
        cout << pQ.top() << " ";
        pQ.pop();
    }
    cout << endl;
}

运行结果：

我们写死的最大问题是 —— 如果想按升序排列，就没办法排了。

我们这里写的用来排降序的大堆，如果想排升序我们需要写小堆，

C++ 在这里有一种叫仿函数的东西，可以控制这些东西，我们下面先来介绍一下仿函数。

 仿函数（functor）

概念：使一个类的使用看上去像一个函数。可以像函数一样使用的对象，称为函数对象。

其实现就是在类中重载 operator()，使得该类具备类似函数的行为，就是一个仿函数类了。

C语言优先级，() 圆括号使用形式为 表达式 或 "作为函数形参列表的括号" 

我们这里重载的其实就是：函数名(形参表)

代码：我们来写一个最简单的仿函数

namespace foxny {
    struct less {
        // 仿函数（函数对象）———— 对象可以像调用函数一样去使用
        bool operator()(int x, int y) {
            return x < y;
        }
    };
 
    void test_functor() {
        less lessCmp;   // 定义一个对象（这里我用小驼峰，能看上去更像函数）
        cout << lessCmp(10, 20) << endl;   // 是对象，但是却能像函数一样去使用
    }
}

 运行结果：1

这里定义对象的时候我用的我是小驼峰，这样看上去更像是一个函数了，以假乱真。

我们定义的 lessCmp 是一个对象，但是我们却可以像使用函数一样给它传递参数：

lessCmp(10, 20);

 我们还可以使其能够支持泛型，我们加一个 template 模板：

// 支持泛型
template<class T> struct less {
    bool operator()(const T& x, const T& y) const {
        return x < y;
    }
};
 
void test_functor() {
    less<int> lessCmp;
    cout << lessCmp(10, 20) << endl;
}

 less 是用来比较谁小的，对应的，我们再实现一个比较谁大的 greater：

// less: 小于的比较
template<class T> struct less {
    bool operator()(const T& x, const T& y) const {
        return x < y;
    }
};
// greater: 大于的比较
template<class T> struct greater {
    bool operator()(const T& x, const T& y) const {
        return x > y;
    }
};
 
void test_functor() {
    less<int> lessCmp;
    cout << lessCmp(10, 20) << endl;
 
    greater<int> GreaterCmp;
    cout << GreaterCmp(10, 20) << endl;
}

 运行结果：1   0

一个对象能像函数一样用，看上去很神奇，实际上调用的只是我们重载的 operator() 而已。

这些操作都是归功于运算符重载功能，这就是仿函数！

思考：我们在C阶段不是学过函数指针么，用函数指针不香吗？

函数指针确实可以做到这些功能。但是在这里函数指针跟仿函数比，一点都不香。

在 C++ 里其实是非常鄙夷使用函数指针的，函数的指针在一些地方用起来非常复杂。 

static void( * set_malloc_handler(void (*f)()))() {
    void (* old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = f;
    return(old);
}

这个函数的参数是什么？函数的返回值是什么？

这就很阴间了，这就是函数指针的杰作…… 所以 C++ 搞出了仿函数，简化了好多点。

加了仿函数后的优先级队列 

  我们现在用仿函数去比较那些数据，这样就不会写死了。

代码：priority_queue 

#include <iostream>
#include <vector>
#include <functional>  // 这里放的是一些仿函数
#include <assert.h>
using namespace std;
 
namespace foxny {
    // less: 小于的比较
    template<class T> 
    struct less {
        bool operator()(const T& x, const T& y) const {
            return x < y;
        }
    };
    // greater: 大于的比较
    template<class T> 
    struct greater {
        bool operator()(const T& x, const T& y) const {
            return x > y;
        }
    };
 
    template<class T, class Container = vector<T>, class Compare = less<T>>
    class priority_queue {
    public:
        /* 向上调整算法 */
        void AdjustUp(size_t child) {
            Compare cmpFunc;
 
            size_t father = (child - 1) / 2;
            while (child > 0) {
                // if (_con[father] < _con[child]) {
                if (cmpFunc(_con[father], _con[child])) {
                    swap(_con[father], _con[child]);
                    child = father;
                    father = (child - 1) / 2;
                }
                else {
                    break;
                }
            }
        }
        /* 向下调整算法 */
        void AdjustDown(size_t father) {
            Compare cmpFunc;
 
            size_t child = father * 2 + 1; // 默认认为左孩子大
            while (child < _con.size()) {
                // if (child + 1 < _con.size() && _con[child] < _con[child + 1]) {
                if (child + 1 < _con.size() && cmpFunc(_con[child], _con[child + 1])) {
                    child += 1;
                }
 
                // if (_con[father] < _con[child]) {
                if (cmpFunc(_con[father], _con[child])) {
                    swap(_con[father], _con[child]);
                    father = child;
                    child = father * 2 + 1;
                }
                else {
                    break;
                }
            }
        }
 
        /* 入数据 */
        void push(const T& x) {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }
 
        /* 出数据 */
        void pop() {
            assert(!_con.empty());
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
 
            AdjustDown(0);
        }
 
        /* 返回堆顶数据 */
        const T& top() {
            return _con[0];
        }
 
        /* 返回大小 */
        size_t size() {
            return _con.size();
        }
 
        /* 判断是否为空 */
        bool empty() {
            return _con.empty();
        }
 
    private:
        Container _con;
    };
}

 测试：我们来测试一下效果如何：

// 大于比较，搞小堆
void test_priority_queue2() {
    priority_queue<int, vector<int>, greater<int>> pQ;
    pQ.push(2);
    pQ.push(5);
    pQ.push(1);
    pQ.push(6);
    pQ.push(8);
 
    while (!pQ.empty()) {
        cout << pQ.top() << " ";
        pQ.pop();
    }
    cout << endl;
}

 运行结果：1 2 4 6 8

// 小于比较，搞大堆
void test_priority_queue1() {
    priority_queue<int> pQ;
    pQ.push(2);
    pQ.push(5);
    pQ.push(1);
    pQ.push(6);
    pQ.push(8);
 
    while (!pQ.empty()) {
        cout << pQ.top() << " ";
        pQ.pop();
    }
    cout << endl;
}

 运行结果：8 6 5 2 1

这里的仿函数在编译器视角是这样的： 

if (cmpFunc(_con[father], _con[child]))
                 👇
if (cmpFunc.operator()(_con[father], _con[child]))
                 👇
 
    // 以 less 为例
    template<class T> 
    struct less {
        bool operator()(const T& x, const T& y) const {
            return x < y;
        }
    };
 
最后返回 _con[father] < _con[child] ，true 还是 false

 迭代器的实现

// 创造空的优先级队列
priority_queue()
    : _con()
{}
 
// 迭代器
template<class InputIterator>
priority_queue (InputIterator first, InputIterator last) 
    : _con(first, last)
{
    while (first != last) {
        _con.push_back(*first++);
    }
 
    for (int father = (_con.size()-1-1) / 2; father >= 0; father++) {
        AdjustDown(father);
    }
}

 我们就可以拿这个来解决一些问题，比如：

    void test_priority_queue3() {
        // TOP K
        int arr[] = {1,4,2,7,8,9};
        priority_queue<int> pQ(arr, arr + 6);  // 传一个迭代器区间
    }

 完整代码

#include <iostream>
#include <vector>
#include <functional>  // 这里放的是一些仿函数
#include <assert.h>
using namespace std;
 
namespace foxny {
    // less: 小于的比较
    template<class T> 
    struct less {
        bool operator()(const T& x, const T& y) const {
            return x < y;
        }
    };
    // greater: 大于的比较
    template<class T> 
    struct greater {
        bool operator()(const T& x, const T& y) const {
            return x > y;
        }
    };
 
    template<class T, class Container = vector<T>, class Compare = less<T>>
    class priority_queue {
        Compare _cmpFunc;
    public:
        // 创造空的优先级队列
        priority_queue()
            : _con()
        {}
 
        // 迭代器
        template<class InputIterator>
        priority_queue (InputIterator first, InputIterator last) 
            : _con(first, last)
        {
            int count = _con.size();
            int root = ((count - 2) >> 1);
            for (; root >= 0; root--) {
                AdjustDown(root);
            }
        }
 
        /* 向上调整算法 */
        void AdjustUp(size_t child) {
            Compare cmpFunc;
 
            size_t father = (child - 1) / 2;
            while (child > 0) {
                // if (_con[father] < _con[child]) {
                if (cmpFunc(_con[father], _con[child])) {
                    swap(_con[father], _con[child]);
                    child = father;
                    father = (child - 1) / 2;
                }
                else {
                    break;
                }
            }
        }
        /* 向下调整算法 */
        void AdjustDown(size_t father) {
            Compare cmpFunc;
 
            size_t child = father * 2 + 1; // 默认认为左孩子大
            while (child < _con.size()) {
                // if (child + 1 < _con.size() && _con[child] < _con[child + 1]) {
                if (child + 1 < _con.size() && cmpFunc(_con[child], _con[child + 1])) {
                    child += 1;
                }
 
                // if (_con[father] < _con[child]) {
                if (cmpFunc(_con[father], _con[child])) {
                    swap(_con[father], _con[child]);
                    father = child;
                    child = father * 2 + 1;
                }
                else {
                    break;
                }
            }
        }
 
        /* 入数据 */
        void push(const T& x) {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }
 
        /* 出数据 */
        void pop() {
            assert(!_con.empty());
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
 
            AdjustDown(0);
        }
 
        /* 返回堆顶数据 */
        const T& top() {
            return _con[0];
        }
 
        /* 返回大小 */
        size_t size() {
            return _con.size();
        }
 
        /* 判断是否为空 */
        bool empty() {
            return _con.empty();
        }
 
    private:
        Container _con;
    };
 
    // 小于比较，搞大堆
    void test_priority_queue1() {
        priority_queue<int> pQ;
        pQ.push(2);
        pQ.push(5);
        pQ.push(1);
        pQ.push(6);
        pQ.push(8);
 
        while (!pQ.empty()) {
            cout << pQ.top() << " ";
            pQ.pop();
        }
        cout << endl;
    }
 
    // 大于比较，搞小堆
    void test_priority_queue2() {
        priority_queue<int, vector<int>, greater<int>> pQ;
        pQ.push(2);
        pQ.push(5);
        pQ.push(1);
        pQ.push(6);
        pQ.push(8);
 
        while (!pQ.empty()) {
            cout << pQ.top() << " ";
            pQ.pop();
        }
        cout << endl;
    }
}
 
int main(void)
{
    foxny::test_priority_queue1();
    foxny::test_priority_queue2();
 
    return 0;
}

 

加一zZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++容器之优先队列(std::priority_queue)
flysnow010的博客
05-27 575
优先级队列是一种容器适配器，专门设计为根据一些严格的弱排序标准，它的第一个元素始终是它所包含的元素中最大的一个。此上下文类似于堆(heap)，在堆中，元素可以随时插入，并且只能检索最大堆元素（优先级队列中最顶端的元素）。优先级队列被实现为容器适配器，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素从特定容器的“后部”弹出，即优先级队列的顶部。底层容器可以是任何标准容器类模板或某些其他专门设计的容器类。
C++ 中"priority_queue" 优先级队列实例详解
08-30
在C++编程语言中，`priority_queue`是一个非常有用的数据结构，它实现了优先级队列的概念。优先级队列不同于传统的FIFO（先进先出）队列，它遵循的是最大优先级原则，即每次从队列顶部弹出优先级最高的元素。在标准...
c++优先队列(priority_queue)用法详解
热门推荐
weixin_36888577的博客
04-14 49万+
既然是队列那么先要包含头文件#include &lt;queue&gt;优先队列具有队列的所有特性，包括基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的 定义：priority_queue&lt;Type, Container, Functional&gt; Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用
C++ 优先队列 priority_queue 使用篇
weixin_57761086的博客
10-04 3万+
介绍了学习priority_queue应该具有的储备知识：仿函数。通过对类的模板参数和函数的参数列表的解读来为后续的学习做铺垫。通过大量的代码示例来讲解三种情境下的元素存储，步步深入，学会仿函数和priority_queue的使用。
C++ priority_queue简单源码剖析：priority_queue模拟实现
Lvision2的博客
06-03 820
被叫做优先队列优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)，其数据结构类似于大堆。优先队列被实现为容器适配器容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。
【C++/STL深度剖析】priority_queue 最全解析（什么是priority_queue? priority_queue的常用接口有哪些？）
weixin_45031801的博客
07-04 2043
优先级队列 priority_queue 是容器适配器中的一种，常用来进行对数据进行优先级处理，比如优先级高的值在前面，这其实就是数据结构中的 堆，它俩本质上是一样东西，底层都是以数组存储的完全二叉树，不过优先级队列 priority_queue 中加入了 泛型编程 的思想，并且属于 STL 中的一部分。本就就来详细的讲解一下 priority_queue 是如何使用的！！
C++ queue 和priority_queue
徐凤年llll的博客
12-09 1038
优先级队列的适配会更复杂一些些。它的适配容器用的是vector。优先级队列就不是什么先进先出了，它虽然叫队列，但它不是真队列。其实它的底层是堆，可以在任意时刻插入数据，默认是大堆，当然也可以通过仿函数去调整。优先级队列有一个反人类的设计：传less仿函数，底层是大堆。传greater仿函数，底层是小堆。它的一些接口。
优先级队列priority_queue
weixin_47266712的博客
08-18 1万+
使用这种方式，需要显示定义优先级队列的容器类型和比较函数//函数对象类 template < typename T > class cmp {public ://重载 () 运算符 bool operator()(T a , T b) {} };int x;int y;};1 , 2 };0 , 2 };1 , 3 };2 , 5 };3 , 6 };// 显式指定容器类型和比较函数 pq . push(a);while(!}.........
[STL]priority_queue多种方式自定义排序
刘好念的博客
07-26 1万+
本文介绍了STL中priority_queue自定义排序的方法。
【C++】priority_queue使用与模拟实现
不 良的博客
07-13 704
1、priority_queue(优先级队列)是一种容器适配器，底层是一个完全二叉树的大堆（堆总是一颗完全二叉树，根结点最大的堆叫做大堆；根结点最小的堆叫做小堆），头文件在中，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。不按照先进先出，优先级高的先出，默认数字大的优先级高。2、类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。3、优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，priority_queue提供一组特定的成员函数
c++ priority_queue用法 入门必看 超详细
weixin_52115456的博客
10-31 1万+
基本定义默认是使用大顶堆的，即队首总是最大的元素priority_queue 容器名如：储存int型数据的优先级队列 priority_queue q;储存double型数据的优先级队列 priority_queue q;储存string型数据的优先级队列 priority_queue q;储存结构体或者类的优先级队列 priority_queue q;less 即使用大顶堆。
C++ 中”priority_queue” 优先级队列实例详解
12-31
C++ 中”priority_queue” 优先级队列实例详解 1. 简介 标准库队列使用了先进先出(FIFO)的存储和检索策略. 进入队列的对象被放置在尾部, 下一个被取出的元素则取自队列的首部. 标准库提供了两种风格的队列: FIFO ...
keyed_priority_queue
05-09
用法将此添加到您的Cargo.toml ： [ dependencies ]keyed_priority_queue = " 0.3 " 代码示例： use keyed_priority_queue :: {KeyedPriorityQueue, Entry};let mut queue = KeyedPriorityQueue :: new ();// ...
优先队列(priority_queue)的C语言实现代码
09-04
同样，`priority_queue_enqueue` 的实现会涉及调整二叉堆以保持优先级规则，这通常涉及到插入元素后向上调整的过程，确保新插入的元素在其父节点之上（如果遵循最大优先级规则）。 总的来说，优先队列的C语言实现...
数据结构之树的存储结构
DKPT的博客
08-16 538
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
【Java & 数据结构】初识二叉树
qq_42150700的博客
08-20 480
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
C语言基础（六）
最新发布
wehpd的博客
08-20 229
一维数组
数据结构day01（数据结构、算法基础知识）
dghbs的博客
08-20 769
数据结构就是数据的逻辑结构存储结构以及操作（类似数据的运算）数据结构的最终目的就是：如何更高效的存储数据算法对特定问题求解步骤的一种描述，它是指令的有限序列，期中每一条指令都表示一个或多个操作。数据结构 + 算法 = 程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值