C++ - STL标准库_c++ stl标准库

最新推荐文章于 2024-06-29 16:00:10 发布

2401_83704218

最新推荐文章于 2024-06-29 16:00:10 发布

阅读量574

点赞数 11

分类专栏：程序员文章标签： c++ 开发语言

本文链接：https://blog.youkuaiyun.com/2401_83704218/article/details/138777539

版权

程序员专栏收录该内容

444 篇文章

订阅专栏

}
cout << endl;

//测试我们自己实现的Print算法,迭代器架起了算法与容器之间的桥梁
Print<vector::iterator>(v.begin(), v.end());
Print(v.begin(), v.end());
Print<vector::reverse_iterator>(v.rbegin(), v.rend());

return 0;
}


**添加、删除、插入元素：**

#include
#include
using namespace std;

int main()
{
vector v;//定义一个空的动态数组
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//往尾部插入元素 // 1
v.push_back(1);
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

v.push_back(2); // 1 2
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//向某一个迭代器指向的位置插入
v.insert(v.begin(), 3);// 3 1 2
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//向某一个迭代器指向的位置插入2个值为4的元素
v.insert(v.end()-1 , 2, 4);// 3 1 4 4 2
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//使用迭代器遍历
for (vector::const_iterator it = v.cbegin(); it!= v.cend(); it++)
{
cout << *it << " ";
}
cout << endl;

//访问第一个元素
cout <<"front " <<v.front() << endl;
//访问最后一个元素
cout << "back " << v.back() << endl;
//访问某一个下标的元素
cout << "at " << v.at(3) << endl;

//删除最后一个元素
v.pop_back();
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//删除开头的元素
v.erase(v.begin());
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//删除结尾的元素, end()指向最后一个元素的下一个
v.erase(v.end()-1);
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

//使用迭代器遍历
for (vector::const_iterator it = v.cbegin(); it != v.cend(); it++)
{
cout << *it << " ";
}
cout << endl;

//删除所有元素，不会清除容量
v.clear();
cout << “容量:” << v.capacity() << " 元素个数:" << v.size() << endl;

/*
当size和capacity相等时继续添加数据，否则vector会扩容，
每次扩容都是增加当前空间的1/2(第一次除外);
*/
{
vector v;

cout << "------------------------capacity容量随元素个数size增加的规律----------------------------" << endl;
for (int i = 0; i < 50; i++)
{
	v.push_back(i);
	cout << "v的容量：" << v.capacity() << "  元素个数:" << v.size() << endl;
}

}

return 0;
}


 **vector常用赋值操作：**

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。


**vector大小操作:**

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。


**vector数据存取操作:**

at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素


**vector插入和删除操作:**

insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素


**vector排序：**

sort(nums.begin(),nums.end());


**定义二维vector：**

vector<vector> v;


**创建m\*n的二维vector：**

vector<vector >nums(m ,vector(n)); //m*n的二维vector


**初始化二维数组：**

vector<vector> nums(m ,vector(n,0)); //m*n的二维vector，所有元素为0


**二维数组遍历：**

int m = nums.size(),n = nums[0].size();
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
cout<<nums[i][j]<<endl;
}
}


**4.deque容器**


Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。


所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以


在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。


