C++中使用元组的Deque示例

C++中使用元组的Deque示例

什么是Deque?

在C ++中,Deque是一种序列容器,也被称为双端队列。顾名思义,Deque允许从两端进行插入和删除。虽然Deque类似于vector,但是与vector相比,Deque更高效。在vector中,保证连续的存储分配,但在Deque中情况可能并非如此。Deque是队列的特殊情况,因为在两端都允许插入和删除操作。

与Deque相关的函数:

  • push_front() 用于从容器前面推元素。
  • push_back() 用于从容器后面推元素。
  • front() 用于引用容器的第一个元素。
  • back() 用于引用容器的最后一个元素。

什么是Tuple?

在C ++中,Tuple是用于将元素分组在一起的对象。在Tuple中,元素可以是相同的数据类型或不同的数据类型。 Tuple的元素将按访问顺序初始化。

与Tuple相关的函数:

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

如何访问Tuple?

使用get<>()函数访问Tuple元素。

语法:

auto fistElement = get<0>(myTuple);

auto secondElement = get<1>(myTuple);

auto thirdElement = get<2>(myTuple);

本文重点介绍如何在C++中创建一个带有元组的二维向量。

Deque of tuples

Deque的元素本身是一个元组的Deque容器。尽管Tuple可能包含更多或更少的元素,但为了简单起见,我们只考虑三个元素的Tuple。

语法:

**deque <tuple<dataType1, dataType2, dataType3>> myContainer; **

在这里,dataType1,dataType2和dataType3可以是相似的或不同的数据类型

示例1: 下面是实现Deque of tuples的C ++程序:

// C++程序演示
// 元组双端队列的工作原理
#include <bits/stdc++.h>
using namespace std;
  
// 函数用于打印双端队列元素
void print(deque<tuple<string, 
           int, bool> >& myContainer)
{
    cout << "myContainer的元素:\n\n";
  
    for (auto currentTuple : myContainer) 
    {
        // 每个deque元素
        // 本身就是一个元组
        tuple<string, int, bool> tp = 
                      currentTuple;
  
        cout << "[ ";
  
        // 打印元组元素
        cout << get<0>(tp) << ', ' << 
                get<1>(tp) << ', ' << 
                get<2>(tp);
        cout << ']';
        cout << '\n';
    }
}
  
// 主函数
int main()
{
    // 声明元素为{string, int, bool}
    // 的元组双端队列
    deque<tuple<string, int, bool> >
          myContainer;
  
    // 声明一个元组
    tuple<string, int, bool> tuple1;
  
    // 初始化元组
    tuple1 = make_tuple("GeeksforGeeks", 
                         22, true);
  
    // 在双端队列的头部推送元组
    myContainer.push_front(tuple1);
  
    // 声明另一个元组
    tuple<string, int, bool> tuple2;
  
    // 初始化元组
    tuple2 = make_tuple("GFG", 
                         33, false);
  
    // 在双端队列的尾部推送元组
    myContainer.push_back(tuple2);
  
    // 声明另一个元组
    tuple<string, int, bool> tuple3;
  
    // 初始化元组
    tuple3 = make_tuple("Java", 
                         11, true);
  
    // 在双端队列的头部推送元组
    myContainer.push_front(tuple3);
  
    // 声明另一个元组
    tuple<string, int, bool> tuple4;
  
    // 初始化元组
    tuple4 = make_tuple("Python", 
                         44, false);
  
    // 在双端队列的尾部推送元组
    myContainer.push_back(tuple4);
  
    // 调用打印函数
    print(myContainer);
  
    return 0;
}

输出

myContainer的元素: 

[ Java, 11, 1]
[ GeeksforGeeks, 22, 1]
[ GFG, 33, 0]
[ Python, 44, 0]

示例2: 下面是实现元组双端队列的C++程序。

// C ++程序演示
// 元组双向队列的工作原理
#include 
using namespace std;

