文章目录

一、优先级队列简介
二、优先级队列的接口说明
- 1.基本介绍及其使用
- 2.构造函数
- 3.求数组中第k个最大的元素
三、手撕优先级队列
四、仿函数
- 1.仿函数介绍
- 2.优先级队列添加仿函数
- 3.需要自己写仿函数的情形
五、优先级队列完整代码

一、优先级队列简介

在这里插入图片描述

优先级队列是一种容器适配器，根据某种严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大的堆元素(优先级队列中位于顶部的元素)。

优先级队列是作为容器适配器实现的，这些适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素从特定容器的“后面”弹出，这被称为优先级队列的顶部。

底层容器可以是任何标准容器类模板或其他特定设计的容器类。容器必须可以通过随机访问迭代器访问，并支持以下功能操作：empty、size、front、push_back、pop_back

标准容器类vector和deque满足这些要求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用标准容器向量。

为了始终在内部保持堆结构，需要支持随机访问迭代器。这是由容器适配器在需要时自动调用算法函数make_heap、push_heap和pop_heap自动完成的。

二、优先级队列的接口说明

1.基本介绍及其使用

优先级队列的接口有如下几种。对于优先级队列我们默认是它的大的数优先级高。其底层是一个堆。也就是说，我们默认是大堆，所以大的数优先级高。如果是一个小堆，那么就是小的优先级高。
在这里插入图片描述

我们来简单的使用一下这些接口

void test_priority_queue()
{priority_queue<int> pq;pq.push(1);pq.push(10);pq.push(2);pq.push(51);pq.push(4);while (!pq.empty()){cout << pq.top() << " ";pq.pop();}cout << endl;
}

在这里插入图片描述

可以看到，默认是一个大堆，但是我们会注意到，它库里面默认传的是less，但是却是一个大堆，这里需要额外注意一下。
在这里插入图片描述
所以我们如果想要是一个小堆的话，我们需要将这个less替换为greater

在这里我们传的less，greater这些也称之为仿函数。也就是说，通过仿函数控制实现大小堆.

除此之外，这里除了可以传vector以外，还可以传递deque，但是由于堆需要大量访问[]运算符，所以deque的效率不高。

2.构造函数

对于它的构造函数也是比较简单的，如下所示，可以无参构造，也可以用迭代器区间进行初始化。
在这里插入图片描述

3.求数组中第k个最大的元素

题目链接：数组中第k个最大元素

这道题其实就是top-k问题，由于优先级队列就是一个堆，所以我们直接使用优先级队列可以很轻松的完成这道题

下面是建大堆的方法

class Solution {
public:int findKthLargest(vector<int>& nums, int k) {priority_queue<int> pq(nums.begin(),nums.end());while(--k){pq.pop();}return pq.top();}
};

下面是建小堆的方法，注意我们的模板参数。

class Solution {
public:int findKthLargest(vector<int>& nums, int k) {priority_queue<int,vector<int>,greater<int>> pq(nums.begin(),nums.begin()+k);for(int i=k;i<nums.size();i++){if(nums[i]>pq.top()){pq.pop();pq.push(nums[i]);}}return pq.top();}
};

三、手撕优先级队列

如下代码所示，对于优先级队列，主要还是堆的逻辑的实现。即堆的构造，向上调整和向下调整。

	template<class T, class Container = vector<T>>class priority_queue{private:void AdjustDown(int parent){int child = parent * 2 + 1;while (child<_con.size()){if (child + 1 < _con.size() && _con[child] < _con[child + 1]){child++;}if (_con[child] > _con[parent]){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}}void AdjustUp(int child){int parent = (child - 1) / 2;while (child > 0){if (_con[child] > _con[parent]){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}public: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--){AdjustDown(i);}}priority_queue(){}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();AdjustDown(0);}void push(const T& val){_con.push_back(val);AdjustUp(_con.size() - 1);}const T& top(){return _con[0];}bool empty(){return _con.empty();}size_t size(){return _con.size();}private:Container _con;};

四、仿函数

