文章目录
- set的特性
- set初始化
- set迭代器和常见成员函数
- multiset
- map的特性
- map初始化
- map迭代器和常见成员函数
- insert
- []运算符重载
- multimap
set的特性
- 自动排序：
set中的元素会默认排升序存储- 唯一性：
set中每个元素都是唯一的，如果插入一个已有元素，则不会执行插入。- 存储方式：
set在底层中，key和value是相同的，即<value,value>，所以插入元素时只需要value，不需要构造键值对。- 元素修改限制：
由于set底层是红黑树，如果修改元素，结构会被破坏，所以不能修改元素。- 性能：
插入、删除、查找复杂度都O(logn).- 与unordered_set比较
插入、删除、查找的效率比set快。
set初始化
void test1_set()
{
// 默认无参构造
set<int> s1;
// 迭代器区间
string rq1("renqing");
set<int> s2(rq1.begin(), rq1.end());
// 拷贝构造
set<int> s3(s1);
// 指定比较方式
set<int, greater<int>> s4;
// 初始化列表
set<int> s5 = { 1,2,3,4,5 };
}
set迭代器和常见成员函数
迭代器
// 正向迭代器
iterator begin();
iterator end();
// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();
void test2_set()
{
// 正向迭代器
vector<int> v = { 1,2,3,4,5 };
set<int> s1(v.begin(), v.end());
set<int>::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// 反向迭代器
set<int>::reverse_iterator rt = s1.rbegin();
while (rt != s1.rend())
{
cout << *rt << " ";
++rt;
}
cout << endl;
}
void test3_set()
{
set<int> s1;
s1.insert(1);
s1.insert(2);
s1.insert(3);
s1.insert(3);
s1.insert(4);
s1.insert(5);
s1.insert(5);
// 元素个数
cout <<"元素个数：" << s1.size() << endl;
set<int>::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
set<int>::iterator pos = s1.find(3);
if (pos != s1.end())
{
s1.erase(pos);
}
cout << "元素个数：" << s1.size() << endl;
set<int>::iterator it1 = s1.begin();
while (it1 != s1.end())
{
cout << *it1 << " ";
++it1;
}
}
multiset
set和multiset差异
multiset和set使用基本一样，不过multiset支持键值冗余。
void test4_set()
{
// 相⽐set不同的是，multiset是排序，但是不去重
multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
auto it = s.begin();
while (it != s.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// 相⽐set不同的是，x可能会存在多个，find查找中序的第⼀个
int x;
cin >> x;
auto pos = s.find(x);
while (pos != s.end() && *pos == x)
{
cout << *pos << " ";
++pos;
}
cout << endl;
// 相⽐set不同的是，count会返回x的实际个数
cout << s.count(x) << endl;
// 相⽐set不同的是，erase给值时会删除所有的x
s.erase(x);
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
}
map的特性
- 存储和排序：
按照特定次序（基于键值 key 比较）存储由键值 key 和值 value 组成的元素，使用迭代器遍历可得到有序序列。- 键值和值：
map存储的是键值对，可以通过键快速访问到对应值。在底层value_type，键值和值绑定并取别名为 pair<first,second>。- 修改限制：
map的key不能修改，value可以，因为底层是基于key构建的红黑树。- 内部排序：
内部按照键值进行比较排序，默认键值按小于比较，若未传入内部比较对象。- unordered_map：
插入、删除、查找的效率比map快。- 键的类型：
map的键值是可以比较的，支持 < 运算符。- 下标访问：
支持下标访问符，在 [] 中放入键值 key ，可获取对应的 value 。- 底层实现：
在底层使用平衡搜索树（红黑树）实现，查找元素的时间复杂度为O (logN)。
map初始化
//1.默认无参构造
map<int, int> m1;
//2.迭代器区间初始化
map<int, int> m2(m1.begin(), m1.end());
//3.拷贝构造
map<int, int> m3(m1);
//4.指定比较方式
map<int, int, greater<int>> m4;
map迭代器和常见成员函数
map迭代器
void test2_map()
{
map<string, int> m;
m.insert(pair<string, int>("one", 1));
m.insert(pair<string, int>("two", 2));
m.insert(pair<string, int>("three", 3));
m.insert(pair<string, int>("four", 4));
// 正向迭代器
map<string, int>::iterator it = m.begin();
while (it != m.end())
{
cout << it->first << ":" << it->second << " ";
++it;
}
cout << endl;
//反向迭代器
map<string,int>::reverse_iterator rit = m.rbegin();
while (rit != m.rend())
{
cout << rit->first << ":" << rit->second << " ";
++rit;
}
cout << endl;
}
常见成员函数
insert
insert的函数参数是value_type，其实value_type是被typedef之后的类型，真实类型为：
typedef pair<const Key, T> value_type;
插入数据：
void test3_map()
{
// 定义一个有名pair对象
map<string, string> s1;
pair<string, string> p1("apple", "苹果");
s1.insert(p1);
// 定义一个匿名的pair对象
s1.insert(pair<string, string>("banana", "香蕉"));
// 调用make_pair
s1.insert(make_pair("pear", "梨"));
}
make_pair是个函数模板
类似这样，把两个值传给pair，pair再自己构造一个匿名对象进行返回，所以可以省略参数类型
C++11之后支持直接使用初始化列表
// 初始化列表
s1.insert({ "peach","桃子" });
遍历打印
因为map是键值对，所以并不能像其他迭代器一样直接解引用迭代器打印，像打印得通过pair
打印
map<string, string>::iterator it = s1.begin();
while (it != s1.end())
{
cout << (*it).first << ":" << (*it).second << " " << endl;
it++;
}
cout << endl;
find和erase都只与key有关系，只有insert才需要key和value
[]运算符重载
其中mapped_type就是value的类型，并且这个重载实现方式是这样的：
(*((this->insert(make_pair(k, mapped_type()))).first)).second
operator[]底层是用insert实现
(*((this->insert(make_pair(k, mapped_type()))).first)).second这一段代码看着太复杂，展开一下：
从insert可以看出
如果插入成功：pair<新插入的迭代器，true>
如果插入失败：pair<已经存在的跟key相等迭代器，false>
从返回结果中还可以看出：无论插入成功还是失败，都会返回指向key的迭代器，那么就意味着，insert不仅仅可以插入，还有查找功能。
需要注意的是，有两个pair，一个是map底层红黑树中的pair<key,T>,
另一个是insert返回值的pair<iterator,bool>
void test3_map()
{
// 定义一个有名pair对象
map<string, string> s1;
pair<string, string> p1("apple", "苹果");
s1.insert(p1);
// 定义一个匿名的pair对象
s1.insert(pair<string, string>("banana", "香蕉"));
// 调用make_pair
s1.insert(make_pair("pear", "梨"));
// 初始化列表
s1.insert({ "peach","桃子" });
map<string, string>::iterator it = s1.begin();
while (it != s1.end())
{
cout << (*it).first << ":" << (*it).second << " " << endl;
it++;
}
cout << endl;
// 存在 查找+修改
s1["apple"] = "瓶果";
// 不存在 插入+修改
s1["vegetable"] = "蔬菜";
// 存在 查找（谨慎使用）
cout << s1["peach"] << endl;
// 不存在 插入
cout << s1["renqing"] << endl;
}
multimap
multimap的使用方式与map基本一致，唯一的区别就在于multimap允许键值冗余，即可存储重复元素。
void test4_map()
{
multimap<string, string> s1;
s1.insert({ "peach","桃子" });
s1.insert({ "peach","桃子" });
s1.insert({ "apple", "苹果" });
s1.insert({ "banana", "香蕉" });
s1.insert({ "banana", "香蕉" });
s1.insert({ "pear", "梨" });
for (const auto& e : s1)
{
cout << "<" << e.first << "," << e.second << ">" << " " << endl;
}
}
multimap的find返回底层搜索树中序的第一个值为key的元素的迭代器，而map返回的是key元素的迭代器。并且由于multimap支持键值冗余，所以其成员函数没有[]运算符重载，因为一旦键值冗余，根本不知道该返回哪个键值的value。
