在C++中使用示例的Forward List和Tuple List

什么是Forward List？

STL中的Forward List用于实现单链表。从C++11开始引入，Forward List在插入、删除和移动操作（如排序）方面比其他容器更有用，并允许在时间常数内插入和删除元素。

它与List的不同之处在于，Forward List仅跟踪下一个元素的位置，而List跟踪下一个和上一个元素，因此增加了存储每个元素所需的存储空间。

Forward List的缺点是不能向后迭代，并且其各个元素不能直接访问。

当仅需要正向遍历时（与单向链表比起来，同样的原因），推荐使用Forward List。一些示例用例包括哈希链、图的邻接列表表示等。

与Forward List相关的函数：

push_front() ：此函数用于在Forward List的第一个位置插入元素。该函数的值被复制到容器中第一个元素之前的空间中。Forward List的大小增加1。
pop_front() ： 此函数用于删除List的第一个元素。
empty() ：返回List是否为空（1）或非空（0）。

什么是List？

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

与List相关的函数：

front() ：返回List中第一个元素的值。
back() ：返回List中最后一个元素的值。
push_front(x) ：在List开头添加一个新元素“x”。
push_back(x) ：在List末尾添加一个新元素“x”。
empty() ：返回List是否为空（1）或非空（0）。

什么是Tuple？

在C++中，Tuple是一种具有将多个元素组合在一起的功能的对象。元素可以是相同类型或不同数据类型。元组元素的初始化顺序可以按照相同的顺序访问。

与Tuple相关的函数：

1. make_tuple(): 用于为元组分配值。传递的值应按照元组声明的值的顺序。
2. get(): 用于访问元组值并修改它们，它接受索引和元组名称作为参数，以访问特定的元组元素。

Forward List of Tuples

在C++中，Forward List of Tuples是一个Forward List，其中每个元素本身都是一个Tuple。尽管元组可以包含更多或更少的元素，但为简单起见，我们仅使用三个元素的元组。

语法：

**forward_list <tuple<dataType1, dataType2,dataType3> myForwardList; **

在这里，

dataType1、dataType2和dataType3 是相似或不同的数据类型。

示例1: 下面是C++程序，演示元组的前向列表的工作原理。

// C++程序，演示
// 元组的前向列表的工作原理
#include <bits/stdc++.h>
using namespace std;
  
// 打印前向列表元素的函数
void print(forward_list<tuple<int, int, 
           int>> &forwardListOftuples)
{
  for (auto currentTuple : forwardListOftuples) 
  {
    // 每个前向列表元素本身就是一个元组
    tuple<int, int, int> tuple = currentTuple;
  
    cout << "[ ";
  
    // 打印元组元素
    cout << get<0>(currentTuple) << ' ' << 
            get<1>(currentTuple) << ' ' << 
            get<2>(currentTuple);
    cout << ']';
    cout << '\n';
  }
}
  
// 主函数
int main()
{
  // 声明只有整数值的元组的前向列表
  forward_list<tuple<int, int, int> > 
    forwardListOftuples;
  
  // 声明一个元组
  tuple<int, int, int> tuple1;
  
  // 初始化元组
  tuple1 = make_tuple(11, 22, 33);
  
  // 将元组从后面推入前向列表
  forwardListOftuples.push_front(tuple1);
  
  // 声明另一个元组
  tuple<int, int, int> tuple2;
  
  // 初始化元组
  tuple2 = make_tuple(33, 44, 55);
  
  // 将元组从前面推入前向列表
  forwardListOftuples.push_front(tuple2);
  
  // 声明另一个元组
  tuple<int, int, int> tuple3;
  
  // 初始化元组
  tuple3 = make_tuple(55, 66, 77);
  
  // 将元组从前面推入前向列表
  forwardListOftuples.push_front(tuple3);
  
  // 声明另一个元组
  tuple<int, int, int> tuple4;
  
  // 初始化元组
  tuple4 = make_tuple(77, 88, 99);
  
  // 将元组从前面推入前向列表
  forwardListOftuples.push_front(tuple4);
  
  // 调用打印函数
  print(forwardListOftuples);
  return 0;
}

输出:

[ 77 88 99]   
[ 55 66 77]   
[ 33 44 55]  
[ 11 22 33]

示例2: 下面是C++程序，演示元组的前向列表的工作原理。

// C++程序演示
// 元组的前向链表
#include <bits/stdc++.h>
using namespace std;
  
// 打印前向链表的元素
void print(forward_list<tuple<string, string, 
           bool>> &forwardListOftuples)
{
  for (auto currentTuple : forwardListOftuples) 
  {
    // 每个前向链表的元素本身就是一个元组
    tuple<string, string, bool> tuple = 
                          currentTuple;
  
    cout << "[ ";
  
    // 输出元组的元素
    cout << get<0>(currentTuple) << ' ' << 
            get<1>(currentTuple) << ' ' << 
            get<2>(currentTuple);
    cout << ']';
    cout << '\n';
  }
}
  