1.仿函数介绍

我们知道对于优先级队列可以用仿函数改变其是大堆还是小堆。根据底层逻辑可知，仿函数应该就是改变了大小比较。才改变的行为。我们可以写一个简单的仿函数类

如下所示就是一个最简单的仿函数

	class less{public:bool operator()(int x, int y){return x < y;}};

这样我们就可以类似于一个函数一样进行比较大小了，仿函数即函数对象，可以让类对象像函数一样使用
在这里插入图片描述

我们可以继续将这个仿函数扩展成模板，如下所示，这样更加贴近于我们的使用

	template<class T>class less{public:bool operator()(const T& x, const T& y){return x < y;}};

在这里插入图片描述

有了仿函数，我们就可以在前面的优先级队列中使用仿函数来切换大堆小堆了。在C语言中，我们想要实现这个功能只有使用函数指针。而这个仿函数就刚好可以替换掉函数指针。因为函数指针的弊端太明显了，它太过于复杂了，可读性不好。

2.优先级队列添加仿函数

#pragma once
namespace Sim
{template<class T, class Container = vector<T>, class Compare = less<T>>class priority_queue{private:void AdjustDown(int parent){Compare com;int 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])){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}}void AdjustUp(int child){Compare com;int parent = (child - 1) / 2;while (child > 0){if (com(_con[parent], _con[child])){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}public: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--){AdjustDown(i);}}priority_queue(){}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();AdjustDown(0);}void push(const T& val){_con.push_back(val);AdjustUp(_con.size() - 1);}const T& top(){return _con[0];}bool empty(){return _con.empty();}size_t size(){return _con.size();}private:Container _con;};template<class T>class less{public:bool operator()(const T& x, const T& y){return x < y;}};template<class T>class greater{public:bool operator()(const T& x, const T& y){return x > y;}};
}

接下来我们可以去测试一下我们的优先级队列，用内置类型是没有什么问题的，我们可以使用自定义类型来进行测试，比如将我们之前所写的日期类给导入进来

这里直接给出我们的代码

Date.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
class Date
{//友元函数声明friend ostream& operator<<(ostream& out, const Date& d);friend istream& operator>>(istream& in, Date& d);
public:Date(int year = 1, int month = 1, int day = 1);void Print() const{cout << _year << '-' << _month << '-' << _day << endl;}bool operator<(const Date& x) const;bool operator==(const Date& x) const;bool operator<=(const Date& x) const;bool operator>(const Date& x) const;bool operator>=(const Date& x) const;bool operator!=(const Date& x) const;int GetMonthDay(int year, int month) const;Date& operator+=(int day);Date& operator-=(int day);Date operator+(int day) const;Date operator-(int day) const;Date& operator++();Date operator++(int);Date& operator--();Date operator--(int);int operator-(const Date& d) const;private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

Date.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"
Date::Date(int year, int month, int day)
{if (month > 0 && month < 13&& day>0 && day <= GetMonthDay(year, month)){_year = year;_month = month;_day = day;}else{cout << "非法日期" << endl;assert(false);}
}
bool Date::operator<(const Date& x) const
{if (_year < x._year){return true;}else if (_year == x._year && _month < x._month){return true;}else if (_year == x._year && _month == x._month && _day < x._day){return true;}return false;
}
bool Date::operator==(const Date& x) const
{return (_year == x._year) &&(_month == x._month) &&(_day == x._day);
}
bool Date::operator<=(const Date& x) const
{return (*this < x) || (*this == x);
}
bool Date::operator>(const Date& x) const
{return !(*this <= x);
}
bool Date::operator>=(const Date& x) const
{return !(*this < x);
}
bool Date::operator!=(const Date& x) const
{return !(*this == x);
}
int Date::GetMonthDay(int year, int month) const
{if (month <= 12 && month >= 1){const static int ArrDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };if (month == 2 && ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0))){return 29;}return ArrDay[month];}cout << "非法日期" << endl;return -1;
}
Date& Date::operator+=(int day)
{if (day < 0){return *this -= -day;}_day += day;while (_day > GetMonthDay(_year, _month)){_day -= GetMonthDay(_year, _month);_month++;if (_month > 12){_month -= 12;_year++;}}return *this;
}
Date& Date::operator-=(int day)
{if (day < 0){return *this += -day;}_day -= day;while (_day <= 0){_month--;if (_month <= 0){_month += 12;_year--;}_day += GetMonthDay(_year, _month);}return *this;
}
Date Date::operator+(int day) const
{Date tmp = *this;return tmp += day;
}
Date Date::operator-(int day) const
{Date tmp = *this;return tmp -= day;
}
Date& Date::operator++()
{*this += 1;return *this;
}
Date Date::operator++(int)
{Date tmp = *this;*this += 1;return tmp;
}
Date& Date::operator--()
{*this -= 1;return *this;
}
Date Date::operator--(int)
{Date tmp = *this;*this -= 1;return tmp;
}
int Date::operator-(const Date& d) const
{Date max = *this;Date min = d;int flag = 1;if (max < min){max = d;min = *this;flag = -1;}int n = 0;while (max != min){min++;n++;}return flag * n;
}
//流插入不能写成成员函数
//因为Date对象默认占用第一个参数，就是做了左操作数
//写出来就是下面的样子，不符合我们的使用习惯
//d1<<cout;
ostream& operator<<(ostream& out, const Date& d)
{out << d._year << "年" << d._month << "月" << d._day << "日" << endl;return out;
}
istream& operator>>(istream& in, Date& d)
{int year, month, day;in >> year >> month >> day;if (month > 0 && month < 13&& day>0 && day <= d.GetMonthDay(year, month)){d._year = year;d._month = month;d._day = day;}else{cout << "非法日期" << endl;assert(false);}return in;
}

