当前位置：极客教程 > C++语言 > C++ 教程 > C++映射的优先队列及示例

C++映射的优先队列及示例

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>> priorityQueue;

这里，

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>>，greater<map<data_type1，data_type2，greater>>> priorityQueue;

这里，

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 ]

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

C++ 教程