![在这里插入图片描述](https://img-blog.csdnimg.cn/20190817080710196.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIyMTAz,size_16,color_FFFFFF,t_70)


**deque容器实现原理:**


Deque容器是连续的空间，至少逻辑上看来如此，连续现行空间总是令我们联想到array和


vector,array无法成长，vector虽可成长，却只能向尾端成长，而且其成长其实是一个假象，事实上


(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间 三步骤，如果不是vector每次配置新的空间


时都留有余裕，其成长假象所带来的代价是非常昂贵的。


Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间，便


配置一段连续定量的空间，串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连


续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮


回，代价就是复杂的迭代器架构。


既然deque是分段连续内存空间，那么就必须有中央控制，维持整体连续的假象，数据结构的设计


及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。


Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续


的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称


作缓冲区。缓冲区才是deque的存储空间的主体。


![在这里插入图片描述](https://img-blog.csdnimg.cn/20190817080837663.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIyMTAz,size_16,color_FFFFFF,t_70)


**基本使用 :**

#include

#include
using namespace std;

int main()
{
//空的双端队列
deque d;
cout << “元素个数” << d.size() << endl;

deque d2(5);//指定元素个数，默认值为类型默认值
cout << “元素个数” << d2.size() <<" "<<d2[0]<< endl;

deque d3(5,111);//指定元素个数，每一个指定元素值111
cout << “元素个数” << d3.size() << " " << d3[4] << endl;

deque d4(d3);//拷贝构造
cout << “元素个数” << d4.size() << " " << d4[3] << endl;

//像数组一样的访问元素（内存空间并不是连续的）
d2[0] = 1;
d2[1] = 2;
d2[2] = 3;
d2.at(3) = 4;

for (size_t i = 0; i < d2.size(); i++)
{
cout << d2[i] << " ";
}
cout << endl;

//验证deque的内存空间不是连续的
{
deque d;

for (size_t i = 0; i < 20; i++)
{
	d.push_back(i);
	cout << "元素" << d[i] << " " << &d[i] << '\t';

	if ((i + 1) % 4 == 0)cout << endl;
} 
cout << endl;

}

return 0;
}


**迭代器使用：**

#include

#include
using namespace std;

template
void Print(T begin, T end)
{
for (T p = begin; p != end; ++p)
{
cout << *p << " ";
}
cout << endl;
}

int main()
{
deque d2(5);//指定元素个数，默认值为类型默认值
cout << “元素个数” << d2.size() << " " << d2[0] << endl;

//像数组一样的访问元素（内存空间并不是连续的）
d2[0] = 1;
d2[1] = 2;
d2[2] = 3;
d2.at(3) = 4;
d2.at(4) = 5;
for (size_t i = 0; i < d2.size(); i++)
{
cout << d2[i] << " ";
}
cout << endl;

//deque::iterator是随机访问迭代器
cout << typeid( deque::iterator::iterator_category ).name() << endl;

//支持++ 、–、+=n、 -=n、[]、* 、+n、-n

deque::iterator it = d2.begin();//获取指向容器的第一个元素的迭代器
cout << “begin返回的迭代器指向的元素：”<<*it << endl;

*it = 111;//deque::iterator可以改变迭代器指向的元素值

it++;//下一个元素，it自身改变
cout <<“++后:”<< *it << endl;

it += 2;//往后移2个位置，it自身改变，指向第4个元素
cout << “+=2后:” << *it << endl;

cout << “-3后:” << *(it-3) << endl; // it-3代表it位置的前3个位置，it自身不变

cout << “[1]后:” << it[1] << endl; //指向最后一个

it = d2.begin();//置为开头
cout << “[i]后:” << it[1] << endl; //指向第二个

//const_iterator只读的迭代器
deque::const_iterator it2 = d2.cbegin();
//*it2 = 11111; //无法改变元素的值，只能读取，类似于 const int *

//使用迭代器正向遍历
for (deque::iterator it = d2.begin(); it != d2.end(); ++it)
{
cout << *it << " ";
}
cout << endl;

//使用反向迭代器反向向遍历
for (deque::reverse_iterator it = d2.rbegin(); it != d2.rend(); ++it)
{
cout << *it << " ";
}
cout << endl;

//测试自己写的算法(无需知道deque容器的内存结构，具有通用性)
Print<deque::iterator>(d2.begin(), d2.end());
Print(d2.rbegin(), d2.rend());//自动推导

return 0;
}


**添加、删除、插入元素：**

#include

#include
using namespace std;

int main()
{
deque d;

d.push_back(1);//从尾部插入元素
d.push_front(2);//从头部插入元素（vector没有此方法）
d.insert(d.begin(), 3);//在迭代器位置插入
d.insert(d.end(), 2, 4);//在迭代器位置插入2个元素值为4

for ( int i = 0; i < d.size(); i++)
{
cout <<d[i]<< " ";
}
cout << endl;

//访问元素
//d.at(0) = 111;
//d[4] = 555;
cout << d.front() << endl;//返回第一个元素
cout << d.back() << endl;//返回第一个元素

//删除元素
d.pop_back();//从尾部删除
d.pop_front();//从头部删除（vector不提供）

d.erase(d.begin());//删除某个迭代器指向的元素

for (int i = 0; i < d.size(); i++)
{
cout << d[i] << " ";
}
cout << endl;

d.clear();//全部清空

cout << “元素个数：”<<d.size() << endl;

return 0;
}


**deque赋值操作：**

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将deq与本身的元素互换


**deque大小操作：**

deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。


**deque双端插入和删除操作：**

push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据


**deque数据存取：**

at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据


**deque插入操作：**

insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。


**deque删除操作：**

clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。



**5.list容器**


链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针


链接次序实现的。


链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包


括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。


相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是


配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，


对于任何位置的元素插入或元素的移除，list永远是常数时间。


List和vector是两个最常被使用的容器。


List容器是一个双向链表。


![在这里插入图片描述](https://img-blog.csdnimg.cn/20190817081547209.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIyMTAz,size_16,color_FFFFFF,t_70)


* 采用动态存储分配，不会造成内存浪费和溢出
* 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
* 链表灵活，但是空间和时间额外耗费较大


**基本使用:**

#include

#include
using namespace std;

int main()
{
list l;//空的双向链表
cout << “元素个数:” << l.size() << endl;

list l2(5);//初始化5个元素，默认值为类型的默认值
cout << “元素个数:” << l2.size() <<" "<< * (l2.begin() )<< endl;

list l3(5,111);//初始化5个元素，每个元素初始值为111
cout << “元素个数:” << l3.size() << " " << *(l3.begin()) << endl;

list l4( l3 );//拷贝构造
cout << “元素个数:” << l4.size() << " " << *(l4.begin()) << endl;

//不支持[]运算符，因为效率低
//cout << l4[0] << endl;

//验证了list容器的内存空间是不连续的
for (list::iterator it = l3.begin(); it !=l3.end(); it++)
{
cout << &(*it) << " ";
}
cout << endl;

return 0;
}


**迭代器使用:**

#include

#include
using namespace std;

template
void Print(T begin, T end)
{
//此处编写代码
for (T p = begin; p != end; ++p)
{
cout << *p << " ";
}
cout << endl;
}

int main()
{
list l3(5, 111);//初始化5个元素，每个元素初始值为111
cout << “元素个数:” << l3.size() << " " << *(l3.begin()) << endl;

//验证list容器的迭代器类型（5种之一）
//双向迭代器bidirectional_iterator_tag
cout << typeid(list::iterator::iterator_category).name() << endl;

//双向迭代器比随机访问迭代器弱一些，支持 ++ – != == = * 不支持[] +n -n +=n -=n
list::iterator it = l3.begin(); //指向容器l3的第一个元素
cout << *it << endl;

*(++it) = 222;
*(++it) = 333;
*(++it) = 444;
*(++it) = 555;

++it;//指向最后一个元素的下一个

cout <<“迭代器指向末尾的下一个”<< (it == l3.end() )<< endl;

–it;//指向最后一个元素
cout << *it << endl;

//it += 3;//不支持
//it + 3;//不支持
//it[0];//不支持

//const_iterator常迭代器，类似于 const int *
list::const_iterator it2 = l3.cbegin();
//*it2 = 1;//不能修改常迭代器指向的内容

//正向遍历
for (list::iterator it = l3.begin(); it != l3.end(); it++)
{
cout << *it << " ";
}
cout << endl;

//反向遍历
for (list::reverse_iterator it = l3.rbegin(); it != l3.rend(); it++)
{
cout << *it << " ";
}
cout << endl;

//测试自己的算法(迭代器带来的好处，算法无需关系容器的具体内存结构，就可以遍历)
Print<list::iterator>(l3.begin(), l3.end());
Print(l3.crbegin(), l3.crend());//自己推到迭代器类型

return 0;
}


**增加、删除、插入元素:**

#include

#include
using namespace std;

int main()
{
list l;

//头部插入一个节点（list容器肯定知道头部的位置）
l.push_front(111);

//尾部插入一个节点（list容器肯定知道尾部的位置）
l.push_back(444);
l.push_back(555);

//在某个迭代器的位置之前插入
l.insert(l.begin(), 222);

//在某个迭代器的位置之前插入n个相同值元素
l.insert(l.begin(), 3,333);

//访问链表第一个元素
l.front() = 1;
cout <<“第一个元素:”<< l.front() << endl;

//访问链表最后一个元素
cout << “最后一个元素:” << l.back() << endl;

for (list::iterator it = l.begin(); it!= l.end(); it++)
{
cout << *it << " ";
}
cout << endl;

//删除链表头的元素
l.pop_front();

//删除链表尾的元素
l.pop_back();

//删除某个迭代器指向的元素
l.erase(l.begin());

//删除一段迭代器区间

l.erase(l.begin(),l.end());

//清空链表
l.clear();

for (list::iterator it = l.begin(); it != l.end(); it++)
{
cout << *it << " ";
}
cout << endl;

return 0;
}


**list数据元素插入和删除操作**

push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。


**list大小操作**

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，
若容器变长，则以默认值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
若容器变长，则以elem值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。


**list赋值操作**

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。


**list数据的存取**

front();//返回第一个元素。
back();//返回最后一个元素。


**list反转排序**

reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); //list排序



**6.set/multiset容器**



`set`（集合）是一种每个元素值都是唯一的有序的关联容器。


`multiset`（多重集合）是一种元素值 可复的、有序的 关联容器。


set/multiset容器内部结构采用`红黑树（Red-Black tree）`的平衡[二叉树]( )，它可以在`O(logn)`时间内


高效的做查找，插入和删除。


![img](https://img-blog.csdnimg.cn/img_convert/90f5158dcef4e6151b4f4a9749a4febf.png)


 基本使用:

#include
#include
#include

using namespace std;

int main()
{
//set 的特点，值必须唯一，有序

set s;//构造空的集合,默认less 升序
cout << “元素个数” << s.size() << endl;

set<int>  s2 = {3,2,5,1,4 ,3};//初始化列表

//set<int, greater> s2 = {3,2,5,1,4 ,3};//初始化列表,降序
cout << “元素个数” << s2.size() << endl;

set s3(s2.begin(),s2.end()); //拷贝迭代器范围内的元素
cout << “元素个数” << s3.size() << endl;

//插入元素 ,成功后返回值的成员second为1，失败为0
//cout << typeid(s2.insert(9)).name() << endl;
cout<< s2.insert(9).second <<endl;

//重复插入元素
cout << s2.insert(9).second << endl;

vector v = {6,7,8,9};
s2.insert(v.begin(), v.end());//插入其它容器中元素的值

for (set::iterator it = s2.begin(); it!=s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;

//删除值为6的元素
s2.erase(6);

//删除迭代器指向的元素
s2.erase(s2.begin());

for (set::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;

//删除迭代器区间
set::iterator it = s2.begin();
it++; it++; it++;
s2.erase(s2.begin(), it);

//s2.clear();//清空集合元素

for (set::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;

//查找集合中的元素 ,找到返回指向该元素的迭代器，否则返回end()
set::iterator it2 = s2.find(99);
if (it2 != s2.end())
{
cout << “找到:” <<*it2<< endl;
}
else
{
cout << “未找到！” << endl;
}

return 0;
}


**迭代器使用**


STL为`set`容器提供了相应的迭代器类`set<T>::iterator`，它是一个`双向迭代器（Bidirectional`


`iterator）`，以供我们方便的访问容器内部的元素。

#include

#include
using namespace std;

template
void Print(T begin, T end)
{
for (T p = begin; p != end; ++p)
{
cout << *p << " ";
}
cout << endl;
}

int main()
{
//set 的特点，值必须唯一，有序
set s2 = { 3,2,5,1,4,3 };//初始化列表

//输出set迭代器的类别: bidirectional_iterator_tag 双向迭代器
cout << typeid(set::iterator::iterator_category).name() << endl;

//双向迭代器，支持++ – * != == = 不支持 [] +=n -=n +n -n
set::iterator it = s2.begin();//获取第一个元素
cout <<“第一个元素”<< *it << endl;

// *it = 111;  //不可更改，说明set中元素值不可改变

//符合逻辑，因为set中每个元素都已经根据值排列好了大小，此刻你若更改值，顺序无法保证

++it;
cout << “第二个元素” << *it << endl;

–it;
cout <<“是否指向开头”<< (it == s2.begin())<< endl;

//常迭代器，不可更改指向的元素的内容
set::const_iterator it2 = s2.cbegin();//获取第一个元素
// *it2 = 111; //不可更改set元素中的值

//验证下， set::iterator 与 set::const_iterator 是一样的
cout << typeid(set::iterator ).name() << endl;
cout << typeid(set::const_iterator).name() << endl;

//正向遍历
for (set::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;

//反向遍历
for (set::reverse_iterator it = s2.rbegin(); it != s2.rend(); it++)
{
cout << *it << " ";
}
cout << endl;

//测试自定义的Print算法(迭代器，算法无需关心容器的内存结构)
Print<set::iterator>(s2.begin(), s2.end());
return 0;
}


**set赋值操作**

set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器


**set大小操作**

size();//返回容器中元素的数目
empty();//判断容器是否为空


**set插入和删除操作**

insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。


**set查找操作**

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//查找键key的元素个数
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。



**7.map/multimap容器**


`map`（映射）是一种存储键值（`key-value`）对， key是唯一的、有序的 关联容器。


`multimap`（多重映射）是一种存储键值（key-vauekey是 允许重复的、有序的 关联容器。


`map`内部结构采用`红黑树（Red-Black tree）`平衡二叉树，它可以在`O(log n)`时间内高效的做查


找，插入和删除。


Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所


有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
## 最后

**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。**

**因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/1d0f044c8994420862d285556af9a93c.png)

![img](https://img-blog.csdnimg.cn/img_convert/8c6894bc2d6939c72af60f95261c9ebb.jpeg)

![img](https://img-blog.csdnimg.cn/img_convert/a9f7cc010f5d68250e58c94a2eff5a8d.png)

 ![img](https://img-blog.csdnimg.cn/img_convert/df8a61024c78288711f052cae6ecf1f1.png)

![img](https://img-blog.csdnimg.cn/img_convert/14119d8b4880bb438663de5e6eabbf3a.png)

![img](https://img-blog.csdnimg.cn/img_convert/731f38c5fd850cedc6d3fcf934ad0274.png)

![](https://img-blog.csdnimg.cn/img_convert/b50ebf8c38c39456c6f4f5456687bde1.png)

 

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！**

[**如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！**](https://bbs.youkuaiyun.com/topics/618654289)

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**！！


`


**7.map/multimap容器**


`map`（映射）是一种存储键值（`key-value`）对， key是唯一的、有序的 关联容器。


`multimap`（多重映射）是一种存储键值（key-vauekey是 允许重复的、有序的 关联容器。


`map`内部结构采用`红黑树（Red-Black tree）`平衡二叉树，它可以在`O(log n)`时间内高效的做查


找，插入和删除。


Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所


有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
## 最后

**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。**

**因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

[外链图片转存中...(img-Vu4V02rY-1715541325276)]

[外链图片转存中...(img-zsxF8851-1715541325277)]

[外链图片转存中...(img-lARFpAIC-1715541325277)]

 [外链图片转存中...(img-2Z4bVT1b-1715541325278)]

[外链图片转存中...(img-teztLvYK-1715541325278)]

[外链图片转存中...(img-xXeuuwwN-1715541325279)]

[外链图片转存中...(img-RLNsDxQw-1715541325279)]

 

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！**

[**如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！**](https://bbs.youkuaiyun.com/topics/618654289)

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**！！