C++ 关联容器和无序容器学习笔记

最新推荐文章于 2023-11-06 07:00:00 发布

家家的快乐空间

最新推荐文章于 2023-11-06 07:00:00 发布

阅读量239

点赞数 1

分类专栏： C++学习文章标签： c++

本文链接：https://blog.csdn.net/m0_38144614/article/details/116766866

版权

C++学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

关联容器

在这里插入图片描述

使用关联容器

使用map

#include "iostream"
#include "map"
using namespace std;

int main()
{
    // 统计每个单词在输入中出现的次数
    map<string, size_t> word_count; 
    string word;
    int i = 0;
    while(i<3) 
    {
        cin >> word;
        ++word_count[word]; // 提取word的计数器并将其加1
        i++;
    }
    for(const auto &w : word_count) // 对map中的每个元素打印结果
        cout<< w.first<<" occurs " << w.second <<((w.second > 1) ? " times":" time")<<endl;
    // getchar();
    return 0;
}

结果：
hello hi hello
hello occurs 2 times
hi occurs 1 time

使用set

#include <iostream>
#include <set>
#include <map>
using namespace std;

int main()
{
    map<string, size_t> word_count;
    set<string> exclude = {"The", "But", "And", "Or", "An", "A"};
    string word;
    int i = 0;
    while(i<5)
    {
        cin>>word;
        // 如果find的返回值为end，表示set中不包含该word。否则返回其对应迭代器
        if(exclude.find(word) != exclude.end())
        {
            ++word_count[word]; // 获取并递增word的计数器
        }
        i++;
    }
    for(const auto &w : word_count) // 对map中的每个元素打印结果
        cout<< w.first<<" occurs " << w.second <<((w.second > 1) ? " times":" time")<<endl;
    return 0;
}

结果：
And But hi Or hello  
And occurs 1 time
But occurs 1 time
Or occurs 1 time

初始化multimap或multiset

一个map或set中的关键字必须是唯一的。对于一个给定的关键字，只能有一个元素的关键字等于它。multimap和multiset没有此限制，它们都允许多个元素具有相同的关键字。

#include<iostream>
#include<vector>
#include<set>
using namespace std;

int main()
{
    // 定义一个有20个元素的vector,保存0到9每个整数的两个拷贝
    vector<int> ivec;
    for(vector<int>::size_type i=0; i!=10; i++ )
    {
        ivec.push_back(i);
        ivec.push_back(i); // 每个数重复保存一次
    }
    set<int> iset(ivec.cbegin(), ivec.cend());
    multiset<int> miset(ivec.cbegin(), ivec.cend());
    cout<<"ivec.size() = "<<ivec.size()<<endl;
    cout<<"iset.size() = "<<iset.size()<<endl;
    cout<<"miset.size() = "<<miset.size()<<endl;
    return 0;
}

结果：
ivec.size() = 20 
iset.size() = 10 
miset.size() = 20

关键字类型的要求

有序容器的关键字类型

关键字类似普通有序容器的下标，它们应该按一定顺序排列，而我们可以向一个算法提供我们自己定义的比较操作。所提供的操作必须在关键字类型上定义一个严格弱序（可以看作"小于等于"）。必须具备如下基本性质：

两个关键字不能同时“小于等于”对方；如果 $k_1$ 小于等于 $k_2$ ，那么 $k_2$ 绝不能小于等于 $k_1$
如果 $k_1$ 小于等于 $k_2$ ，且 $k_2$ 小于等于 $k_3$ ，那么 $k_2$ 必须小于等于 $k_3$
如果存在两个关键字，任何一个都不小于等于另一个，那么我们称这两个关键字是等价的。如果 $k_1$ 等价于 $k_2$ ，且 $k_2$ 等价于 $k_3$ ，那么 $k_1$ 必须等价于 $k_3$ 。

如果两个等价关键字被用作map的关键字时，只能有一个元素与这两个关键字关联，我们可以用两者中任意一个来访问对应的值。

使用关键字类型的比较函数

我们需要定义一个函数来定义一个严格弱序。

#include<iostream>
#include<vector>
#include<set>
using namespace std;

class Sales_data
{
    public:
        Sales_data(float v1, float v2): val1(v1), val2(v2) {};
        float val1;
        float val2;
};

bool compareIsbn(const Sales_data &lhs, const Sales_data &rhs)
{
    return lhs.val1 < rhs.val2;
}

