692. 前K个高频单词

692. 前K个高频单词

class Solution {
public:
    struct ComCoV
    {
        bool operator()(map<string,int>::iterator &l,map<string,int>::iterator &r)
        {
             if(l->second < r->second)   //这里是个坑，堆 < 是大堆
             return true;
             else if(l->second ==  r->second && l->first > r->first) //这里又是坑，比较pair第二个不用> 正常比较
             return true;
             else
             return false;
        }
    };
    vector<string> topKFrequent(vector<string>& words, int k) {
        vector<string> v;
        map<string,int>mp;
        for(const auto & e: words)
        {
            ++mp[e];
        }
        priority_queue<map<string,int>::iterator,vector<map<string,int>::iterator>,ComCoV> q;
//这里又是坑，优先级队列第二个参数的容器，其他容器都是比较器（仿函数）
        auto it = mp.begin();
        while(it != mp.end())
        {
            q.push(it);
            ++it;
        }
        while(k--)
        {
            v.push_back(q.top()->first);
            q.pop();
        }
        return v;
    }
};

 可以参考我自己写的priority_queue

#pragma once
#include<iostream>
#include"vector.h"
#include<algorithm>
#include<vector>
#include"data.h"

namespace bit
{
	template <class T>
	struct Less  //防函数
	{
		bool operator()(const T &a, const T &b)const 
		{
			return a < b;
		}
	};
	template<>
	struct Less<Data*>  //模板特化
	{
		bool operator()(const Data* a, const  Data* b)const
		{
			return *a < *b;
		}
	};
	template <class T>
	struct Greater
	{
		bool operator()(const T& a, const T& b)const
		{
			return a > b;
		}
	};
	template<>
	struct Greater<Data*>
	{
		bool operator()(const Data* a, const  Data* b)const
		{
			return *a > *b;
		}
	};
	template <class T, class Container = vector<T>, class Compare = Less<T>> //默认Less是大堆
	class priorirty_queue
	{
	private:
		void AdJustUp(int child)
		{
			Compare com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] < _con[child])
			   if(com(_con[parent],_con[child]))
				{
					std::swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void AdjustDown(int parent)
		{
			Compare com;
			int child = 2 * parent + 1;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child] > _con[parent])
				if(child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}
				if (com(_con[parent],_con[child]))
			  //if(com(_con[child], _con[child + 1]))
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}
	public:
		priorirty_queue() :_con(){};
		template <class iterator>
		priorirty_queue(iterator frist, iterator last)
			:_con( frist, last)
		{
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				AdjustDown(i);
			}
		}
		void push(const T & val)
		{
			_con.push_back(val);
			AdJustUp(_con.size() -1);
		}
		void pop()
		{
			if (empty()) return;
			std::swap(_con.front(), _con.back());
			_con.pop_back();
			AdjustDown(0);
		}
		 T& top()
		{
			return _con.front();
		}
		bool empty() const 
		{
			return _con.empty();
		}
		size_t size() const 
		{
			_con.size();
		}
	private:
		Container _con;
	};


	void priority_queue_test()
	{
		//priorirty_queue<int> pq;
		//pq.push(1);
		//pq.push(2);
		//pq.push(9);
		//pq.push(3);
		//pq.push(5);
		priorirty_queue<Data*> pq;
		pq.push(new Data(2021, 4, 19));
		pq.push(new Data(2020, 4, 19));
		pq.push(new Data(2022, 4, 19));
		while (!pq.empty())
		{
			std::cout << *pq.top();
			pq.pop();
		}
	}
}