Question

In C++ if needed,

(Weight: 2096) Programming: Write a Compare function class that inserts Person objects in a priority queue based on the number of dependents a person has. The Person object with the largest number of dependents should be removed first. 3. Hint: In order to use the priority queue class, we need to pass in a structure that allows comparing the objects. If the max queue keeps track of primitive values (e.g. integers, strings), then the built-in C++ less than will compare the objects fine. However, since we want to compare persons, we need to tell the queue how to compare them. Now, the compare function class is simply a structure that overrides the parenthesis operator, and the operator takes two persons as parameters. Then, the persons are compared based on the number of dependents. Since this is a max queue, we should use the< operator. Here's an example of writing a compare structure (from Huffman Tree): (however, this one is for a min priority queue) struct CompareHuffman_Trees bool operator () (const Binary-Tree<Huff-Datax& left-tree, constBinary-Tree〈Huf Data> & right_tree) double wLeft = left-tree.get_data().weight; double WRight = right-t ree.get_data().weight; return wLeft>wRight;

Answer 1

This is the compare function that you need. For any clarifications, please comment and in case the answer helps please upvote.

struct CompareDependencies {
bool operator()(Person const& p1, Person const& p2)
{
// return true when p1 has lower dependencies than p2
return p1.dependencies < p2.dependencies;
}
};

I have also attached a sample code for testing the functionality:

#include <iostream> #include queue > using namespace std 1 4 class Person //Person class that stores the name and the count of dependencies public: int dependencies: string name; -]struct CompareDependencies { 9 bool operator ()(Person consti pl, person consti p2ǐl // return true when pl has lower dependencies than p2 return pl.dependencies < p2.dependencies: 1 2 15 L

16 int main() 18 priority queue<Person, vector<Person>, CompareDependencies>pg: Person pl,p2,p3,p4,p5,p6: //create 6 people p1 . dependencies= 10: p1 . name="Benasma"; p2.dependencies12 p2.name"Alba" p3.dependencies14: p3.nameTorres" p4.dependencies23 p4.name"Mes p5.dependencies30: p5.name"Ronalda p6.dependencies23 p6.nameSuarez" 20 21 23 24 25 2 6 27 28 29 30 31 32 //Insert them in the priority queue pq.push (pl); pq. push (p2); pq.push (p3); pq.push (p4); pq.push (p5); pq. push (p6); 34 35 36 37 38 39 40 Print their data while (pq.empty)) Person temp = pq. top(); // extract the top element of the priority queu cout << temp. name << " " << temp. dependenciesくくendl ; pq.pop )

Output:

Ronaldo 30 Suarez 23 Messi 23 Torres 14 Alba 12 Benzema 10 Process returned e (8x0) execution time : 0.212 s Press any key to continue.

Typed code:

#include <iostream>
#include <queue>
using namespace std;
class Person{ //Person class that stores the name and the count of dependencies
public:
int dependencies;
string name;
};
struct CompareDependencies {
bool operator()(Person const& p1, Person const& p2)
{
// return true when p1 has lower dependencies than p2
return p1.dependencies < p2.dependencies;
}
};
int main()
{
priority_queue<Person, vector<Person>, CompareDependencies> pq;
Person p1,p2,p3,p4,p5,p6; // create 6 people
p1.dependencies = 10; p1.name = "Benzema";
p2.dependencies = 12; p2.name = "Alba";
p3.dependencies = 14; p3.name = "Torres";
p4.dependencies = 23; p4.name = "Messi";
p5.dependencies = 30; p5.name = "Ronaldo";
p6.dependencies = 23; p6.name = "Suarez";

// Insert them in the priority queue
pq.push(p1);
pq.push(p2);
pq.push(p3);
pq.push(p4);
pq.push(p5);
pq.push(p6);

// Print their data
while(!pq.empty()){
Person temp = pq.top(); // extract the top element of the priority queue
cout << temp.name << " " << temp.dependencies<<endl;
pq.pop();
}
}