【手撕】priority_queue

系列文章目录

---

---

前言

模拟实现priority_queue。

---

#pragma once
#include <vector>
#include <iostream>
#include <deque>

using namespace std;

namespace yyf
{
	template<class T>
	struct less//大堆
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	struct greater//小堆
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	// 默认大堆
	template<class T, class Container = vector<T>, class Comapre = less<T>>
	class priority_queue
	{
	public:
		void adjust_up(int child)
		{//向上调整
			Comapre com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//(_con[parent] < _con[child])
				//com(_con[parent], _con[child]
				if (Comapre()(_con[parent], _con[child]))
				{//匿名对象
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(int parent)
		{//向下调整
			
			int child = parent * 2 + 1;
			while(child < _con.size())
			{
				Comapre com;
				if (child + 1 < _con.size() &&  com(_con[child],_con[child + 1]))
				{
					++child;
				}
				
				if (com(_con[parent],_con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
				
			}
		}


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

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

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

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

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
        //成员变量
	};

}

void test_priority_queue()
{
    priority_queue<int, deque<int>, less<int>> pq;
    //priority_queue<int, deque<int>> pq;
    pq.push(1);
    pq.push(0);
    pq.push(5);
    pq.push(2);
    pq.push(1);
    pq.push(7);


    while (!pq.empty())
    {
        cout << pq.top() << " ";
        pq.pop();
    }
    cout << endl;
}



class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}
    bool operator<(const Date& d)const
    {
        return (_year < d._year) ||
            (_year == d._year && _month < d._month) ||
            (_year == d._year && _month == d._month && _day < d._day);
    }
    bool operator>(const Date& d)const
    {
        return (_year > d._year) ||
            (_year == d._year && _month > d._month) ||
            (_year == d._year && _month == d._month && _day > d._day);
    }
    friend ostream& operator<<(ostream& _cout, const Date& d)
    {
        _cout << d._year << "-" << d._month << "-" << d._day;
        return _cout;
    }
private:
    int _year;
    int _month;
    int _day;
};

struct PDateLess
{
public:
    bool operator()(const Date* p1, const Date* p2)
    {
        return *p1 < *p2;
    }
};

struct PDateGreater
{
public:
    bool operator()(const Date* p1, const Date* p2)
    {
        return *p1 > *p2;
    }
};

void TestPriorityQueue()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date*, vector<Date*>, PDateLess> q1;
    q1.push(new Date(2018, 10, 29));
    q1.push(new Date(2018, 10, 28));
    q1.push(new Date(2018, 10, 30));
    cout << *(q1.top()) << endl;
    // 如果要创建小堆，需要用户提供>的重载
    priority_queue<Date, vector<Date>, greater<Date>> q2;
    q2.push(Date(2018, 10, 29));
    q2.push(Date(2018, 10, 28));
    q2.push(Date(2018, 10, 30));
    cout << q2.top() << endl;
}