C++映射的优先队列及示例
优先队列
优先队列 是一种容器适配器,专门设计为队列中的第一个元素是队列中所有元素中最大的元素,并且元素以非递增的顺序排列(因此我们可以看到队列的每个元素都有优先级 {固定顺序})。通常,优先队列有两种类型:最大堆和最小堆,但我们总是可以将比较器传递给优先队列。
与优先队列一起使用的函数:
- empty(): 此函数返回队列是否为空。
- size(): 此函数返回队列的大小。
- top(): 返回队列中元素的最上面的引用。
- push(x): 此函数将元素”x”添加到队列的末尾。
映射
映射 是将元素以映射方式存储的关联容器。每个元素都具有键值和映射值。没有两个映射值可以具有相同的键值。其内部实现为自平衡BST。
与映射一起使用的函数:
- begin(): 返回映射中第一个元素的迭代器
- end(): 返回映射中最后一个元素之后的理论元素的迭代器
- size(): 返回映射中的元素数量
- empty(): 返回映射是否为空
本文重点介绍了如何在C ++中使用映射的优先队列。 映射的优先队列在设计复杂的数据结构时非常有用。
最大堆的映射优先队列:
- 非降序排列映射的最大堆优先队列:
priority_queue <map<data_type1,data_type2>> priorityQueue;
这里,
data_type1: 是键的数据类型。
data_type2: 是值的数据类型。
- 非升序排列映射的最大堆优先队列:
priority_queue <map<data_type1,data_type2,greater
这里,
data_type1: 是键的数据类型。
data_type2: 是值的数据类型。
映射的最小堆优先队列:
- 非降序排列映射的最小堆优先队列:
priority_queue <map<data_type1,data_type2>,vector<map<data_type1,data_type2>>,greater<map<data_type1,data_type2>>> priorityQueue;
这里,
data_type1: 是键的数据类型。
data_type2: 是值的数据类型。
- 非升序排列映射的最小堆优先队列:
priority_queue <map<data_type1,data_type2>,vector<map<data_type1,data_type2,greater
这里,
data_type1: 是键的数据类型。
data_type2: 是值的数据类型。
使用比较器自定义地图优先队列:
priority_queue<map<data_type1, data_type2>, vector<map<data_type1, data_type2>>, myComparator> priorityQueue;
在这里,
data_type1: 为键的数据类型。
data_type2: 为值的数据类型。
myComparator: 为比较器类或结构体。
下面是比较器的C ++代码片段:
//比较器结构
struct myComparator
{
int operator()(const map<data_type1,
data_type2>& map1,
const map<data_type1,
data_type2>& map2)
{
// 此处省略比较器的主体内容
}
};
//比较器类
struct myComparator
{
public:
int operator()(const map<data_type1,
data_type2>& map1,
const map<data_type1,
data_type2>& map2)
{
// 此处省略比较器的主体内容
}
};```
**Map的最大堆优先队列**
默认情况下,优先队列是最大堆。因此,在最大堆优先队列中,将同时逐个比较两个地图元素的键和值。如果两张地图的第一个元素的键相等,则比较第一个元素的值,如果两个地图的第一个元素的值也相等,则比较第二个元素的键,如果两张地图的第二个元素的键也相等,则比较第二个元素的值,以此类推。在比较中具有较大键或值的地图将成为优先队列的顶部元素。
下面是C ++程序,演示地图元素按键的非降序排序方式工作的示例:
**示例1:**
```cpp
// C++ program to implement
// the above approach
# include <bits/stdc++.h>
using namespace std;
// Function to print priority queue contents
void print(priority_queue<string> priorityQueue)
{
while (!priorityQueue.empty())
{
cout << priorityQueue.top() << " ";
priorityQueue.pop();
}
}
// Driver code
int main()
{
// Priority queue of strings
priority_queue<string> priorityQueue;
// Inserting strings into the priority queue
priorityQueue.push("Geeks");
priorityQueue.push("for");
priorityQueue.push("Geeks");
// Calling print function
print(priorityQueue);
return 0;
}
输出:
Geeks for Geeks
// C++程序以实现
// 上述方法
# include<bits/stdc++.h>
using namespace std;
//函数来打印优先级
//队列内容
void print(priority_queue<map<int, string> >
priorityQueue)
{
while (!priorityQueue.empty())
{
// 优先级队列的每个元素本身都是一个映射
map<int, string> map1 =
priorityQueue.top();
cout << "[ ";
//打印映射元素
for (auto pair1 : map1)
{
//映射中的每个元素都是一对键值对
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
//弹出最顶部的映射
priorityQueue.pop();
}
}
//驱动程序
int main()
{
//优先级队列的映射
//优先级队列的每个元素都是一个映射
priority_queue<map<int, string> >
priorityQueue;
//声明一个键为整数类型、值为
//也是整数类型的映射
map<int, string> map1;
map1[1] = "geeks";
map1[2] = "for";
map1[3] = "geeks";
priorityQueue.push(map1);
//声明另一个键为整数类型、值为
//也是整数类型的映射
map<int, string> map2;
map2[1] = "geeks";
map2[2] = "for";
map2[3] = "learning";
priorityQueue.push(map2);
//声明另一个键为整数类型、值为
//也是整数类型的映射
map<int, string> map3;
map3[1] = "geeks";
map3[2] = "for";
map3[4] = "geeks";
priorityQueue.push(map3);
//调用打印函数
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:geeks key:2 , value:for key:4 , value:geeks ]
[ key:1 , value:geeks key:2 , value:for key:3 , value:learning ]
[ key:1 , value:geeks key:2 , value:for key:3 , value:geeks ]
映射的最大堆优先队列-Priority Queue of Maps
以下是C++程序,演示将映射元素按键进行非升序排序的映射的最大堆优先队列的工作原理:
示例1:
// C++ program to implement
// the above approach
# include <bits/stdc++.h>
using namespace std;
// Function to print priority queue contents
void print(priority_queue<int, vector<int>,
greater<int> >
priorityQueue)
{
while (!priorityQueue.empty())
{
cout << priorityQueue.top() << " ";
priorityQueue.pop();
}
}
// Driver code
int main()
{
// Priority queue of integers
priority_queue<int, vector<int>, greater<int> >
priorityQueue;
priorityQueue.push(3);
priorityQueue.push(2);
priorityQueue.push(15);
priorityQueue.push(5);
priorityQueue.push(4);
priorityQueue.push(45);
// Calling print function
print(priorityQueue);
return 0;
}
输出:
2 3 4 5 15 45
// C++程序来实现
//以上方法
# include <bits/stdc++.h>
using namespace std;
// 打印优先队列的内容
void print(priority_queue<map<int, string,
greater<int> > >
priorityQueue)
{
while (!priorityQueue.empty())
{
// 每个优先队列的元素都是一个map
map<int, string, greater<int> > map1 =
priorityQueue.top();
cout << "[ ";
// 打印map元素
for (auto pair1 : map1)
{
// map中的每个元素都是键值对
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
// 弹出最顶上的map
priorityQueue.pop();
}
}
// 主函数
int main()
{
// map的优先队列
// 每个优先队列的元素都是一个map
priority_queue<map<int, string,
greater<int> > >
priorityQueue;
// 声明一个map,其键是整型,值也是整型
map<int, string, greater<int> > map1;
map1[1] = "geeks";
map1[2] = "for";
map1[3] = "geeks";
priorityQueue.push(map1);
// 声明另一个map,其键是整型,值也是整型
map<int, string, greater<int> > map2;
map2[1] = "geeks";
map2[2] = "for";
map2[3] = "learning";
priorityQueue.push(map2);
// 声明另一个map,其键是整型,值也是整型
map<int, string, greater<int> > map3;
map3[1] = "geeks";
map3[2] = "for";
map3[4] = "geeks";
priorityQueue.push(map3);
// 声明另一个map,其键是整型,值也是整型
map<int, string, greater<int> > map4;
map4[1] = "Code";
map4[2] = "For";
map4[4] = "Fun";
priorityQueue.push(map4);
// 调用打印函数
print(priorityQueue);
return 0;
}
输出:
[ key:4 , value:geeks key:2 , value:for key:1 , value:geeks ]
[ key:4 , value:Fun key:2 , value:For key:1 , value:Code ]
[ key:3 , value:learning key:2 , value:for key:1 , value:geeks ]
[ key:3 , value:geeks key:2 , value:for key:1 , value:geeks ]
映射的最小堆优先队列
在最小堆优先队列中,两个映射的键和值同时进行比较。如果两个映射的第一个元素的键相等,则比较第一个元素的值;如果两个映射的第一个元素的值也相等,则比较第二个元素的键。如果两个映射的第二个元素的键也相等,则比较第二个元素的值,以此类推。在比较中,映射具有较小的键或值成为优先队列的顶部元素。
以下是C ++程序,演示按键非降序排列的映射的最小堆优先队列的工作方式:
示例1:
// C++程序实现
// 上述方法
# include <bits/stdc++.h>
using namespace std;
// 打印优先队列内容的函数
void print(priority_queue<map<int, int>,
vector<map<int, int> >,
greater<map<int, int> > >
priorityQueue)
{
while (!priorityQueue.empty())
{
// 优先队列的每个元素本身都是一个map
map<int, int> map1 = priorityQueue.top();
cout << "[ ";
// 打印map元素
for (auto pair1 : map1)
{
// 每个map中的元素都是一个键值对
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
// 弹出顶部的map
priorityQueue.pop();
}
}
// 主函数
int main()
{
// map的优先队列,优先队列的每个元素本身是一个map
priority_queue<map<int, int>,
vector<map<int, int> >,
greater<map<int, int> > >
priorityQueue;
// 声明一个map,键和值都是整数类型
map<int, int> map1;
map1[1] = 11;
map1[2] = 22;
map1[3] = 33;
priorityQueue.push(map1);
// 声明另一个map,键和值都是整数类型
map<int, int> map2;
map2[1] = 11;
map2[2] = 22;
map2[3] = 44;
priorityQueue.push(map2);
// 声明一个map,键和值都是整数类型
map<int, int> map3;
map3[1] = 11;
map3[2] = 22;
map3[4] = 33;
priorityQueue.push(map3);
// 调用打印函数
print(priorityQueue);
return 0;
}
输出结果:
[ key:1 , value:11 key:2 , value:22 key:3 , value:33 ]
[ key:1 , value:11 key:2 , value:22 key:3 , value:44 ]
[ key:1 , value:11 key:2 , value:22 key:4 , value:33 ]
示例2:
// C++程序实现
//上述方法
# include
using namespace std;
//打印优先级队列内容的函数
void print(priority_queue<map<int, string>,
vector<map<int, string> >,
greater<map<int, string> > >
priorityQueue)
{
while(!priorityQueue.empty())
{
//优先队列的每个元素本身就是一个map
map<int, string> map1 =
priorityQueue.top();
cout << "[ ";
//打印map中的元素
for(auto pair1: map1)
{
//map中的每个元素都是一个键-值对
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
//弹出最上面的map
priorityQueue.pop();
}
}
//主函数
int main()
{
//map的优先队列
//优先队列中的每个元素均为一个map
priority_queue<map<int, string>,
vector<map<int, string> >,
greater<map<int, string> > >
priorityQueue;
//声明一个map,其键是整数类型,值也是整数类型
map<int, string> map1;
map1[1] = "geeks";
map1[2] = "for";
map1[3] = "geeks";
priorityQueue.push(map1);
//声明另一个map,其键是整数类型,值也是整数类型
map<int, string> map2;
map2[1] = "geeks";
map2[2] = "for";
map2[3] = "learning";
priorityQueue.push(map2);
//声明另一个map,其键是整数类型,值也是整数类型
map<int, string> map3;
map3[1] = "geeks";
map3[2] = "for";
map3[4] = "geeks";
priorityQueue.push(map3);
//声明另一个map,其键是整数类型,值也是整数类型
map<int, string> map4;
map4[1] = "Code";
map4[2] = "For";
map4[4] = "Fun";
priorityQueue.push(map4);
//调用print函数
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:Code key:2 , value:For key:4 , value:Fun ]
[ key:1 , value:geeks key:2 , value:for key:3 , value:geeks ]
[ key:1 , value:geeks key:2 , value:for key:3 , value:learning ]
[ key:1 , value:geeks key:2 , value:for key:4 , value:geeks ]
Map的小根堆优先队列
下面是C++程序,演示了按键的非升序排列的Map的小根堆优先队列的工作方式:
示例1:
// C++ program to implement
// the above approach
# include <bits/stdc++.h>
using namespace std;
// Function to print priority
// queue contents
void print(priority_queue<pair<int, int>,
vector<pair<int, int> >,
greater<pair<int, int> > > priorityQueue)
{
while (!priorityQueue.empty())
{
// Each element of the priority
// queue is a pair itself
pair<int, int> pair1 =
priorityQueue.top();
cout << "[ ";
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
cout << ']';
cout << '\n';
// Pop out the topmost pair
priorityQueue.pop();
}
}
// Driver code
int main()
{
// Priority queue of pairs
// Each element of the priority
// queue is a pair
priority_queue<pair<int, int>,
vector<pair<int, int> >,
greater<pair<int, int> > > priorityQueue;
priorityQueue.push({ 1, 13 });
priorityQueue.push({ 2, 12 });
priorityQueue.push({ 3, 11 });
priorityQueue.push({ 4, 15 });
priorityQueue.push({ 5, 14 });
// Calling print function
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:13 ]
[ key:2 , value:12 ]
[ key:3 , value:11 ]
[ key:5 , value:14 ]
[ key:4 , value:15 ]
// C++程序实现
//以上方法
# include <bits/stdc++.h>
using namespace std;
//打印优先级队列内容的功能
void print(priority_queue<
map<int, string,
greater<int> >,
vector<map<int, string,
greater<int> > >,
greater<map<int, string,
greater<int> > > >
priorityQueue)
{
while (!priorityQueue.empty())
{
//优先队列的每个元素本身就是一个map
map<int, string, greater<int> > map1 =
priorityQueue.top();
cout << "[ ";
//打印map元素
for (auto pair1 : map1)
{
//在map中的每个元素本身就是一个键值对
cout << "键:" << pair1.first << " , " <<
"值:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
//弹出最顶部的map
priorityQueue.pop();
}
}
//驱动程序
int main()
{
//优先级队列的map
//优先队列的每个元素本身就是一个map
priority_queue<map<int, string,
greater<int> >,
vector<map<int, string,
greater<int> > >,
greater<map<int, string,
greater<int> > > >
priorityQueue;
//声明一个map,其键为整数类型,值也为整数类型
map<int, string, greater<int> > map1;
map1[1] = "geeks";
map1[2] = "for";
map1[3] = "geeks";
priorityQueue.push(map1);
//声明另一个map,其键为整数类型,值也为整数类型
map<int, string, greater<int> > map2;
map2[1] = "geeks";
map2[2] = "for";
map2[3] = "learning";
priorityQueue.push(map2);
//声明另一个map,其键为整数类型,值也为整数类型
map<int, string, greater<int> > map3;
map3[1] = "geeks";
map3[2] = "for";
map3[4] = "geeks";
priorityQueue.push(map3);
//声明另一个map,其键为整数类型,值也为整数类型
map<int, string, greater<int> > map4;
map4[1] = "Code";
map4[2] = "For";
map4[4] = "Fun";
priorityQueue.push(map4);
//调用打印函数
print(priorityQueue);
return 0;
}
输出:
[ 键:3 , 值:geeks 键:2 , 值:for 键:1 , 值:geeks ]
[ 键:3 , 值:learning 键:2 , 值:for 键:1 , 值:geeks ]
[ 键:4 , 值:Fun 键:2 , 值:For 键:1 , 值:Code ]
[ 键:4 , 值:geeks 键:2 , 值:for 键:1 , 值:geeks ]
自定义映射的优先级队列
下面是演示自定义映射的优先级队列工作的C++程序的示例:
示例1:
// C++程序,实现上述方法
# include
using namespace std;
struct myComparator
{
int operator()(const map<int, int>& map1, const map<int, int>& map2)
{
//Max-heap优先队列
for(auto it1 = map1.begin(), it2= map2.begin(); it1!= map1.end(), it2!= map2.end(); it1++, it2++)
{
auto key1 = it1->first;
auto value1 = it1->second;
auto key2 = it2->first;
auto value2 = it2->second;
if (key1 == key2)
{
if (value1 == value2)
continue;
return value1 < value2;
}
return key1 < key2;
}
return map1.size() <= map2.size();
}
};
//函数,打印优先队列内容
void print(priority_queue<map<int, int>, vector<map<int, int>>, myComparator> priorityQueue)
{
while(!priorityQueue.empty())
{
//每个优先队列元素本身就是一个map
map<int, int> map1 = priorityQueue.top();
cout << "[ ";
//打印map元素
for(auto pair1: map1)
{
//map中的每个元素都是键值对
cout << "key:" << pair1.first << " , " << "value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
//弹出最顶部的map
priorityQueue.pop();
}
}
int main()
{
//map的优先队列,每个优先队列元素本身就是一个map
priority_queue<map<int, int>, vector<map<int, int>>, myComparator> priorityQueue;
//声明一个map,它的键值为整型,值也为整型
map<int, int> map1;
map1[1] = 11;
map1[2] = 22;
map1[3] = 33;
priorityQueue.push(map1);
//再声明一个map,它的键值为整型,值也为整型
map<int, int> map2;
map2[1] = 11;
map2[2] = 22;
map2[3] = 44;
priorityQueue.push(map2);
//声明另一个map,它的键值为整型,值也为整型
map<int, int> map3;
map3[1] = 11;
map3[2] = 22;
map3[4] = 33;
priorityQueue.push(map3);
//声明另一个map,它的键值为整型,值也为整型
map<int, int> map4;
map4[1] = 11;
map4[2] = 22;
map4[4] = 33;
priorityQueue.push(map4);
//调用print函数
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:11 key:2 , value:22 key:4 , value:33 ]
[ key:1 , value:11 key:2 , value:22 key:4 , value:33 ]
[ key:1 , value:11 key:2 , value:22 key:3 , value:44 ]
[ key:1 , value:11 key:2 , value:22 key:3 , value:33 ]
例子2:
// C++程序,实现上述方法
# include
using namespace std;
struct myComparator
{
int operator()(const map& map1,
const map& map2)
{
// 最小堆优先队列
for (auto it_1 = map1.begin(),
it_2 = map2.begin();
it_1 != map1.end(),
it_2 != map2.end();
it_1++, it_2++)
{
auto key_1 = it_1->first;
auto value_1 = it_1->second;
auto key_2 = it_2->first;
auto value_2 = it_2->second;
if (key_1 == key_2)
{
if (value_1 == value_2)
continue;
return value_1 > value_2;
}
return key_1 > key_2;
}
return map1.size() >= map2.size();
}
};
// 输出优先队列内容的函数
void print(priority_queue,
vector >,
myComparator> priorityQueue)
{
while (!priorityQueue.empty())
{
// 优先队列中的每个元素本身就是一个map
map map1 = priorityQueue.top();
cout << "[ ";
// 输出map中的元素
for (auto pair1 : map1)
{
// map中的每个元素都是一个键值对
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
// 弹出最高优先级的map
priorityQueue.pop();
}
}
// 主函数
int main()
{
// map类型的优先队列,优先队列中每个元素都是一个map
priority_queue,
vector >,
myComparator> priorityQueue;
// 声明一个map,map的键和值都是int类型
map map1;
map1[1] = 11;
map1[2] = 22;
map1[3] = 33;
priorityQueue.push(map1);
// 声明另一个map,键和值都是int类型
map map2;
map2[1] = 11;
map2[2] = 22;
map2[3] = 44;
priorityQueue.push(map2);
// 声明另一个map,键和值都是int类型
map map3;
map3[1] = 11;
map3[2] = 22;
map3[4] = 33;
priorityQueue.push(map3);
// 声明另一个map,键和值都是int类型
map map4;
map4[1] = 11;
map4[2] = 22;
map4[4] = 33;
priorityQueue.push(map4);
// 调用print函数
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:11 key:2 , value:22 key:3 , value:33 ]
[ key:1 , value:11 key:2 , value:22 key:3 , value:44 ]
[ key:1 , value:11 key:2 , value:22 key:4 , value:33 ]
[ key:1 , value:11 key:2 , value:22 key:4 , value:33 ]
示例3:
// C++程序实现
//上述方法
# include <bits/stdc++.h>
using namespace std;
struct myComparator
{
int operator()(const map<int, string>& map1,
const map<int, string>& map2)
{
// 最大堆优先队列
for (auto it1 = map1.begin(),
it2 = map2.begin();
it1 != map1.end(),
it2 != map2.end();
it1++, it2++)
{
auto key1 = it1->first;
auto value1 = it1->second;
auto key2 = it2->first;
auto value2 = it2->second;
if (key1 == key2)
{
if (value1 == value2)
continue;
return value1 < value2;
}
return key1 < key2;
}
return map1.size() <= map2.size();
}
};
// 打印优先队列内容的函数
void print(priority_queue<map<int, string>,
vector<map<int, string> >,
myComparator> priorityQueue)
{
while (!priorityQueue.empty())
{
// 优先队列的每个元素本身就是一个映射
map<int, string> map1 =
priorityQueue.top();
cout << "[ ";
// 打印映射元素
for (auto pair1 : map1)
{
// 映射中的每个元素都是一个键值对
cout << "key:" << pair1.first << " , " <<
"value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
// 弹出最顶端的映射
priorityQueue.pop();
}
}
// 主函数
int main()
{
// 映射的优先队列
// 优先队列的每个元素本身就是一个映射
priority_queue<map<int, string>,
vector<map<int, string> >,
myComparator> priorityQueue;
// 声明键和值都是整数类型的映射
map<int, string> map1;
map1[1] = "apple";
map1[2] = "boy";
map1[3] = "cat";
priorityQueue.push(map1);
// 声明键和值都是整数类型的另一个映射
map<int, string> map2;
map2[1] = "apple";
map2[2] = "bat";
map2[4] = "eat";
priorityQueue.push(map2);
// 声明键和值都是整数类型的另一个映射
map<int, string> map3;
map3[1] = "apple";
map3[2] = "ao";
map3[10] = "fo";
priorityQueue.push(map3);
// 声明键和值都是整数类型的另一个映射
map<int, string> map4;
map4[1] = "code";
map4[2] = "for";
map4[10] = "fun";
priorityQueue.push(map4);
// 调用print函数
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:code key:2 , value:for key:10 , value:fun ]
[ key:1 , value:apple key:2 , value:boy key:3 , value:cat ]
[ key:1 , value:apple key:2 , value:bat key:4 , value:eat ]
[ key:1 , value:apple key:2 , value:ao key:10 , value:fo ]
// C++程序来实现上述方法
# include <bits/stdc++.h>
using namespace std;
struct myComparator
{
int operator()(const map<int, string>& map1,
const map<int, string>& map2)
{
//最小根堆优先队列
for (auto it1 = map1.begin(),
it2 = map2.begin();
it1 != map1.end(),
it2 != map2.end();
it1++, it2++)
{
auto key1 = it1->first;
auto value1 = it1->second;
auto key2 = it2->first;
auto value2 = it2->second;
if (key1 == key2)
{
if (value1 == value2)
continue;
return value1 > value2;
}
return key1 > key2;
}
return map1.size() >= map2.size();
}
};
//打印优先队列的内容
void print(priority_queue<map<int, string>,
vector<map<int, string> >,
myComparator> priorityQueue)
{
while (!priorityQueue.empty())
{
//每个优先队列的元素本身就是一个map
map<int, string> map1 = priorityQueue.top();
cout << "[ ";
//打印map的元素
for (auto pair1 : map1)
{
//每个map中的元素是一个键值对
cout << "key:" << pair1.first << " , "
<< "value:" << pair1.second << " ";
}
cout << ']';
cout << '\n';
//弹出最上面的map
priorityQueue.pop();
}
}
//主函数
int main()
{
//map变成优先队列
//优先队列中的每个元素也是一个map
priority_queue<map<int, string>,
vector<map<int, string> >,
myComparator> priorityQueue;
//定义一个key是整型,value是字符串的map
map<int, string> map1;
map1[1] = "apple";
map1[2] = "boy";
map1[3] = "cat";
priorityQueue.push(map1);
//定义另一个key是整型,value也是整型的map
map<int, string> map2;
map2[1] = "apple";
map2[2] = "bat";
map2[4] = "eat";
priorityQueue.push(map2);
//定义另一个key是整型,value也是整型的map
map<int, string> map3;
map3[1] = "apple";
map3[2] = "ao";
map3[10] = "fo";
priorityQueue.push(map3);
//定义另一个key是整型,value也是整型的map
map<int, string> map4;
map4[1] = "code";
map4[2] = "for";
map4[10] = "fun";
priorityQueue.push(map4);
//调用print函数
print(priorityQueue);
return 0;
}
输出:
[ key:1 , value:apple key:2 , value:ao key:10 , value:fo ]
[ key:1 , value:apple key:2 , value:bat key:4 , value:eat ]
[ key:1 , value:apple key:2 , value:boy key:3 , value:cat ]
[ key:1 , value:code key:2 , value:for key:10 , value:fun ]