容器泛型算法

雨点打透心脏的1/2处 2022-09-21 00:28 228阅读 0赞

# 容器介绍 #

1.标准库定义了三种顺序容器类型：vector,list和deque(双端队列),同时还定义了三种顺序容器适配器:queue,priority\_queue和stack

适配器是根据原始的容器类型所提供的操作，通过定义新的操作接口，来适应基础的容器类型

所有的容器都是类模板

2.一些容器特点

vector：存储连续，支持快速随机访问

list:支持快速插入/删除,存储不连续

deque:双端队列

stack：后进先出的栈（LIFO）

queue：先进先出队列（FIFO）

priority\_queue:有优先级管理的队列

# 顺序容器 #

1.容器的初始化

C<T> c;

C<T> c(c2);

C<T> c(b,e);(使用迭代器初始化一段元素的副本，不要求容器类型相同，只要他们互相兼容，能够够将要复制的元素转换为所构建的新容器的元素类型，即可实现复制，因为指针就是迭代器，因此允许通过使用内置数据中的一对指针初始化容器)

例如

char \*words\[\] = \{"stately","plump","buck","mulligan"\};

size\_t words\_size = sizeof(words)/sizeof(char \*);

list<string words2(words,words + words\_size);

C<T> c(n,t);

C<T> c(n);

2.迭代器为所有标准库容器类型提供的运算

\*iter

iter->mem

\++iter

iter++

\--iter

iter--

iter1 == iter2

iter1 != iter2

iter + n

iter - n

iter1 += iter2

iter1 -=iter2

iter1 - iter2（只有vector和deque容器支持此操作）

>,>=.<,<=(注意只有vector和deque支持此操作，list只能支持==,!=操作，因为它不是连续存储的)

迭代器失效的问题：当迭代器所指向的数被erase后，则会是的迭代器失效，使用无效迭代器将会导致严重的运行时错误。

3.容器定义的类型别名

size\_type

iterator

const\_iterator

reverse\_iterator

const\_reverse\_iterator

difference\_type存储两个迭代器差值的有符号整数

value\_type元素类型

reference元素的左值类型，是value\_type&的同义词

const\_reference元素的常量左值类型，等效于const value\_type&

c.begin()

c,end()

c.rbegin()

c.rend()

此四个操作的返回值取决于容器是否为const,如果不是，则返回iterator或reverse\_iterator,如果是则返回const\_iterator或者const\_reverse\_iterator

c.push\_back(t)

c.push\_front(t)(只使用与list和deque)

c.insert(p,t)在迭代器p所指向的元素前面插入值为t的新元素，返回新添加元素的迭代器

c.insert(p,n,t)在迭代器p所指向的元素前面插入n个值为t的新元素，返回void类型

c.insert(p,b,e)在迭代器p所指向的元素前面插入由迭代器b和e标记的返回内的元素，返回void类型

（insert可能会导致整个容器的重新加载，这样的话，该容器设计的所有迭代器都会失效）

容器的比较跟字符串比较类型，必须保证容器类型和元素类型相同例如 vector<int>不能与vector<float>比较

c.size()

c.max\_size()

c.empty()

c.resize(n)调整容器的大小为n

c.resize(n,t)调整容器的大小为n，所有新添加的元素值都为t

c.back()返回容器c的最后一个元素的引用，如果c为空，则该操作未定义

c.front()返回容器c的第一个元素的引用，如果c为空，则改操作未定义

c\[n\]返回下表为n的元素的引用，如果n<0或n>=n.size()，则该操作未定义（只适用于vector和deque）

c.at(n)返回下标为n的元素的引用。如果下表越界，则该操作未定义（只适用于vector和deque容器）

c.erase(p)删除迭代器p所指向的元素，返回一个迭代器，它指向被删除元素后面的元素

c.erase(b,e)删除迭代器b和e所标记的范围内所有的元素，返回一个迭代器，它指向被删除元素段后面的元素

c.clear()删除容器c内的所有元素，返回void

c.pop\_back()删除容器c的最后一个元素，返回void

c.pop\_front()删除容器c的第一个元素，返回void（只适用于list或deque容器）

c1 = c2容器的赋值操作首先删除其左操作数容器中的所有元素，然后将右操作数容器的所有元素插入到左边容器中

c1.swap(c2)

c.assign(b,e)

c.assgin(n,t)将容器c重新设置为存储n个值为t的元素，操作首先是删除容器中所有元素，然后将其参数所指定的新元素插入到该容器中

（带有与对迭代器参数的assign操作允许我们将一个容器的元素赋给另一个不同类型的容器）

c.capacity()获取容器需要分配更多的存储空间之前能够存储的元素总数

