STL之容器小结
来源:互联网 发布:sql server没有002 编辑:程序博客网 时间:2024/06/05 17:04
STL之容器小结
一、理论提高:所有容器提供的都是值(value)语意,而非引用(reference)语意。容器执行插入元素的操作时,内部实施拷贝动作。所以STL容器内存储的元素必须能够被拷贝(必须提供拷贝构造函数)。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
二、除了queue与stack外,每个容器都提供可返回迭代器的函数,运用返回的迭代器就可以访问元素。
三、通常STL不会丢出异常。要求使用者确保传入正确的参数。
四、每个容器都提供了一个默认构造函数跟一个默认拷贝构造函数。
如已有容器vecIntA
。 vector<int> vecIntB(vecIntA); //调用拷贝构造函数,复制vecIntA到vecIntB中
。
五、与大小相关的操作方法(c代表容器):
- 1
- 2
六、比较操作(c1,c2代表容器):
- 1
- 2
- 3
七、各容器的特点
八、deque的使用场景
比如排队购票系统,对排队者的存储可以采用deque,支持头端的快速移除,尾端的快速添加。如果采用vector,则头端移除时,会移动大量的数据,速度慢。
vector与deque的比较:
(1) vector.at()比deque.at()效率高,比如vector.at(0)是固定的,deque的开始位置却是不固定的。
(2) 如果有大量释放操作的话,vector花的时间更少,这跟二者的内部实现有关。
(3) deque支持头部的快速插入与快速移除,这是deque的优点。
九、list的使用场景
比如公交车乘客的存储,随时可能有乘客下车,支持频繁的不确实位置元素的移除插入。
十、set的使用场景
比如对手机游戏的个人得分记录的存储,存储要求从高分到低分的顺序排列。
十一、map的使用场景
比如按ID号存储十万个用户,想要快速要通过ID查找对应的用户。二叉树的查找效率,这时就体现出来了。如果是vector容器,最坏的情况下可能要遍历完整个容器才能找到该用户。
一、容器的定义
在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。很简单,容器就是保存其它对象的对象,当然这是一个朴素的理解,这种“对象”还包含了一系列处理“其它对象”的方法。
二、容器的种类
1、顺序容器:是一种各元素之间有顺序关系的线性表,是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置,除非用删除或插入的操作改变这个位置。顺序容器的元素排列次序与元素值无关,而是由元素添加到容器里的次序决定。顺序容器包括:vector(向量)、list(列表)、deque(队列)。
2、关联容器:关联式容器是非线性的树结构,更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系,也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能,这样迭代器就能根据元素的特点“顺序地”获取元素。元素是有序的集合,默认在插入的时候按升序排列。关联容器包括:map(集合)、set(映射)、multimap(多重集合)、multiset(多重映射)。
3、容器适配器:本质上,适配器是使一种不同的行为类似于另一事物的行为的一种机制。容器适配器让一种已存在的容器类型采用另一种不同的抽象类型的工作方式实现。适配器是容器的接口,它本身不能直接保存元素,它保存元素的机制是调用另一种顺序容器去实现,即可以把适配器看作“它保存一个容器,这个容器再保存所有元素”。STL 中包含三种适配器:栈stack 、队列queue 和优先级队列priority_queue 。
容器类自动申请和释放内存,因此无需new和delete操作。
三、不同容器的使用方法
1、vector(需要导入头文件#include <vector>)
①定义与初始化
如果没有指定元素的初始化式,那么标准库将自行提供一个元素初始值进行,具体值为何,取决于存储在vector 中元素的数据类型;如果为int型数据,那么标准库将用 0 值创建元素初始化式;如果 vector 保存的是含有构造函数的类类型(如 string)的元素,标准库将用该类型的默认构造函数创建元素初始化式;元素类型可能是没有定义任何构造函数的类类型。这种情况下,标准库仍产生一个带初始值的对象,这个对象的每个成员进行了值初始化。
vector<int> vec1; //默认初始化,vec1为空
vector<int> vec2(vec1); //使用vec1初始化vec2
vector<int> vec3(vec1.begin(),vec1.end());//使用vec1初始化vec2
vector<int> vec4(10); //10个值为0的元素
vector<int> vec5(10,4); //10个值为4的元素
vector<string> vec6(10,"null"); //10个值为null的元素
vector<string> vec7(10,"hello"); //10个值为hello的元素
②常用的操作方法
vec1.push_back(100); //添加元素
int size = vec1.size(); //元素个数
bool isEmpty = vec1.empty(); //判断是否为空
cout<<vec1[0]<<endl; //取得第一个元素
vec1.insert(vec1.end(),5,3); //从vec1.back位置插入5个值为3的元素
vec1.pop_back(); //删除末尾元素
vec1.erase(vec1.begin(),vec1.end());//删除之间的元素,其他元素前移
cout<<(vec1==vec2)?true:false; //判断是否相等==、!=、>=、<=...
vector<int>::iterator iter = vec1.begin(); //获取迭代器首地址
vector<int>::const_iterator c_iter = vec1.begin(); //获取const类型迭代器
vec1.clear(); //清空元素
- 反向迭代器的概念点此进入
③遍历方法
//下标法(vector的特有访问方法,一般容器只能通过迭代器访问)
int length = vec1.size();
for(int i=0;i<length;i++)
{
cout<<vec1[i];
}
cout<<endl<<endl;
//迭代器法
vector<int>::const_iterator iterator = vec1.begin();
for(;iterator != vec1.end();iterator++)
{cout<<*iterator;
}
2、list(需要导入头文件#include <list>)
①定义与初始化
list<int> lst1; //创建空list
list<int> lst2(3); //创建含有三个元素的list
list<int> lst3(3,2); //创建含有三个元素的值为2的list
list<int> lst4(lst2); //使用lst2初始化lst4
list<int> lst5(lst2.begin(),lst2.end()); //同lst4
②常用的操作方法
lst1.assign(lst2.begin(),lst2.end()); //分配值
lst1.push_back(10); //添加值
lst1.pop_back(); //删除末尾值
lst1.begin(); //返回首值的迭代器
lst1.end(); //返回尾值的迭代器
lst1.clear(); //清空值
bool isEmpty1 = lst1.empty(); //判断为空
lst1.erase(lst1.begin(),lst1.end()); //删除元素
lst1.front(); //返回第一个元素的引用
lst1.back(); //返回最后一个元素的引用
lst1.insert(lst1.begin(),3,2); //从指定位置插入3个值为2的元素
lst1.rbegin(); //返回第一个元素的前向指针
lst1.remove(2); //相同的元素全部删除
lst1.reverse(); //反转
lst1.size(); //含有元素个数
lst1.sort(); //排序
lst1.unique(); //删除相邻重复元素
③遍历方法
//迭代器法
for(list<int>::const_iterator iter = lst1.begin();iter != lst1.end();iter++)
{
cout<<*iter;
}
cout<<endl;
3、deque(需要导入头文件#include <deque>)
deque容器类与vector类似,支持随机访问和快速插入删除,它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是,deque还支持从开始端插入数据:push_front()。其余类似vector操作方法的使用。
4、顺序容器使用方法小结(操作的共同点)
①添加元素
函数名意义c.push_back(t)c.push_front(t)c.insert(p,t)c.insert(p,n,t)c.insert(p,b,e)函数名意义c.size()c.max_size()c.empty()c.resize(n)c.resize(n,t)//在容器首部或者尾部添加数据
list<
int
> ilist;
ilist.push_back(ix);
//尾部添加
ilist.push_front(ix);
//首部添加
//在容器中指定位置添加元素
list<string> lst;
list<string>::iterator iter = lst.begin();
while
(cin >> word)
iter = lst.insert(iter, word);
// 和push_front意义一样
//插入一段元素
list<string> slist;
string sarray[4] = {
"quasi"
,
"simba"
,
"frollo"
,
"scar"
};
slist.insert(slist.end(), 10,
"A"
);
//尾部前添加十个元素都是A
list<string>::iterator slist_iter = slist.begin();
slist.insert(slist_iter, sarray+2, sarray+4);
//指针范围添加
②容器大小的操作
函数名意义c.back()c.front()返回容器 c 的第一个元素的引用。如果 c 为空,则该操作未定义c[n]c.at(n)list<
int
> ilist(10, 1);
ilist.resize(15);
// 尾部添加五个元素,值都为0
ilist.resize(25, -1);
// 再在尾部添加十个元素,元素为-1
ilist.resize(5);
// 从尾部删除20个元素
③访问元素
函数名意义c.erase(p)c.erase(b,e)c.clear()删除容器c内的所有元素。返回voidc.pop_back()c.pop_front()vector<
int
> vi;
for
(
int
i=0;i<10;i++)vi.push_back(i);
cout<<vi[0]<<endl;
cout<<vi.at(0)<<endl;
cout<<vi[10]<<endl;
//越界错误
cout<<vi.at(10)<<endl;
//越界错误
④删除元素
//删除第一个或最后一个元素
list<
int
> li;
for
(
int
i=0;i<10;i++)list.push_back(i);
li.pop_front();
//删除第一个元素
li.pop_back();
//删除最后一个元素
//删除容器内的一个元素
list<
int
>::iterator iter =li.begin();
if
(iter!= li.end())li.erase(iter);
//删除容器内所有元素
li.clear();
函数名 c1 = c2 c1.swap(c2) c.assign(b,e) c.assign(n,t)将容器c重新设置为存储n个值为t的元素⑤赋值与swap
list<string> sl1,sl2;
for
(
int
i=0;i<10;i++)sl2.push_back(
"a"
);
sl1.assign(sl2.begin(),sl2.end());
//用sl2的指针范围赋值,sl1中十个元素都为a
sl1.assign(10,
"A"
);
//s1被重新赋值,拥有十个元素,都为A
vector<string> vs1(3);
// vs1有3个元素
vector<string> vs(5);
// vs2有5个元素
vs1.swap(vs2);
//执行后,vs1中5个元素,而vs2则存3个元素。
5、map(需要导入头文件#include <map>)
C++中map容器提供一个键值对(key/value)容器,map与multimap差别仅仅在于multiple允许一个键对应多个值。对于迭代器来说,可以修改实值,而不能修改key。Map会根据key自动排序。
map 是键-值对的集合。map 类型通常可理解为关联数组:可使用键作为下标来获取一个值,正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联,而并非通过元素在数组中的位置来获取。
①定义与初始化
map<int,string> map1; //空map
函数名意义
在使用关联容器时,它的键不但有一个类型,而且还有一个相关的比较函数。所用的比较函数必须在键类型上定义严格弱排序(strict weak ordering):可理解为键类型数据上的“小于”关系,虽然实际上可以选择将比较函数设计得更复杂。
对于键类型,唯一的约束就是必须支持 < 操作符,至于是否支持其他的关系或相等运算,则不作要求。
②常用的操作方法
添加元素有两种方法:1、先用下标操作符获取元素,然后给获取的元素赋值 2、使用insert成员函数实现
下标操作添加元素:如果该键已在容器中,则 map 的下标运算与 vector 的下标运算行为相同:返回该键所关联的值。只有在所查找的键不存在时,map 容器才为该键创建一个新的元素,并将它插入到此 map 对象中。此时,所关联的值采用值初始化:类类型的元素用默认构造函数初始化,而内置类型的元素初始化为 0。
函数名意义m.insert(e)
函数名意义m.count(k)m.find(k)如果m容器中存在按k索引的元素,则返回指向该元素的迭代器。如果不存在,则返回超出末端迭代器。例1:
word_count.insert(map<string,
int
>::value_type(
"Anna"
, 1));
word_count.insert(make_pair(
"Anna"
, 2));//返回false,且键值仍为1.
word_count["Anna"] = 2;//键值变为2
insert的返回值:包含一个迭代器和一个bool值的pair对象,其中迭代器指向map中具有相应键的元素,而bool值则表示是否插入了该元素。如果该键已在容器中,则其关联的值保持不变,返回的bool值为false。在这两种情况下,迭代器都将指向具有给定键的元素。例2:pair<map<string,
int
>::iterator,
bool
> ret =
word_count.insert(make_pair(word, 1));
ret存储insert函数返回的pair对象。该pair的first成员是一个map迭代器,指向插入的键。
ret.first从insert返回的pair对象中获取 map 迭代器;ret.second从insert返回是否插入了该元素。例3:map1[3] = "Saniya"; //添加元素
map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素
map1.insert(pair<int,string>(1,"Siqinsini"));
map1.insert(make_pair<int,string>(4,"V5"));
string str = map1[3]; //根据key取得value,key不能修改
map<int,string>::iterator iter_map = map1.begin();//取得迭代器首地址
int key = iter_map->first; //取得key
string value = iter_map->second; //取得value
map1.erase(iter_map); //删除迭代器数据
map1.erase(3); //根据key删除value
map1.size(); //元素个数
map1.empty(); //判断空
map1.clear(); //清空所有元素
③遍历
map中使用下标存在一个很危险的副作用:如果该键不在 map 容器中,那么下标操作会插入一个具有该键的新元素。所以map 容器提供了两个操作:count 和 find,用于检查某个键是否存在而不会插入该键。
例1:
int
occurs = 0;
if
(word_count.count(
"foobar"
))occurs = word_count[
"foobar"
];
map<string,
int
>::iterator it = word_count.find(
"foobar"
);
if
(it != word_count.end())occurs = it->second;
例2:
函数名意义m.erase(k)m.erase(p)for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)
{
int keyk = iter->first;
string valuev = iter->second;
}
④从map对象中删除元素
string removal_word =
"a"
;
if
(word_count.erase(removal_word))
cout <<
"ok: "
<< removal_word <<
" removed\n"
;
else
cout <<
"oops: "
<< removal_word <<
" not found!\n"
;
6、set(需要导入头文件#include <set>)
set的含义是集合,它是一个有序的容器,里面的元素都是排序好的,支持插入,删除,查找等操作,就像一个集合一样。所有的操作的都是严格在logn时间之内完成,效率非常高。set和multiset的区别是:set插入的元素不能相同,但是multiset可以相同。Set默认自动排序。使用方法类似list。
①set容器的定义和使用
set 容器的每个键都只能对应一个元素。以一段范围的元素初始化set对象,或在set对象中插入一组元素时,对于每个键,事实上都只添加了一个元素。
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.begin(), ivec.end());
cout << ivec.size() << endl;
//20个
cout << iset.size() << endl;
// 10个
②在set中添加元素
set<string> set1;
set1.insert(
"the"
);
//第一种方法:直接添加
set<
int
> iset2;
iset2.insert(ivec.begin(), ivec.end());
//第二中方法:通过指针迭代器
③从set中获取元素
set 容器不提供下标操作符。为了通过键从 set 中获取元素,可使用 find运算。
如果只需简单地判断某个元素是否存在,同样可以使用 count 运算,返回 set 中该键对应的元素个数。
当然,对于 set 容器,count 的返回值只能是1(该元素存在)或 0(该元素不存在)。
set<
int
> iset;
for
(
int
i = 0; i<10; i++)iset.insert(i);
iset.find(1)
// 返回指向元素内容为1的指针
iset.find(11)
// 返回指针iset.end()
iset.count(1)
// 存在,返回1
iset.count(11)
// 不存在,返回0
- set<int>::iterator it=iset.begin()
*it就是当前迭代器指向的值
- set默认是从小到大排列值,定义时set<int,greater<int>> iset;则此时默认是从大到小排列值。
四、各种容器的元素在内存中的储存方式
1、vector(向量):相当于数组,但其大小可以不预先指定,并且自动扩展。它可以像数组一样被操作,
由于它的特性我们完全可以将vector 看作动态数组。在创建一个vector 后,它会自动在内存中分配一块连续的
内存空间进行数据存储,初始的空间大小可以预先指定也可以由vector 默认指定,这个大小即capacity ()函数
的返回值。当存储的数据超过分配的空间时vector 会重新分配一块内存块,但这样的分配是很耗时的,效率非常低。
2、deque(队列):它不像vector 把所有的对象保存在一块连续的内存块,而是采用多个连续的存储块,并且在一个
映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小,它不需要重新分配空间。
3、list(列表):是一个线性链表结构,它的数据由若干个节点构成,每一个节点都包括一个信息块(即实际存储的数据)、
一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩,这是因为它存储在非连续的内存空间中,
并且由指针将有序的元素链接起来。
4、set, multiset, map, multimap 是一种非线性的树结构,具体的说采用的是一种比较高效的特殊的
平衡检索二叉树—— 红黑树结构。
五、各种容器优劣分析
1、Vector:
优点:
A、支持随机访问,访问效率高和方便,它像数组一样被访问,即支持[ ] 操作符和vector.at()。
B、节省空间,因为它是连续存储,在存储数据的区域都是没有被浪费的,但是要明确一点vector 大多情况下并不是满存的,在未存储的区域实际是浪费的。
缺点:
A、在内部进行插入、删除操作效率非常低。
B、只能在vector 的最后进行push 和pop ,不能在vector 的头进行push 和pop 。
C、 当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷贝与释放,这个操作非常消耗能。
2、List:
优点:
不使用连续的内存空间这样可以随意地进行动态操作,插入、删除操作效率高;
缺点:
A、不能进行内部的随机访问,即不支持[ ] 操作符和vector.at(),访问效率低。
B、相对于verctor 占用更多的内存。
3、Deque:
优点:
A、支持随机访问,方便,即支持[ ] 操作符和vector.at() ,但性能没有vector 好;
B、可以在两端进行push 、pop 。
缺点:
在内部进行插入、删除操作效率低。
综合:
vector 的查询性能最好,并且在末端增加数据也很好,除非它重新申请内存段;适合高效地随机存储。
list 是一个链表,任何一个元素都可以是不连续的,但它都有两个指向上一元素和下一元素的指针。所以它对插入、删除元素性能是最好的,而查询性能非常差;适合 大量地插入和删除操作而不关心随机存取的需求。
deque 是介于两者之间,它兼顾了数组和链表的优点,它是分块的链表和多个数组的联合。所以它有被list 好的查询性能,有被vector 好的插入、删除性能。 如果你需要随即存取又关心两端数据的插入和删除,那么deque 是最佳之选。
3、关联容器的特点是明显的,相对于顺序容器,有以下几个主要特点:
A, 其内部实现是采用非线性的二叉树结构,具体的说是红黑树的结构原理实现的;
B, set 和map 保证了元素的唯一性,mulset 和mulmap 扩展了这一属性,可以允许元素不唯一;
C, 元素是有序的集合,默认在插入的时候按升序排列。
基于以上特点,
A, 关联容器对元素的插入和删除操作比vector 要快,因为vector 是顺序存储,而关联容器是链式存储;比list 要慢,是因为即使它们同是链式结构,但list 是线性的,而关联容器是二叉树结构,其改变一个元素涉及到其它元素的变动比list 要多,并且它是排序的,每次插入和删除都需要对元素重新排序;
B, 关联容器对元素的检索操作比vector 慢,但是比list 要快很多。vector 是顺序的连续存储,当然是比不上的,但相对链式的list 要快很多是因为list 是逐个搜索,它搜索的时间是跟容器的大小成正比,而关联容器 查找的复杂度基本是Log(N) ,比如如果有1000 个记录,最多查找10 次,1,000,000 个记录,最多查找20 次。容器越大,关联容器相对list 的优越性就越能体现;
C, 在使用上set 区别于vector,deque,list 的最大特点就是set 是内部排序的,这在查询上虽然逊色于vector ,但是却大大的强于list 。
D, 在使用上map 的功能是不可取代的,它保存了“键- 值”关系的数据,而这种键值关系采用了类数组的方式。数组是用数字类型的下标来索引元素的位置,而map 是用字符型关键字来索引元素的位置。在使用上map 也提供了一种类数组操作的方式,即它可以通过下标来检索数据,这是其他容器做不到的,当然也包括set 。(STL 中只有vector 和map 可以通过类数组的方式操作元素,即如同ele[1] 方式)。
六、关于容器的sizeof、size()、capacity问题
vector<int> ivec;
cout<<sizeof(ivec)<<endl; // 12
cout<<ivec.size()<<endl; // 0
cout<<ivec.capacity()<<endl; // 0
for(int i=0;i<10;i++)
ivec.push_back(1);
cout<<sizeof(ivec)<<endl; // 12
Cout<<ivec.size()<<endl; // 10
cout<<ivec.capacity()<<endl; // 16
这是container的实现问题,container肯定有些数据成员什么的,这可以是auto_ptr或者是普通的ptr指向一块内存区域,或者还有可能(应该)包括这个内存区域的长度,现在已经用的长度。sizeof操作符统计的只是数据成员的长度,不会与堆里面的数据长度有关,所以会出现你看到的结果。即作sizeof操作的大小是相同的。而vector::size()操作,才反映了具体数据长度。Capacity求的是容器(vector)的容量。
七、其它
1、STL中hashtable,hashset,hashmap,set,map,unordered_map、unordered_set的区别
①hashtable,hashset,hashmap,unordered_map、unordered_set与set,map的根本区别在于底层的实现不同,前者底层都是由hashtable来提供的,后者都是由红黑树来提供;前者查询时间虽然是O(1),但是并不是前者查询时间一定比后者短,因为实际情况中还要考虑到数据量,而且前者的hash函数的构造速度也没那么快,所以不能一概而论,应该具体情况具体分析。后者保证了一个稳定的动态操作时间,查询、插入、删除都是O(logN),最坏和平均都是。
②unordered_map、unordered_set在C++11的时候被引入标准库了,而hashset,hashmap没有,所以建议还是使用unordered_map比较好。
③hashset与set相比较,它里面的元素不一定是经过排序的,而是按照所用的hash函数分派的,它能提供更快的搜索速度(当然跟hash函数有关)。(hashmap与map区别一样)
- STL之容器小结
- STL之容器小结
- STL 容器之 priority_queue小结
- 34STL之容器小结
- 【C++】STL常用容器总结之十一:容器小结
- STL容器删除小结
- STL 容器小结
- STL 容器小结
- STL容器适配器接口小结
- [stl容器及算法小结]
- STL容器之顺序容器
- STL容器之关联容器
- STL容器之串行容器
- STL容器之关联容器
- 【STL】STL容器之vector
- 【STL】STL容器之map
- STL之顺序容器
- STL 之 容器
- POJ 1088 滑雪
- 网络基础常考面试题--源自牛客网
- Git知识梳理和整合
- BeanUtils将map直接封装到对象中
- h5 canvas画布、setInterval定时器、addEventListener事件
- STL之容器小结
- spring boot日志打印(六)
- 【基本算法】统计n!尾部零
- Java NIO学习笔记二(Buffer的flip()方法详解)
- 用Gson在Hibernate框架下出现栈溢出
- 二叉排序树,建立,查找,删除等操作
- Android 不能在子线程中更新ui的讨论和分析
- ubuntu 16.04 LTS
- AndroidStudio3.0--api和implementation