Очередь приоритетов для пользовательских типов

У меня есть следующая структура

struct node{
   float val;
   int count;

}

У меня есть несколько объектов этой структуры. Теперь я хочу вставить эти объекты в очередь приоритетов STL, чтобы очередь приоритетов заказывала элементы по счету. Любая идея о том, как это сделать? Предпочтительно предпочтительна минимальная куча. Я знаю, как это сделать для примитивных типов данных, а не структур

Ответ 1

Перегрузка < Оператор:

bool operator<(const node& a, const node& b) {
  return a.count > b.count;
}

Я перевернул сравнение, чтобы получить минимальную кучу, не передавая дополнительные аргументы в очередь приоритетов. Теперь вы используете его следующим образом:

priority_queue<node> pq;
...

Изменить: взгляните на это сообщение, которое кажется почти точным дубликатом: STL Priority Queue в пользовательском классе

Ответ 2

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
class Boxer{
    public:
        string name;
        int strength;
};
struct Comp{
    bool operator()(const Boxer& a, const Boxer& b){
        return a.strength<b.strength;
    }
};
int main(){
    Boxer boxer[3];
    boxer[0].name="uday", boxer[0].strength=23;
    boxer[1].name="manoj", boxer[1].strength=33;
    boxer[2].name="rajiv", boxer[2].strength=53;

    priority_queue< Boxer, vector<Boxer>, Comp> pq;
    pq.push(boxer[0]);
    pq.push(boxer[1]);
    pq.push(boxer[2]);
    Boxer b = pq.top();
    cout<<b.name;
    //result is Rajiv

    return 0;
}

Ответ 3

Используя функцию сравнения в качестве greater вы можете использовать приоритетную очередь в качестве минимальной кучи,

#include <bits/stdc++.h>

using namespace std;

int main()
{
    priority_queue<int,vector<int>,greater<int> >pq;
    pq.push(1);
    pq.push(2);
    pq.push(3);

    while(!pq.empty())
    {
        int r = pq.top();
        pq.pop();
        cout << r << " ";
    }
    return 0;
}

Вставляя значение, изменяя их знак (используя минус (-) для положительного числа и используя плюс (+) для отрицательного числа, мы можем использовать приоритетную очередь в обратном порядке).
```
int main()
{
    priority_queue<int>pq2;
    pq2.push(-1); //for +1
    pq2.push(-2); //for +2
    pq2.push(-3); //for +3
    pq2.push(4);  //for -4

    while(!pq2.empty())
    {
        int r = pq2.top();
        pq2.pop();
        cout << -r << " ";
    }

    return 0;
}
```

Для пользовательских типов данных или классов нам нужно указать приоритетной очереди способ определения порядка сортировки наших данных.

struct compare
{
    bool operator()(const int & a, const int & b)
    {
        return a>b;
    }
};

int main()
{

    priority_queue<int,vector<int>,compare> pq;
    pq.push(1);
    pq.push(2);
    pq.push(3);

    while(!pq.empty())
    {
        int r = pq.top();
        pq.pop();
        cout << r << " ";
    }

    return 0;
}

Для пользовательской структуры или класса вы можете использовать priority_queue в любом порядке. Предположим, мы хотим отсортировать людей в порядке убывания по их зарплате, а если связать, то по возрасту.

struct people
{
    int age,salary;
};
struct compare {
    bool operator()(const people & a, const people & b)
    {
        if(a.salary==b.salary)
        {
            return a.age>b.age;
        } else {
            return a.salary>b.salary;
        }
    }
};

int main()
{
    priority_queue<people,vector<people>,compare> pq;
    people person1,person2,person3;
    person1.salary=100;
    person1.age = 50;
    person2.salary=80;
    person2.age = 40;
    person3.salary = 100;
    person3.age=40;

    pq.push(person1);
    pq.push(person2);
    pq.push(person3);

    while(!pq.empty())
    {
        people r = pq.top();
        pq.pop();
        cout << r.salary << " " << r.age << endl;
    }

Тот же результат можно получить при перегрузке оператора:

struct people
{
    int age,salary;

    bool operator< (const people & p) const
    {
        if(salary==p.salary)
        {
            return age>p.age;
        } else {
            return salary>p.salary;
        }
    }
};

В основной функции:

    priority_queue<people> pq;
    people person1,person2,person3;
    person1.salary=100;
    person1.age = 50;
    person2.salary=80;
    person2.age = 40;
    person3.salary = 100;
    person3.age=40;

    pq.push(person1);
    pq.push(person2);
    pq.push(person3);

    while(!pq.empty())
    {
        people r = pq.top();
        pq.pop();
        cout << r.salary << " " << r.age << endl;
    }

Ответ 4

Вам нужно предоставить operator< для этой структуры. Что-то вроде:

bool operator<(node const& x, node const& y) {
    return x.count < y.count;
}

Теперь вы можете использовать приоритетную очередь из стандартной библиотеки.

Ответ 5

Мы можем определить определяемый пользователем класс компаратора:

Фрагмент кода:

#include<bits/stdc++.h>
using namespace std;

struct man
{
  string name;
  int priority; 
};

class comparator
{
 public:
   bool operator()(const man& a, const man& b)
   {
        return a.priority<b.priority;
   }
};

int main()
{
   man arr[5];
   priority_queue<man, vector<man>, comparator> pq;

   for(int i=0; i<3; i++)
   {
     cin>>arr[i].name>>arr[i].priority;
     pq.push(arr[i]);
   }

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

Ответ 6

Так как С++ 11, вы можете написать

auto comparer = [](const auto& a, const auto& b) {
    return a.priority < b.priority;
};
std::priority_queue<Item, std::vector<Item>, decltype(comparer)> queue(comparer);