priority_queue的模拟实现和仿函数

priority_queue模拟

首先查看源代码，源代码就在queue剩下的部分中

push_heap是STL库中的堆算法，STL库中包装有支持堆的算法，在algorithm.h中：

只要不断用堆的形式插入数据，就会形成堆。

priority_queue模拟——初版

priority_queue.h中

#pragma once

#include<iostream>

#include<vector>

#include<assert.h>

using namespace std;

template<class T, class container = vector<int>>

class myPriority_queue

{

public:

        void adjustUp(int lea) //向上调整算法，在插入数据后，将数据重新调整为堆时使用，lea为尾节点下标

        {

               if (lea == 0)

                       return;

               size_t fa = (lea - 1) / 2;

               while (_con[fa] < _con[lea])

               {

                       swap(_con[fa], _con[lea]);

                       lea = fa;

                       fa = (lea - 1) / 2;

               }

        }

        void adjustDown() //向下调整算法，在删除数据后，使空间重新调整为堆时使用，从根节点开始调整，不需要传入数据

        {

               size_t ch = 1; //代表子节点

               size_t fa = 0; //代表父节点

               while (ch < _con.size() && _con[fa] < _con[ch])

               {

                       if (ch + 1 < _con.size() && _con[ch] < _con[ch + 1]) //开始默认左子节点大

                              ch++;

                       swap(_con[fa], _con[ch]);

                       fa = ch;

                       ch = fa * 2 + 1;

               }

        }

        void push(const T& x)

        {

               _con.push_back(x);

               int lea = _con.size() - 1;

               adjustUp(lea);

        }

        void pop()

        {

               assert(!_con.empty());

               size_t tail = _con.size() - 1;

               swap(_con[0], _con[tail]);

               _con.pop_back();

               adjustDown();

        }

        const T& top()

        {

               return _con[0];

        }

        size_t size()

        {

               return _con.size();

        }

        bool empty()

        {

               return _con.empty();

        }

private:

        container _con;

};

test.cpp中

#define _CRT_SECURE_NO_WARNINGS 1

#include"priority_queue.h"

#include<iostream>

#include<vector>

using namespace std;

void test_priority_queue()

{

        myPriority_queue<int> pri_qu;

        pri_qu.push(8);

        pri_qu.push(2);

        pri_qu.push(5);

        pri_qu.push(1);

        pri_qu.push(4);

        pri_qu.push(3);

        cout << pri_qu.empty() << " " << pri_qu.size() << endl;

        while(!pri_qu.empty())

        {

               cout << pri_qu.top() << " ";

               pri_qu.pop();

        }

        cout << endl;

}

int main()

{

        test_priority_queue();

        return 0;

}

这样写出来的优先级队列只能排升序，而实际上的优先级队列是可以排升序，也可以排降序的。

实现升序降序控制的叫仿函数，即一开始priority_queue源代码看到的第三个模板参数。

所谓仿函数函数实际上是一个对象，在对象中重载了 '()' 符号，已知 '()' 符号有两种用法，一是(表达式)，可以用于数据类型强转，或者控制优先级；一是作函数调用，这里重载的就是函数调用，将类写成一个类似函数的使用方式，所以叫仿函数。也叫函数对象。

下面写一个简单的仿函数：

class less

{

    bool operator()(int x, int y)

    {

        return x < y;

    }

};

使用这个类：

less  l1;

bool ret = l1(10, 20)

将仿函数修改为泛型：

template<class T>

class less

{

    bool operator()(const T& x, const T& y) const

    {

        return x < y; //支持的前提条件是类型要支持用 < 符号来进行大小的比较

    }

};

仿函数是一个类，是类就可以作为参数传递。

priority_queue模拟——进阶版（只是添加上了仿函数）

priority_queue.h中

#pragma once

#include<iostream>

#include<vector>

#include<assert.h>

using namespace std;

template<class T>

class myless

{

public:

        bool operator()(const T& x, const T& y) const

        {

               return x < y;

        }

};

template<class T>

class mygreater

{

public:

        bool operator()(const T& x, const T& y) const