int main()
{
	// bookstore中的元素以compareIsbn的顺序进行排列
    multiset<Sales_data, decltype(compareIsbn)*> bookstore(compareIsbn);
    return 0;
}

如果一个类没有定义<运算符，那么不能被定义为multiset的元素类型。为了使用这种类型元素，我们需要定义一个严格弱序（二元谓词函数bool compareIsbn）。除此之外，我们使用decltype来指出自定义操作的类型。记住，当用decltype来获得一个函数指针类型时，必须加上一个*来指出我们要使用一个给定函数类型的指针。

pair类型

pair<string, string> spair = {"hello", "world"};
pair<string, vector<int>> lins;

cout<< spair.first<<", "<<spair.second<<endl;

结果：
hello, world

在这里插入图片描述

关联容器操作

关联容器还定义了一些特定类型：
在这里插入图片描述
注：对于set类型。key_type和value_type是一样的。set中保存的值就是关键字。

set<string>::value_type v1;         // v1为string
set<string>::key_type v2;           // v2为string
map<string, int>::value_type v3;    // v3是一个pair<const string, int>
map<string, int>::key_type v4;      // v4是string
map<string, int>::mapped_type v5;   // v5是int

关联容器迭代器

map：value_type是一个pair类型，其first成员保存const的关键字，second成员保存值：

map<string, int> word;
word.insert({"hello", 5});
auto map_it = word.begin();
cout<< map_it->first <<" "<<map_it->second<<endl;

Error:  map_it->first = "world";  关键字是const的

++map_it->second; // 元素的值可以更改

set：虽然set类型同时定义了iterator和const_iterator类型，但两种类型都只允许访问set中的元素。可以用一个set迭代器来读取元素的值，但不能修改：

set<int> iset = {0, 1, 2, 3, 4};
set<int>::iterator set_it = iset.begin();
while(set_it != iset.end())
{

    Error : *set_it = 42;
    
    cout<<*set_it<<endl;
    set_it++;
}

关联容器添加元素

在这里插入图片描述
注：添加单一元素的insert和emplace会返回一个pair，告诉我们插入操作是否成功。pair的first成员是一个迭代器，指向具有给定关键字的元素；second成员是一个bool值，指出元素是插入成功还是已经存在于容器中。如果关键字已经在容器中，则insert什么事情也不做。

删除元素

在这里插入图片描述

map的下标操作

在这里插入图片描述

访问元素

在这里插入图片描述

建议：对map使用find代替下标操作

在multimap或multiset中查找元素

方法一（使用find和cound）：

#include<iostream>
#include<string>
#include<map>
using namespace std;

int main()
{
    multimap<string, int> students = { {"Apple", 1}, {"Ben", 2}, {"Cat", 3}, {"Dog", 4}, {"Apple", 5}, {"Ben", 6} };

    string search_item("Apple"); // 要查找的关键字
    auto entries = students.count(search_item); // 元素的数量
    auto iter = students.find(search_item); // 此关键字对应的第一个值
    // 用一个循环查找此关键字的所有值
    while (entries)
    {
        cout<<iter->second<<endl;
        ++iter;
        --entries;
    }
    
    return 0;
}

结果：
1
5

方法二（面向迭代器）：

如果关键字在容器中，lower_bound返回的迭代器将指向第一个具有给定关键字的元素，而upper_bound返回的迭代器则指向最后一个匹配给定关键字的元素之后的位置。
如果元素不在multimap中，则lower_bound喝upper_bound会返回相等的迭代器——指向一个不影响排序的关键字插入位置。

#include<iostream>
#include<string>
#include<map>
using namespace std;

int main()
{
    multimap<string, int> students = { {"Apple", 1}, {"Ben", 2}, {"Cat", 3}, {"Dog", 4}, {"Apple", 5}, {"Ben", 6} };

    string search_item("Apple"); // 要查找的关键字

    for(auto beg = students.lower_bound(search_item), end = students.upper_bound(search_item);
            beg != end; ++beg)
    {
        cout<<beg->second<<endl;
    }
    
    return 0;
}

结果：
1
5

方法三（使用equal_range函数）：
该函数接受一个关键字，返回一个迭代器pair。

若关键字存在，则第一个迭代器指向第一个与关键字匹配的元素，第二个迭代器指向最后一个匹配元素之后的位置。
若未找到匹配元素，则两个迭代器都指向关键字可以插入的位置。

#include<iostream>
#include<string>
#include<map>
using namespace std;

