std vector，list，map，Dupe 常用方法和注意事项

//说明：itor = remove（itor，itor，值）；因为算法不知道删除容器所以不是正真的删除，而是移动位置把要删除的放到返回值的后面，和容器的end()之间，被删除的元素被放入这个区域后内容可能被修改，而不被删除的元素在前面的顺序也是不变的.包括remove_if，而正真删除元素可以是使用容器的erase;

删除含有9的元素,用法如下：remove(vecInfo.begin(),vecInfo.end(),9) 返回了重新调整后的应该删除元素的首位置，而end的位置不变.s

vecInfo.erase(remove(vecInfo.begin(),vecInfo.end(),9),vecInfo.end());

bool fun(int a)

{

return 9 == a;

}

vecInfo.erase(remove_if(vecInfo.begin(),vecInfo.end(),fun),vecInfo.end());

//删除最后的一个

vecInfo.pop_back();

//明显删除错误代码

for (vector<int>::iterator itor = vecInfo.begin();itor != vecInfo.end();++itor)

{

if (*itor == 2)

{

vecInfo.erase(itor); //此处的itor删除导致迭代器失效，下次循环++iotr导致崩溃

}

//循环并安全删除

for (vector<int>::iterator itor = vecInfo.begin();itor != vecInfo.end();)

{

if (*itor == 2)

{

itor = vecInfo.erase(itor);

//此处不可 vecInfo.erase(itor++); 也会崩溃，记住规律：

//容器有返回值的定义要用返回值去拿下个节点，否则就用itor++

}

else

{

++itor;

}

//便利全部元素

for_each(vecInfo.begin(),vecInfo.end(),info());

//查找指定项个数

int iCount = count(vecInfo.begin(),vecInfo.end(),2);

//查找指定项计算个数

int iCountIf = count_if(vecInfo.begin(),vecInfo.end(),countGreater2);

//从小到大排序,默认

//函数对象模版 equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>

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

//sort(vecInfo.begin(),vecInfo.end(),less<int>());

//从大到小排序

sort(vecInfo.begin(),vecInfo.end(),greater<int>());

//自定义排序

//sort(vecInfo.begin(),vecInfo.end(),compare);

sort(vecInfo.begin(),vecInfo.end(),Ccompare());

//查找

vector<int>::iterator itorFind = find(vecInfo.begin(),vecInfo.end(),9);

if (itorFind != vecInfo.end())

{

//找到

}

else

{

//没有找到

}

//条件查找

//如果是类，则类可以实现operator==函数，也可以使用函数对象

vecInfo.push_back(5);

vector<int>::iterator itorFind5 = find_if(vecInfo.begin(),vecInfo.end(),find5());

if (itorFind5 != vecInfo.end())

{

//找到

}

else

{

//没有找到

}

//partition 满足条件放在前面

//nth_element 查找一个区间的中间值或是莫个特定的百分比

return 0;

}

//区间内最大值，最小值和自定义判断

//max_element

//min_element

//判断在容积的位置

//distance

//说明：

sort，stable，partial_sort和nth_element 算法都要求随机访问的迭代器，所以这些算法只能被应用于

//vector .string. deque 和数组 .对于标准关联中的元素进行排序并没有实际意义，因为这样的容器总是使用比较函数

//来维护内部元素的有序性.list是唯一需要排序却无法使用这些排序算法容器，为此，list特供了sort成员函数。

选择容器类型的法则：

1）如果程序要求随机访问元素，则应实用vector

或deque容器。

2）如果程序必须在容器的中间插入或删除元素，就用list。

3）如果程序是在程序的首部或尾部插入或删除元素，就用deque。

选择何种容器主要在于取决于随机访问元素的代价和插入或删除元素的代价两个方面。

哪方面相对用的多就选择对该方面操作更有优势的容器类型。

list

using namespace std;

#include <list>

#include <algorithm>

#include <string>

struct info

{

void operator()(int& a)

{

printf(“info = %d\n”,a);

}

};

struct comp

{

bool operator()(int a,int b)

{

return a > b;

}

};

struct find5

{

bool operator()(int& a)

{

return 5 == a;

}

};

int _tmain(int argc, _TCHAR* argv[])

{

list<int> listInfo;

//插入元素

listInfo.push_back(2);

listInfo.push_front(3);

listInfo.insert(listInfo.begin(),1,1);

listInfo.push_back(2);

listInfo.push_back(7);

listInfo.push_back(5);

listInfo.push_back(0);

//得到第一个元素

int iFront = listInfo.front();

//得到最后一个元素

int iBack = listInfo.back();

//删除元素

listInfo.erase(listInfo.begin());

//删除最前面的一个

listInfo.pop_front();

//删除最后面的一个

listInfo.pop_back();

//条件删除

for (list<int>::iterator itor = listInfo.begin();itor != listInfo.end();)

{

if (*itor == 2)

{

//满足条件，删除并把结果返回给迭代器;

itor = listInfo.erase(itor);

}

else

{

++itor;

}

//条件删除多个

删除含有9的元素,用法如下：remove(listInfo.begin(),listInfo.end(),9) 返回了重新调整后的应该删除元素的首位置，而end的位置不变.s

listInfo.erase(remove(listInfo.begin(),listInfo.end(),9),listInfo.end());

bool fun(int a)

{

return 9 == a;

}

listInfo.erase(remove_if(listInfo.begin(),listInfo.end(),fun),listInfo.end());

//遍历

for_each(listInfo.begin(),listInfo.end(),info());

//循环安全删除

方法1

for (list<int>::iterator itor = listInfo.begin();itor != listInfo.end();)

{

if (*itor == 2)

{

listInfo.erase(itor++);

}

else

{

++itor;

}

方法2

for (list<int>::iterator itor = listInfo.begin();itor != listInfo.end();)

{

if (*itor == 2)

{

itor = listInfo.erase(itor);

}

else

{

++itor;

}

//排序

listInfo.sort();

//自定义排序

listInfo.sort(comp());

//不可用算法排序list

//查找

list<int>::iterator itorFind5 = find(listInfo.begin(),listInfo.end(),5);

if (itorFind5 != listInfo.end())

{

//find it

}

else

{

//not find

}

//自定义查找

list<int>::iterator itorFindIf5 = find_if(listInfo.begin(),listInfo.end(),find5());

if (itorFindIf5 != listInfo.end())

{

//find it

}

else

{

//not find

}

//计数

int iCount = count(listInfo.begin(),listInfo.end(),5);

//条件计数

int iCountIf = count_if(listInfo.begin(),listInfo.end(),find5());

//区间内最大值，最小值和自定义判断

//max_element

//min_element

//取得在容积的位置

//distance

return 0;

}

选择容器类型的法则：

1）如果程序要求随机访问元素，则应实用vector

或deque容器。

2）如果程序必须在容器的中间插入或删除元素，就用list。

3）如果程序是在程序的首部或尾部插入或删除元素，就用deque。

选择何种容器主要在于取决于随机访问元素的代价和插入或删除元素的代价两个方面。

哪方面相对用的多就选择对该方面操作更有优势的容器类型。

Dupe

Dupe 比 vector

多了函数

c.push_front(elem) 在头部插入一个数据

C.pop_front 删除头部数据

缺少了函数

Capacity() 返回vector当前的容量

Reserve() 给指定大小的vector分配空间

Set

//set 平衡二叉树模版

//set是关联容器。其键值就是实值，实值就是键值，不可以有重复，所以我们不能通过set的迭代器来改变set的元素的值

//set拥有和list相同的特性：当对他进行插入和删除操作的时候，操作之前的迭代器依然有效。当然删除了的那个就没效了。

//set的底层结构是RB-tree，所以是有序的

#include <set>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

set<int> intSet;

//插入一个

intSet.insert(1);

//连续插入,默认已经排序了

intSet.insert(1);//重复插入失败;

intSet.insert(9);

intSet.insert(3);

intSet.insert(4);

intSet.insert(5);

intSet.insert(6);

//删除多个

intSet.erase(2);

intSet.erase(intSet.begin());

//循环安全删除

方法1

for (set<int>::iterator itor = intSet.begin();itor != intSet.end();)

{

if (*itor == 3)

{

itor = intSet.erase(itor);

}

else

{

++itor;

}

方法2

for (set<int>::iterator itor = intSet.begin();itor != intSet.end();)

{

if (*itor == 3)

{

intSet.erase(itor++);

}

else

{

++itor;

}

//判断元素是否存在，可以使用计算这个元素的个数

int iCont4 = intSet.count(4);

int iCont9 = intSet.count(9);

//条件查找

//good,这样查找还不如上面的count呢

set<int>::iterator itorFind = intSet.find(11);

if (itorFind != intSet.end())

{

//find it;

}

else

{

//not find

}

//bad:

for (set<int>::iterator itor = intSet.begin();itor != intSet.end();++itor )

{

if (*itor == 3)

{

int a = 8;

a++;

}

//排序

//已经排序，可以在定义的时候定义其排序规则

//判断容器是否是空

intSet.empty();

return 0;

}

map

//map 的key是不可以改的.但是second是可以修改的

using namespace std;

#include <map>

#include <string>

struct stuStudent

{

string name;

int sorce;

};

struct comp

{

bool operator()(stuStudent left,stuStudent right)

{

return left.sorce > right.sorce;

}

};

int _tmain(int argc, _TCHAR* argv[])

{

//定义(默认已经排序,小到大)

map<int,string> mapData;

//定义排序,以key的类型

map<int,string,less<int>> mapData2;

//定义自己结构体为key

map<stuStudent,int,comp> mapData3;

//插入元素

mapData.insert(pair<int,string>(3,”data1″));

mapData.insert(map<int,string>::value_type(2,”aa”));

mapData.insert(map<int,string>::value_type(1,”aa”));

stuStudent a;

a.sorce =1;

mapData3.insert(map<stuStudent,int>::value_type(a,1));

//删除元素

mapData.erase(mapData.begin());

//遍历安全删除元素

方式1：

for (map<int,string>::iterator itor = mapData.begin();itor != mapData.end();)

{

if (1 == itor->first)

{

itor = mapData.erase(itor);

}

else

{

++itor;

}

方法2：

for (map<int,string>::iterator itor = mapData.begin();itor != mapData.end();)

{

if (1 == itor->first)

{

mapData.erase(itor++);

}

else

{

++itor;

}

//以key删除,即使这个key不存，也不会崩溃;

mapData.erase(1);

//修改已经存在的key的第二个元素值

mapData[1] = “hello”;

//修改不存在的key的第二元素,则默认插入元素

mapData[11] = “hello”;

//查找元素

map<int,string>::iterator itorFind1 = mapData.find(1);

if (itorFind1 != mapData.end())

{

//find

}

else

{

//not find

}

int iCount = mapData.count(1);

if (0 != iCount)

{

//find

}

else

{

//not find

}

//遍历

//for_each()

//排序

//在定义的时候的第3个参数定义函数对象类实现bool operator()｛｝即可

return 0;

}

今天的文章std vector，list，map，Dupe 常用方法和注意事项分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/67772.html

std vector，list，map，Dupe 常用方法和注意事项

//插入一个

//连续插入

//得到第一个元素

//得到最后一个元素

//删除多个

//条件删除多个

//删除最后的一个

//明显删除错误代码

//循环并安全删除

//便利全部元素

//查找指定项个数

//查找指定项计算个数

//从小到大排序,默认

//从大到小排序

//自定义排序

//查找

//条件查找

//区间内最大值，最小值和自定义判断

//判断在容积的位置

//说明：

//插入元素

//得到第一个元素

//得到最后一个元素

//删除元素

//删除最前面的一个

//条件删除

//条件删除多个

//遍历

//循环安全删除

//排序

//自定义排序

//不可用算法排序list

//查找

//自定义查找

//计数

//条件计数

//区间内最大值，最小值和自定义判断

//取得在容积的位置

//插入一个

//连续插入,默认已经排序了

//删除多个

//判断元素是否存在，可以使用计算这个元素的个数

//条件查找

//排序

//判断容器是否是空

//定义(默认已经排序,小到大)

//定义排序,以key的类型

//定义自己结构体为key

//插入元素

//删除元素

//遍历安全删除元素

//以key删除,即使这个key不存，也不会崩溃;

//修改已经存在的key的第二个元素值

//修改不存在的key的第二元素,则默认插入元素

//查找元素

//遍历

//排序

相关推荐

发表回复