然后我们用下面的代码进行测试

void Date_test()
{//Sim::priority_queue<Date, vector<Date>, greater<Date>> pq;Sim::priority_queue<Date> pq;pq.push(Date(2023, 7, 1));pq.push(Date(2023, 7, 10));pq.push(Date(2023, 7, 12));pq.push(Date(2023, 7, 13));while (!pq.empty()){cout << pq.top();pq.pop();}cout << endl;
}

符合我们的预期
在这里插入图片描述

3.需要自己写仿函数的情形

我们的上面的仿函数是模拟库里面的行为，上面的仿函数在库里面早已给出，我们无需自己动手写。但是有时候我们也需要自己去写一个仿函数。

如下测试用例，我们此时存储的是一个指针，而不是一个对象

void Date_test1()
{//Sim::priority_queue<Date, vector<Date>, greater<Date*>> pq;Sim::priority_queue<Date*> pq;pq.push(new Date(2023, 7, 1));pq.push(new Date(2023, 7, 10));pq.push(new Date(2023, 7, 12));pq.push(new Date(2023, 7, 13));while (!pq.empty()){cout << *(pq.top());pq.pop();}cout << endl;
}

在这里插入图片描述

这时候我们的比较逻辑就会出问题，我们只能自己写一个去比较指针指向的内容

如下代码所示

struct LessPDate
{bool operator()(Date* x, Date* y){return *x < *y;}
};

在这里插入图片描述

五、优先级队列完整代码

#pragma once
namespace Sim
{template<class T, class Container = vector<T>, class Compare = less<T>>class priority_queue{private:void AdjustDown(int parent){Compare com;int 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])){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}}void AdjustUp(int child){Compare com;int parent = (child - 1) / 2;while (child > 0){if (com(_con[parent], _con[child])){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}public: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--){AdjustDown(i);}}priority_queue(){}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();AdjustDown(0);}void push(const T& val){_con.push_back(val);AdjustUp(_con.size() - 1);}const T& top(){return _con[0];}bool empty(){return _con.empty();}size_t size(){return _con.size();}private:Container _con;};template<class T>class less{public:bool operator()(const T& x, const T& y){return x < y;}};template<class T>class greater{public:bool operator()(const T& x, const T& y){return x > y;}};
}