【C++】仿函数(less)

C++中的仿函数

c++ 复制代码
class Solution {
public:

    struct cmp
    {
        bool operator()(const pair<string,int>&kv1,const pair<string,int>&kv2)
        {
            if(kv1.second<kv2.second) return true;

            if(kv1.second==kv2.second&&kv1.first>kv2.first) return true;

            return false;
        }
    };

    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int>mp;
        for(auto& w:words)
        {
            mp[w]++;
        }
        priority_queue<pair<string,int>,vector<pair<string,int>>,cmp>pq(mp.begin(),mp.end());
       
        vector<string>res;

        while(k--)
        {
            res.push_back(pq.top().first);
            pq.pop();
        }
        return res;
    }
};

对于以上代码一开始存在一点疑问,为什么自定义一下堆的排序规则还需要定义一个类、结构体然后再在类里面重写operator() ,于是我跑去看了一下文档对priority_queue的定义。

嚯,比较器是一个类

这里的value_type是一个模板参数。

可以看到less<>当中没有具体的参数,typename显示的告诉编译器后面是一个类型 ,这里是告诉编译器,在Container这个类(容器)当中的value_type是一个类型。

less 是一个函数对象(即仿函数)或者函数模板,它不需要具体的变量名来执行比较操作。

<>用于指定类型,好让less的模板参数识别类型。

c++ 复制代码
template <class T>
  struct less : binary_function <T,T,bool> {
  bool operator() (const T& x, const T& y) const {
      return x<y;//升序,小的在前
  }
};

再来看之前模拟实现的priority_queue代码,真的是边学边忘。

c++ 复制代码
template<class T, class Container = vector<T>,class Compare=std::less<T>>
    class priority_queue
    {
    public:
        priority_queue()
        {}

        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                _con.push_back(*first);
                first++;
            }

            for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
            {
                Adjust_down(i);
            }
        }

        size_t size()
        {
            return _con.size();
        }

        void Adjust_up(size_t child)
        {
            Compare compare;
            size_t parent = (child - 1) / 2;
            while (child>0)
            {
                if (compare(_con[parent],_con[child]))
                {
                    std::swap(_con[parent], _con[child]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else
                {
                    break;
                }
            }

        }

        void Adjust_down(size_t parent)
        {
            Compare com;
            size_t child = parent * 2 + 1;
            while (child < _con.size())
            {
                // 选出左右孩子中大的那一个
                //if (child+1 < _con.size() && _con[child+1] > _con[child])
                //if (child + 1 < _con.size() && _con[child] < _con[child + 1])
                if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
                {
                    ++child;
                }

                //if (_con[child] > _con[parent])
                //if (_con[parent] < _con[child])
                if (com(_con[parent], _con[child]))
                {
                    std::swap(_con[child], _con[parent]);
                    parent = child;
                    child = parent * 2 + 1;
                }
                else
                {
                    break;
                }
            }
        }

        void push(const T& val)
        {
            _con.push_back(val);
            Adjust_up(_con.size()-1);//调堆
        }

        void pop()
        {
            std::swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
            Adjust_down(0);
        }

        const T& top()const
        {
            return _con[0];
        }

        bool empty()
        {
            return (_con.size() == 0);
        }

        bool empty() const 
        {
            return (_con.size()==0);
        }

    private:
        Container _con;//容器
    };

将重点抠出来

c++ 复制代码
template<class T, class Container = vector<T>,class Compare=std::less<T>>
c++ 复制代码
void Adjust_down(size_t parent)
        {
            Compare com;//比较器
            size_t child = parent * 2 + 1;
            while (child < _con.size())
            {
                if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
                {
                    ++child;
                }
                
                if (com(_con[parent], _con[child]))
                {
                    std::swap(_con[child], _con[parent]);
                    parent = child;
                    child = parent * 2 + 1;
                }
                else
                {
                    break;
                }
            }
        }
C++ 复制代码
Compare com;//比较器
com(_con[child], _con[child + 1]);//直接调用重载的运算符operator()

就是这样通过重载operator()来改变排序规则的。

总结:less是一个类、通过调用operator()来实现排序规则

相关推荐
小鲈鱼-5 分钟前
【LeetCode4.寻找两个正序数组的中位数】二分O(log(m+n))
c++·算法
橘颂TA8 分钟前
【C++】红黑树的底层思想 and 大厂面试常问
数据结构·c++·算法·红黑树
啊我不会诶21 分钟前
倍增法和ST算法 个人学习笔记&代码
笔记·学习·算法
逼子格35 分钟前
振荡电路Multisim电路仿真实验汇总——硬件工程师笔记
笔记·嵌入式硬件·硬件工程·硬件工程师·硬件工程师真题·multisim电路仿真·震荡电流
三体世界43 分钟前
TCP传输控制层协议深入理解
linux·服务器·开发语言·网络·c++·网络协议·tcp/ip
一条破秋裤1 小时前
一份多光谱数据分析
笔记·数据挖掘·数据分析
你的冰西瓜1 小时前
C++ 中最短路算法的详细介绍
c++·算法·图论·最短路
随心点儿1 小时前
使用python 将多个docx文件合并为一个word
开发语言·python·多个word合并为一个
zstar-_1 小时前
【算法笔记】6.LeetCode-Hot100-链表专项
笔记·算法·leetcode
不学无术の码农1 小时前
《Effective Python》第十三章 测试与调试——使用 Mock 测试具有复杂依赖的代码
开发语言·python