c.reverse()告诉容器应该预留多少个元素的存储空间，当超过时，会按照一定策略增加容量

c.resize()是设置c中存放值的大小，相当于增加和减少值，这样可能会影响c.reserve

String

1.string不能使用front,back和pop\_back操作

2.只使用与string的操作 substr，append和replace

3.string类型的查找操作

s.find(args)

s.rfind(args)

s.find\_first\_of(args)

s.find\_last\_of(args)

s.find\_first\_not\_of(args)

s.find\_last\_not\_of(args)

注意args参数样式

c,pos：从下标pos开始查找字符c

s2,pos：从下标pos开始查找string类型的s2

cp,pos：从下标pos开始，查找指针cp所指向的C风格的以空字符结束的字符串

cp,pos,n：从下标pos开始，查找指针cp所指向数组的前n个字符

容器适配器:queue,priority\_queue和stack（适配器中的一种，还有迭代器适配器和函数适配器 ）

1.容器适配器让一种已存在的容器类型采用另一种不同的抽象类型的工作方式实现

2.适配器的初始化

deque<int> deq;

stack<int> stk(deq);

3.默认的stack和queue都基于deque容器实现，而priority\_queue则在vector容器上实现，如果stack要用vector赋值则必须显示声明例如:stack<string,vector<string> >

注意stack栈可以建立在vector,list或者deque容器之上，但是queue适配器要求其关联的基础容器必须提供push\_front,因此不能建立在vector容器上

priority\_queue适配器要求提供随机访问，因此可以建立在vector或deque容器上，但不能建立在list容器上

4.栈适配器操作

s.empty();

s.size();

s.pop();

s.top();

s.push(item);在站定压入新元素

5.队列和优先队列支持的操作

q.empty()

q.size()

q.pop()

q.front()返回队首元素的值，但不删除该元素，只使用于队列

q.back()返回队尾元素的值，但不删除该元素，只适用于队列

q.top()返回具有最高优先级的元素值，但不删除该元素，只使用与优先级队列

q.push(item)

关联容器

1.定义：关联容器通过键(key)存储和读取元素，关联容器类型如下：

map:关联数组，元素通过键来存储和读取，例如字典是map的一种很好的应用，单词是键，解释是值

set:大小可变的集合，支持通过键实现和快速读取，

multimap：支持同一个键多次出现的map类型，即允许多元素拥有相同的键

multiset：支持同一个键多次出现的set类型

2.标准库类型-pair类型该类型在utility头文件中定义

pair<T1,T2> p1;创建一个空的pair对象它的两个元素分别是T1和T2类型，采用值初始化

pair<T1,T2> p1(v1,v2)第一个初始化为v1，第二个初始化为v2

make\_pair(v1,v2)以v1和v2值创建一个新的pair对象，其元素类型分别是v1和v2的类型

p1<p2遵循字典顺序

p1 == p2

p.first

p.second

3.map通过可理解为关联数组，可使用键作为下表来获取一个值

map构造函数

map<k,v> m;

map<k,v> m(m2);

map<k,v> m(b,e);

在使用关联容器时，它的键不但有一个类型，而且还有一个相关的比较函数，默认情况下，标准库使用键类型定义的<操作符来实现键的比较。键值必须支持<操作(list容器不支持)

map的value\_type是pair类型，它的值成员可以修改，但键成员不能修改。

map添加元素

map<string,int> word\_count;

word\_count\["Anna"\] = 1;(此表达式做了4步：（1）在word\_count中查找键为Anna的元素，没有找到（2）将一个新的键-值对插入到word\_count中，键是const string，值为0（3）将这个新的键-值对插入到word\_count中，（4）读取新插入的元素，并将它的值赋给为1)

map：：insert使用

m.insert(e) e为在m上的value\_type类型的值 word\_count.insert(map<string,int>::value\_type("Anna",1));创建一个pair对象，直接插入到map容器中，返回值包含一个迭代器和一个bool值的pair对象 例如 pair<map<string,int>::iterator,bool> ret = word\_count.insert(make\_pair(word,1));

value\_type是pair<constK,V>类型的同义词

m.insert(beg,end)

m.insert(iter,e)

不修改map对象的查询操作（因为下标操作可能会添加元素）

m.count(k)返回m中k的出现次数

m.find(k)如果m中存在按k索引的元素，则返回该元素的迭代器，否则返回超出末端迭代器

从map对象中删除元素

m.erase(k)删除键为k的元素，返回size\_type类型的值，表示删除的元素个数

m.erase(p)删除迭代器所指向的元素，p必须指向m中确实存在的元素

m.erase(b,e)删除迭代器b到e之间的元素 返回void类型

4.set只是单纯的键的集合，没有所关联的值，只需判断某值是否存在

set不支持下标操作符