        {

               return x > y;

        }

};

template<class T, class container = vector<int>, class compare = myless<T>> //和库中一样，默认为大堆

class myPriority_queue

{

public:

        void adjustUp(int lea) //向上调整算法，在插入数据后，将数据重新调整为堆时使用，lea为尾节点下标

        {

               compare func;

               if (lea == 0)

                       return;

               size_t fa = (lea - 1) / 2;

                /*while (_con[fa] < _con[lea])*/

               while (func(_con[fa], _con[lea]))

              //利用仿函数达到比较的效果

             //现在不清楚是大于还是小于了，具体将取决于传入compare的类。

             //通过控制仿函数的类型，达到控制大堆还是小堆的效果。

               {

                       swap(_con[fa], _con[lea]);

                       lea = fa;

                       fa = (lea - 1) / 2;

               }

        }

        void adjustDown(size_t father = 0)

         //向下调整算法，在删除数据后，使空间重新调整为堆时使用

        //默认从根节点开始调整，在建堆时使用就需要传入第一个非叶子节点

        {

               compare func;

               size_t fa = father; //代表父节点

               size_t ch = fa * 2 + 1; //代表子节点

                /*while (ch < _con.size() && _con[fa] < _con[ch])*/

               while (ch < _con.size() && func(_con[fa], _con[ch]))

               {

                        //if (ch + 1 < _con.size() && _con[ch] < _con[ch + 1])//开始默认左子节点大

                       if (ch + 1 < _con.size() && func(_con[ch], _con[ch + 1]))

                              ch++;

                       swap(_con[fa], _con[ch]);

                       fa = ch;

                       ch = fa * 2 + 1;

               }

        }

        //push，pop，top，size，empty部分和上面一样，这里省略

private:

        container _con;

};

test.cpp中

#define _CRT_SECURE_NO_WARNINGS 1

#include"priority_queue.h"

#include<iostream>

#include<vector>

using namespace std;

void test_priority_queue()

{

        myPriority_queue<int,vector<int>, mygreater<int>> pri_qu; //通过传仿函数控制为小堆，默认为大堆。

        

        //剩下的部分一样，这里省略

}

int main()

{

        test_priority_queue();

        return 0;

}

利用模板实现不同比较的调用过程。

当使用默认传参时，compare被myless<T>赋值，compare创建的func对象，是myless的对象，func(_con[fa], _con[lea])会调用myless类中的成员函数，完成比较。当使用mygreater<T>传参时，compare被mygreater<T>赋值，compare创建的func对象，是mygreater的对象，func(_con[fa], _con[lea])会调用mygreater类中的成员函数，完成比较。

下面函数指针的内容了解就可以：

less和greater都是在库中包装好的仿函数，使用需要包头文件<functional>。一般利用仿函数的优势来替换函数指针。如果myPriority_queue传给compare的不是仿函数，而是函数指针会如何？

准备知识：

1.对函数指针解引用，找到对应函数，调用参数，和直接使用函数指针调用参数是一样的，即(*函数指针)(函数参数1.函数参数2)与函数指针(函数参数1，函数参数2)等价，代表函数指针可以直接使用()操作符，这样就能通过函数指针指向对应的比较函数，完成比较。

2.模板会自动推导类型，传什么就是什么，不会构造成单成员变量的类。

先来看一下函数指针的应用：

这是一个函数，*和()相比，()优先级更高，函数名与()结合，为函数。括号内的内容，即函数参数为void (*f)()，f是名称，与*结合，是函数指针，指向一个返回值为void，没有参数的函数。最后剩下：static void(* )()是返回值，即函数的返回值是一个函数指针，指针指向的类型为无参，返回值为static void。

模板具备自动推导的功能，可以兼容使用函数指针完成比较。

bool comIntLess(int x, int y)

{

    return x > y;

}

myPriority_queue<int,vector<int>, bool(* )(int, int)> pri_qu; //模板参数要传类型

按照想象，应该是传入函数指针，compare推导出指针类型，创建func函数指针变量，func(参数1,参数2)调用comIntLess函数。