// 函数打印双向队列元素
void print(deque>& myContainer)
{
    cout << "myContainer元素:\n\n";

    for (auto currentTuple : myContainer) 
    {
        // 每个双向队列元素本身就是一个元组
        tuple tp = currentTuple;

        cout << "[ ";

        // 打印元组元素
        cout << get<0>(tp) << ', ' << get<1>(tp) << ', ' << get<2>(tp);
        cout << ']';
        cout << '\n';
    }
}

// 驱动程序
int main()
{
    // 声明元组双向队列
    // 类型为{string,float,bool}的元组
    deque> myContainer;

    // 声明元组
    tuple tuple1;

    // 初始化
    // 元组
    tuple1 = make_tuple("GeeksforGeeks",2.123, false);

    // 在双向队列前面放入元组
    myContainer.push_front(tuple1);

    // 声明另外一个元组
    tuple tuple2;

    // 初始化
    // 元组
    tuple2 = make_tuple("GFG",3.123, false);

    // 在双向队列后面放入元组
    myContainer.push_back(tuple2);

    // 声明另外一个元组
    tuple tuple3;

    // 初始化
    // 元组
    tuple3 = make_tuple("Java",1.123, true);

    // 在双向队列前面放入元组
    myContainer.push_front(tuple3);

    // 声明另外一个元组
    tuple tuple4;

    // 初始化
    // 元组
    tuple4 = make_tuple("Python",4.123, true);

    // 在双向队列后面放入元组
    myContainer.push_back(tuple4);

    // 调用print函数
    print(myContainer);

    return 0;
}

输出

myContainer元素:

[ Java, 1.123, 1]
[ GeeksforGeeks, 2.123, 0]
[ GFG, 3.123, 0]
[ Python, 4.123, 1]

比较元组双向队列的元素

此部分重点介绍比较两个元组双向队列的元素。 可以通过迭代两个元组双向队列来比较它们的元素。

例如: 在下面的程序中,我们创建了两个元组双向队列。元组的类型为{int,char,bool}。我们使用比较函数逐个比较两个双向队列的元素。请注意,两个元组的数据对象如果相应的数据对象相等,则认为两个元组相等。

# include <iostream>
# include <vector>
# include <algorithm>

using namespace std;

// Function to compare two containers
bool compare(const vector<int>& container1, const vector<int>& container2)
{
    // If size of both containers is not equal
    if (container1.size() != container2.size())
        return false;
 
    // Sort both containers
    vector<int> temp1(container1);
    vector<int> temp2(container2);
    sort(temp1.begin(), temp1.end());
    sort(temp2.begin(), temp2.end());
 
    // Compare elements of both containers
    for (int i = 0; i < container1.size(); i++)
    {
        if (temp1[i] != temp2[i])
            return false;
    }
    return true;
}
 
int main()
{
    // Initializing vectors
    vector<int> myContainer1 = {1, 2, 3, 4};
    vector<int> myContainer2 = {4, 3, 2, 1};
    vector<int> myContainer3 = {2, 1, 4, 3};
 
    // Calling compare function
    if (compare(myContainer1, myContainer2))
        cout << "myContainer1 and " << 
                "myContainer2 are equal.";
    else
        cout << "myContainer1 and " << 
                "myContainer2 are not equal.";
    cout << '\n';
 
    // Calling compare function
    if (compare(myContainer1, myContainer3))
        cout << "myContainer1 and " << 
                "myContainer3 are equal.";
    else
        cout << "myContainer1 and " << 
                "myContainer3 are not equal.";
 
    cout << '\n';
 
    // Calling compare function
    if (compare(myContainer2, myContainer3))
        cout << "myContainer2 and " << 
                "myContainer3 are equal.";
    else
        cout << "myContainer2 and " << 
                "myContainer3 are not equal.";
 
    return 0;
}

输出

myContainer1 和 myContainer2 相等。
myContainer1 和 myContainer3 不相等。
myContainer2 和 myContainer3 不相等。

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程

C++ 教程