int main()
{
    multimap<string, int> students = { {"Apple", 1}, {"Ben", 2}, {"Cat", 3}, {"Dog", 4}, {"Apple", 5}, {"Ben", 6} };

    string search_item("Apple"); // 要查找的关键字

    for(auto pos = students.equal_range(search_item);
            pos.first != pos.second; ++pos.first)
    {
        cout<<pos.first->second<<endl;
    }
    
    return 0;
}

结果：
1
5

无序容器

无序容器不是使用比较运算符来组织元素，而是使用一个哈希函数（hash function）和关键字类型的==运算符。

使用无序容器（unordered_map和unordered_set）

通常可以用一个无序容器替换对应的有序容器，反之亦然。除了哈希管理操作之外，无序容器还提供了与有序容器相同的操作（find, insert等）。

unordered_map<string, size_t> word_count;

与有序容器相比，无序容器的缺点和优点：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;
int main()
{
    //创建并初始化一个 unordered_map 容器，其存储的 <string,string> 类型的键值对
    std::unordered_map<std::string, std::string> my_uMap{
        {"Tom","1997"},
        {"Jenny","1998"},
        {"Ben","1999"} };
    //查找指定键对应的值，效率比关联式容器高
    string str = my_uMap.at("Jenny");
    cout << "str = " << str << endl;
    //使用迭代器遍历哈希容器，效率不如关联式容器
    for (auto iter = my_uMap.begin(); iter != my_uMap.end(); ++iter)
    {
        //pair 类型键值对分为 2 部分
        cout << iter->first << " " << iter->second << endl;
    }
    return 0;
}

查找指定键对应的值，效率比关联式容器高
使用迭代器遍历哈希容器，效率不如关联式容器

管理桶

无序容器在存储上组织为一组桶，每个桶保存零个或多个元素。无序容器使用一个哈希函数将元素映射到桶。为了访问一个元素，容器首先计算元素的哈希值，它指出应该搜索哪个桶。容器将具有一个特定哈希值的所有元素都保存在相同的桶中。如果容器允许重复关键字，所有具有相同关键字的元素都会在同一个桶中。因此，无序容器的性能依赖于哈希函数的质量和桶的数量和大小。

对于相同的参数，哈希函数必须总是产生相同的结果。理想情况下，哈希函数还能将每个特定的值映射到唯一的桶。但是，将不同关键字的元素映射到相同的桶也是允许的。当一个桶保存多个元素时，需要顺序搜索这些元素来查找我们想要的那个。计算一个元素的哈希值和在桶中搜索通常都是很快的操作。但是，如果一个桶中保存了很多元素，那么查找一个特定元素就需要大量比较操作。
在这里插入图片描述

无序容器对关键字类型的要求

默认情况下，无序容器使用关键字类型的==运算符来比较元素，它们还使用一个hash<key_type>类型的对象来生成每个元素的哈希值。

我们不使用默认的hash，而是使用类似于为有序容器重载关键字类型的默认比较操作。为了能将自定义类型用作关键字，我们需要提供函数来替代==运算符和哈希值计算函数。我们从定义这些重载函数开始：

// Sales_data 为我们的自定义类型
size_t hasher(const Sales_data &sd)
{
	return hash<string>() (sd.isbn());
}
bool eqOp(const Sales_data &lhs, const Sales_data &rhs)
{
	return lhs.isbn() == rhs.isbn();
}

我们的hasher函数使用一个标准库hash类型对象来计算ISBN成员的哈希值，该hash类型建立在string类型之上。类似的，eqOp函数通过比较ISBN号来比较两个Sales_data。

我们使用这些函数来定义一个unordered_multiset

using SD_multiset = unordered_multiset<Sales_data, decltype(hasher)*, decltype(eqOp)*>;
参数是桶大小、哈希函数指针和相等性判断运算符指针
SD_multiset bookstore(42, hasher, eqOp);

为了简化bookstore的定义，首先unordered_multiset定义了一个类型别名，此集合的哈希和相等性判断操作与hasher和eqOp函数有着相同的类型。

如果我们的类定义了==运算符，则可以只重载哈希函数：

// 使用 FooHash生成哈希值，Foo必须有==运算符
unordered_set<Foo, decltype(FooHash)*> fooSet(10, FooHash);

家家的快乐空间

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ 关联容器和无序容器学习笔记

关联容器使用关联容器使用map#include "iostream"#include "map"using namespace std;int main(){ // 统计每个单词在输入中出现的次数 map<string, size_t> word_count; string word; int i = 0; while(i<3) { cin >> word; ++word_co
复制链接

扫一扫