当前位置：极客教程 > C++语言 > C++ 教程 > C++中的前向列表和无序映射列表

C++中的前向列表和无序映射列表

C++中的前向列表和无序映射列表

前向列表

STL中的前向列表实现了单向链表。自C++11引入以来，前向列表在插入、删除和移动操作（如排序）方面比其他容器更有用，并且允许时间常数的元素插入和删除。它与列表的区别在于前向列表仅跟踪下一个元素的位置，而列表跟踪下一个和前一个元素的位置，从而增加了存储每个元素所需的存储空间。前向列表的缺点是不能向后迭代，也无法直接访问其各个元素。与双向链表相比，只有当仅需要向前遍历时（与单向链表相同）才优先考虑前向列表，因为这样可以节省空间。一些示例情况是哈希中的链式存储、图的邻接列表表示等。

使用前向列表的函数：

  • push_front(x)： 将一个新元素“x”添加到前向列表的开头。
  • pop_front()： 这个函数用于删除前向列表的第一个元素。

列表

列表 是允许非连续内存分配的序列容器。与向量相比，列表遍历速度慢，但一旦找到位置，插入和删除操作就非常快。通常，当我们说List时，我们是指双向链表。为了实现单向链表，我们使用前向列表。

使用列表的函数：

  • front()： 返回列表中第一个元素的值。
  • back()： 返回列表中最后一个元素的值。
  • push_front(x)： 在列表的开头添加一个新元素“x”。
  • push_back(x)： 在列表的末尾添加一个新元素“x”。

无序映射

一个 无序映射 是一个关联容器，它存储由键值-映射值组成的元素，其中键值用于唯一标识元素，映射值是与键关联的内容。键和值都可以是任何预定义或用户定义的类型。在内部上，无序映射使用哈希表实现。

使用无序映射的函数：

  • at()： C++ unordered_map中的这个函数返回带有元素作为键的值的引用k。
  • begin()： 返回指向无序映射容器中第一个元素的迭代器。
  • end()： 返回指向无序映射容器中最后一个元素后的位置的迭代器。
  • size()： 返回无序映射中存在的元素数。

这篇文章重点介绍了如何在C ++中使用前向列表和无序映射列表。向量和前向列表的列表在设计复杂的数据结构时非常有用。

前向列表的无序映射

以下是使用无序映射前向列表的实现：

示例1:

// C++程序实现上述概念
#include <bits/stdc++.h>
using namespace std;
  
// 打印forward list各个元素
void print(forward_list<unordered_map<int, int> >& 
           forwardList1)
{
  cout << "Forward List : \n";
    
  for (auto currentUnorderedMap : forwardList1) 
  {
    // forward_list的每个元素是一个无序map
  
    cout << "Unordered Map : ";
    cout << "[   ";
  
    // 打印无序map的元素
    for (auto it = currentUnorderedMap.begin();
              it != currentUnorderedMap.end(); it++) 
    {
      cout << "First : " << it->first << " , " << 
              "Second : " << it->second << "   ";
    }
    cout << "]\n";
  }
}
  
// 主函数
int main()
{
  // 声明一个forward list，元素为无序map
  forward_list<unordered_map<int, int> > 
  forwardList1;
  
  // 声明一个无序map
  unordered_map<int, int> unorderedMap1;
  
  // 哈希值
  unorderedMap1[2] = 4;
  unorderedMap1[4] = 3;
  unorderedMap1[6] = 9;
  
  // 将无序map插入forward list
  forwardList1.push_front(unorderedMap1);
  
  // 声明另一个无序map
  unordered_map<int, int> unorderedMap2;
  
  // 哈希值
  unorderedMap2[31] = 8;
  unorderedMap2[11] = 3;
  unorderedMap2[23] = 7;
  
  // 将无序map插入forward list
  forwardList1.push_front(unorderedMap2);
  
  // 声明另一个无序map
  unordered_map<int, int> unorderedMap3;
  
  // 哈希值
  unorderedMap3[7] = 3;
  unorderedMap3[18] = 1;
  unorderedMap3[9] = 6;
    
  // 将无序map插入forward list
  forwardList1.push_front(unorderedMap3);
  
  // 声明另一个无序map
  unordered_map<int, int> unorderedMap4;
  
  // 哈希值
  unorderedMap4[32] = 9;
  unorderedMap4[15] = 3;
  unorderedMap4[97] = 5;
  
  // 将无序map插入forward list
  forwardList1.push_front(unorderedMap4);
  
  print(forwardList1);
  return 0;
}

输出:

Forward List :   
Unordered Map : [ First : 97 , Second : 5 First : 32 , Second : 9 First : 15 , Second : 3 ]   
Unordered Map : [ First : 9 , Second : 6 First : 7 , Second : 3 First : 18 , Second : 1 ]   
Unordered Map : [ First : 23 , Second : 7 First : 31 , Second : 8 First : 11 , Second : 3 ]   
Unordered Map : [ First : 6 , Second : 9 First : 2 , Second : 4 First : 4 , Second : 3 ]

示例 3:

#include <iostream>
#include <list>
using namespace std;

int main ()
{
  // Creating a list
  list demoList;

  // Add elements to the List
  demoList.push_front(10);
  demoList.push_front(20);
  demoList.push_back(30);
  demoList.push_back(40);

  // Deleting elements from list
  demoList.pop_front();
  demoList.pop_back();

  // Print the List
  cout << "List : ";
  for (auto it : demoList)
    cout << it << " ";

  return 0;
}

输出:

List : 20 10 30 

// C++程序实现
//上述概念
#include＜bits/stdc++.h＞
使用命名空间std;
  
//打印向前的函数 
//列表元素
void print(forward_list＜unordered_map＜int，string＞＆gt;& 
           forwardList1)
{
  cout＜＜"前向列表：\n";
    
  for (auto currentUnorderedMap：forwardList1）
  {
    //前向列表的每个元素是unordered map
  
    cout＜＜"无序映射：";
    cout＜＜"[   ";
  
    //打印无序映射元素
    for (auto it = currentUnorderedMap.begin();
              它！= currentUnorderedMap.end();它++） 
    {
      cout＜＜"First："＜＜it->first＜＜"，"＜＜ 
              “Second：”＜＜it->second＜＜“　”;
    }
    cout＜＜"]\n";
  }
}
  
//驱动程序
int main()
{
  //声明前向列表
  //无序映射
  forward_list＜unordered_map＜int，string＞＆gt; 
  forwardList1;
  
  //声明无序映射
  unordered_map＜int，string＞ unorderedMap1;
  
  //哈希值
  unorderedMap1 [2] =“Geeks”;
  unorderedMap1 [4] =“for”;
  unorderedMap1 [6] =“Geeks”;
  
  //将unordered map插入前向列表
  forwardList1.push_front(unorderedMap1);
  
  //声明另一个无序映射
  unordered_map＜int，string＞ unorderedMap2;
  
  //哈希值
  unorderedMap2 [3] =“Python”;
  unorderedMap2 [11] =“Java”;
  unorderedMap2 [23] =“C ++”;
  
  //将unordered map插入前向列表
  forwardList1.push_front(unorderedMap2);
  
  //声明另一个无序映射
  unordered_map＜int，string＞ unorderedMap3;
  
  //哈希值
  unorderedMap3 [7] =“C”;
  unorderedMap3 [18] =“PHP”;
  unorderedMap3 [9] =“Swift”;
    
  //将unordered map插入前向列表
  forwardList1.push_front(unorderedMap3);
  
  //声明另一个无序映射
  unordered_map＜int，string＞ unorderedMap4;
  
  //哈希值
  unorderedMap4 [121] =“Hello”;
  unorderedMap4 [97] =“Coding”;
  unorderedMap4 [197] =“World”;
  
  //将unordered map插入前向列表
  forwardList1.push_front(unorderedMap4);
  
  print（forwardList1）;
  返回0;
}

输出：

Forward List :   
Unordered Map : [ First : 197 , Second : World First : 121 , Second : Hello First : 97 , Second : Coding ]   
Unordered Map : [ First : 9 , Second : Swift First : 7 , Second : C First : 18 , Second : PHP ]   
Unordered Map : [ First : 23 , Second : C++ First : 3 , Second : Python First : 11 , Second : Java ]   
Unordered Map : [ First : 6 , Second : Geeks First : 2 , Second : Geeks First : 4 , Second : for ]

无序映射列表 下面是使用无序映射列表的实现：

例1：

// C++程序以实现上述概念
#include <bits/stdc++.h>
using namespace std;
  
//函数打印列表元素
void print(list<unordered_map<int, int> >& 
           List)
{
  cout << "List : \n";
  for (auto currentUnorderedMap : List) 
  {
    //列表的每个元素都是无序映射
    cout << "Unordered Map : ";
    cout << "[   ";
  
    //打印无序映射元素
    for (auto it = currentUnorderedMap.begin();
              it != currentUnorderedMap.end(); it++) 
    {
      cout << "First : " << it->first << " , " << 
              "Second : " << it->second << "   ";
    }
    cout << "]\n";
  }
}
  
// 主程序
int main()
{
  // 声明无序映射列表
  list<unordered_map<int, int> > List;
  
  // 声明1个无序映射
  unordered_map<int, int> unorderedMap1;
  
  //哈希值
  unorderedMap1[2] = 4;
  unorderedMap1[4] = 3;
  unorderedMap1[6] = 9;
  
  // 将无序映射推到列表中
  List.push_front(unorderedMap1);
  
  // 声明另一个无序映射
  unordered_map<int, int> unorderedMap2;
  
  //哈希值
  unorderedMap2[31] = 8;
  unorderedMap2[11] = 3;
  unorderedMap2[23] = 7;
  
  // 将无序映射推到列表中
  List.push_front(unorderedMap2);
  
  // 声明另一个无序映射
  unordered_map<int, int> unorderedMap3;
  
  //哈希值
  unorderedMap3[7] = 3;
  unorderedMap3[18] = 1;
  unorderedMap3[9] = 6;
   
  //将无序映射推到列表中
  List.push_front(unorderedMap3);
  
  // 声明另一个无序映射
  unordered_map<int, int> unorderedMap4;
  
  //哈希值
  unorderedMap4[32] = 9;
  unorderedMap4[15] = 3;
  unorderedMap4[97] = 5;
  
  // 将无序映射推到列表中
  List.push_front(unorderedMap4);
  
  print(List);
  return 0;
}

输出：

List :   
Unordered Map : [ First : 97 , Second : 5 First : 32 , Second : 9 First : 15 , Second : 3 ]   
Unordered Map : [ First : 9 , Second : 6 First : 7 , Second : 3 First : 18 , Second : 1 ]   
Unordered Map : [ First : 23 , Second : 7 First : 31 , Second : 8 First : 11 , Second : 3 ]   
Unordered Map : [ First : 6 , Second : 9 First : 2 , Second : 4 First : 4 , Second : 3 ]

示例 2：

// C++程序实现
// 上述方法
#include <bits/stdc++.h>
using namespace std;
  
// 打印列表元素的函数
void print(list<unordered_map<int, string> >& List)
{
  cout << "列表: \n";
  for (auto currentUnorderedMap : List) 
  {
    // 每个列表元素
    // 为一个无序映射
    cout << "无序映射 : ";
    cout << "[   ";
  
    // 打印无序映射元素
    for (auto it = currentUnorderedMap.begin();
              it != currentUnorderedMap.end(); it++) 
    {
      cout << "第一项 : " << it->first << " , " << 
              "第二项 : " << it->second << "   ";
    }
    cout << "]\n";
  }
}
  
// 主函数
int main()
{
  // 声明无序映射列表
  list<unordered_map<int, string> > List;
  
  // 声明无序映射
  unordered_map<int, string> unorderedMap1;
  
  // 哈希值
  unorderedMap1[2] = "Geeks";
  unorderedMap1[4] = "for";
  unorderedMap1[6] = "Geeks";
  
  // 将无序映射推入顺序列表中
  List.push_front(unorderedMap1);
  
  // 声明另一个无序映射
  unordered_map<int, string> unorderedMap2;
  
  // 哈希值
  unorderedMap2[3] = "Python";
  unorderedMap2[11] = "Java";
  unorderedMap2[23] = "C++";
  
  // 将无序映射推入顺序列表中
  List.push_front(unorderedMap2);
  
  // 声明另一个无序映射
  unordered_map<int, string> unorderedMap3;
  
  // 哈希值
  unorderedMap3[7] = "C";
  unorderedMap3[18] = "PHP";
  unorderedMap3[9] = "Swift";
    
  // 将无序映射推入顺序列表中
  List.push_front(unorderedMap3);
  
  // 声明另一个无序映射
  unordered_map<int, string> unorderedMap4;
  
  // 哈希值
  unorderedMap4[121] = "Hello";
  unorderedMap4[97] = "Coding";
  unorderedMap4[197] = "World";
  
  // 将无序映射推入顺序列表中
  List.push_front(unorderedMap4);
  
  print(List);
  return 0;
}

输出结果:

列表 :   
无序映射 : [ 第一项 : 197 , 第二项 : World 第一项 : 121 , 第二项 : Hello 第一项 : 97 , 第二项 : Coding ]   
无序映射 : [ 第一项 : 9 , 第二项 : Swift 第一项 : 7 , 第二项 : C 第一项 : 18 , 第二项 : PHP ]   
无序映射 : [ 第一项 : 23 , 第二项 : C++ 第一项 : 3 , 第二项 : Python 第一项 : 11 , 第二项 : Java ]   
无序映射 : [ 第一项 : 6 , 第二项 : Geeks 第一项 : 2 , 第二项 : Geeks 第一项 : 4 , 第二项 : for ]

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++ 教程