但是直接这样替换myPriority_queue<int,vector<int>, greater<int>> pri_qu;会出错。

因为compare推导出函数指针类型后，compare func创建的变量是一个没有初始化的函数指针变量，函数指针指向未知。传过去的是类型，没有指向具体函数，不知道调用哪个函数。

要用函数指针，需要在构造的地方传入。同时要兼顾仿函数的传入，这就需要在一些地方做修改：简单来说就是把负责比较的类变成成员变量。

1.添加一个成员变量_comfunc

2.写myPriority_queue的构造函数

myPriority_queue(const compare& x = compare())

    :_comfunc(x)

{}

//传给compare为仿函数类时，x是类，传给compare为函数指针时，x是指针。类创建的_comfunc对象可以调用类的成员函数

//这样是方便传入函数指针，即使不写构造函数，仿函数依然能正常使用，自定义类型为成员变量时会自动调用构造函数，也就是compare()。单凭模板是无法将函数地址传入myPriority_queue中。

//即使这样也不能在传模板参数的时候传入函数指针，而是通过构造函数完成指针的传值。

3.将所有func改为_comfunc

4.在创建优先级队列的地方将函数指针传入：myPriority_queue<int,vector<int>, bool(* )(int, int)> pri_qu(comIntLess)

总之，函数指针也能达到仿函数的效果，但比仿函数复杂，这还只是一个简单函数的情况下。

大多数情况下库中的仿函数就够用，在一些情况下需要自己写。

以c++sort为例：

可以看见，sort中也是有仿函数的。

运行如下程序，及其运行结果：

sort的传参和优先级队列仿函数传参不同的是多了一个()，原因在于优先级队列传的是模板参数，这里传的是对象，优先级队列是在内部创建对象，sort是将创建好的对象传入sort使用。sort是一个函数模板（优先级队列是类模板），传递的是函数的参数，所以这里传的应该是对象，而不是类型。

当需要对自定义类型进行排序的时候，就需要自己写仿函数了，有点类似运算符重载。

sort可以对数组进行排序吗？

数组空间连续，其迭代器本质就是指针，完全可以用sort对数组进行排序。

sort排序的基本原则之一就是要知道要排序对象的大小关系。或者说被排序的对象要有大小的比较规则。

这样的排序是会报错的，因为没有goods类的比较规则。当传入两个goods类的对象到less仿函数中，struct中没有对<的重载，也就无法比较大小，实现升序排序；要进行降序排序也需要对>进行重载。

所以要加上比较方式：

排序前：

排序后：

按照价格升序进行排列。但是也有没解决的问题，如果要按照销量进行排序呢？

<可以被重载两次吗？当然可以，但是要如何解决参数类型不同的问题呢？less中的比较是两个goods对象的比较，即<重载的函数参数就固定为两个goods对象。

这时候仿函数就有用了，就是比较麻烦。当然，这个麻烦是有解决方案的。解决方案需要以后的知识（c++11中）。

将仿函数传给compare作为比较方式。升序的排序方式也是需要仿函数手动实现的，所以说比较麻烦。

重载<和仿函数的区别在于：

重载<函数是被库中用于比较的less仿函数调用的，less在比大小时，调用了operator<；

而手动仿函数则是取代less，完成比较的目的(compare类型为lessPrice，在sort中创建一个lessPrice对象，这个对象来对传入的两个goods对象比大小)。

补充一点：优先级队列有靠区间构造的方式，这个还是很有用的，比如需要对一个数字进行TopK问题的解决，这时用数组的区间构造一个优先级队列就能解决。

在兼容函数指针的版本下继续修改：即新写一个构造函数要支持传迭代器完成建堆

myPriority_queue(InputIterator first, InputIterrator last, const compare& x = compare())

//这里是构造函数，所以没有Container

    :_comfunc(x)

{

    while(first != last)

    {

        _con.push_back(*first);

        first++;

    }

    for(size_t i = (_con.size() - 1 - 1) / 2; i >= 0; i--) //_con.size() - 1是尾节点，(尾节点-1)/2得到第一个非叶子节点

    {

        adjustdown(i);

    }

}