// 主程序
int main()
{
  // 声明一个前向链表的元组
  // 前两个值为字符串类型，第三个值为bool类型
  forward_list<tuple<string, string, bool>> 
    forwardListOftuples;
  
  // 声明一个元组
  tuple<string, string, bool> tuple1;
  
  // 初始化元组
  tuple1 = make_tuple("GeeksforGeeks", 
                      "Computer Science", 0);
  
  // 将元组从后面插入前向链表中
  forwardListOftuples.push_front(tuple1);
  
  // 再声明一个元组
  tuple<string, string, bool> tuple2;
  
  // 初始化元组
  tuple2 = make_tuple("Java", "C++", 1);
  
  // 将元组从前面插入前向链表中
  forwardListOftuples.push_front(tuple2);
  
  // 再声明一个元组
  tuple<string, string, bool> tuple3;
  
  // 初始化元组
  tuple3 = make_tuple("GFG", "C", 1);
  
  // 将元组从前面插入前向链表中
  forwardListOftuples.push_front(tuple3);
  
  // 再声明一个元组
  tuple<string, string, bool> tuple4;
  
  // 初始化元组
  tuple4 = make_tuple("Swift", "Python", 0);
  
  // 将元组从前面插入前向链表中
  forwardListOftuples.push_front(tuple4);
  
  // 调用打印函数
  print(forwardListOftuples);
  return 0;
}

输出:

[ Swift Python 0]   
[ GFG C 1]   
[ Java C++ 1]   
[ GeeksforGeeks Computer Science 0]

List of tuples

在C++中，元组的列表是一个列表，每个元素本身都是一个元组。虽然元组可以包含更多或更少的元素，但出于简单起见，我们仅使用具有三个元素的元组。

语法:

**list <tuple<dataType1, dataType2, dataType3> myList; **

这里，

dataType1，dataType2和dataType3 是相似或不同的数据类型。

示例 1: 下面是演示元组列表工作的C++程序。

 // C++程序演示
//元组列表的工作原理
#include <bits/stdc++.h>
using namespace std;
  
// 打印
// 列表元素
void print(list<tuple<int, int, 
           int>> &listOftuples)
{
  for (auto currentTuple : listOftuples) 
  {
    // List每个元素都是
    // 一个元组本身
    tuple<int, int, int> tuple = currentTuple;
  
    cout << "[ ";
  
    // 打印元组元素
    cout << get<0>(currentTuple) << ' ' << 
            get<1>(currentTuple) << ' ' << 
            get<2>(currentTuple);
    cout << ']';
    cout << '\n';
  }
}
  
// 驱动程序
int main()
{
  // 声明整数类型的元组列表
  list<tuple<int, int, int>> 
  listOftuples;
  
  // 声明元组1
  tuple<int, int, int> tuple1;
  
  // 初始化元组
  tuple1 = make_tuple(11, 22, 33);
  
  // 把元组末尾推入列表
  listOftuples.push_front(tuple1);
  
  // 声明元组2
  tuple<int, int, int> tuple2;

  // 初始化元组
  tuple2 = make_tuple(33, 44, 55);
  
  // 把元组头插入列表
  listOftuples.push_front(tuple2);
  
  // 声明元组3
  tuple<int, int, int> tuple3;
  
  // 初始化元组
  tuple3 = make_tuple(55, 66, 77);
  
  // 把元组头插入列表
  listOftuples.push_front(tuple3);
  
  // 声明元组4
  tuple<int, int, int> tuple4;
  
  // 初始化元组
  tuple4 = make_tuple(77, 88, 99);
  
  // 把元组头插入列表
  listOftuples.push_front(tuple4);
  
  // 调用print函数
  print(listOftuples);
  return 0;
}

输出：

[ 77 88 99]   
[ 55 66 77]   
[ 33 44 55]   
[ 11 22 33]

示例2： 以下是演示元组列表的C++程序。

// C++程序演示元组列表的工作原理
#include <bits/stdc++.h>
using namespace std;
  
//打印列表元素的函数
void print(list<tuple<string, string, 
           bool>> &listOftuples)
{
  for (auto currentTuple : listOftuples) 
  {
    //列表的每个元素都是一个元组
    tuple<string, string, bool> tuple = currentTuple;
  
    cout << "[ ";
  
    //打印元组元素
    cout << get<0>(currentTuple) << ' ' << 
            get<1>(currentTuple) << ' ' << 
            get<2>(currentTuple);
    cout << ']';
    cout << '\n';
  }
}
  
// 主函数
int main()
{
  //声明一个列表的元组，前两个值为字符串类型，而第三个值为布尔类型
  list<tuple<string, string, bool>> 
  listOftuples;
  
  //声明一个元组
  tuple<string, string, bool> tuple1;
  
  //初始化元组
  tuple1 = make_tuple("GeeksforGeeks", 
                      "计算机科学", 0);
  
  //将元组推入列表后面
  listOftuples.push_front(tuple1);
  
  //声明另一个元组
  tuple<string, string, bool> tuple2;
  
  //初始化元组
  tuple2 = make_tuple("Java", "C++", 1);
  
  //将元组推入列表前面
  listOftuples.push_front(tuple2);
  
  //声明另一个元组
  tuple<string, string, bool> tuple3;
  
  //初始化元组
  tuple3 = make_tuple("GFG", "C", 1);
  
  //将元组推入列表前面
  listOftuples.push_front(tuple3);
  
  //声明另一个元组
  tuple<string, string, bool> tuple4;
  
  //初始化元组
  tuple4 = make_tuple("Swift", "Python", 0);
  
  //将元组推入列表前面
  listOftuples.push_front(tuple4);
  
  //调用打印函数
  print(listOftuples);
  return 0;
}

输出：

[ Swift Python 0]   
[ GFG C 1]   
[ Java C++ 1]   
[ GeeksforGeeks Computer Science 0]

在C++中使用示例的Forward List和Tuple List

在C++中使用示例的Forward List和Tuple List

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程

C++ 教程

回顶部