容器概述

容器概述

stl是Standard Template Library的简称，中文为标准模板库

是一些容器的集合，这些容器包括list,vector,set,map

//容器 （数据结构）

序列式容器：可序（每个元素都有固定的位置，取决于插入的时机以及地点，与数据本身无关）添加元素简单，元素的查找相对麻烦

vector 、list、deque

关系式容器：已序（元素的位置取决于元素的大小）

set map multiset multimap//元素的查找相对简单

//容器接口：有一些公共的能力，有相同的接口

//stl容器需要满足的特性：

1、外部数据外部管理，内部数据内部管理，容器在实现数据的插入时，内部实现的拷贝操作，防止数据被错误更改，需要数据本身能够被拷贝

2、容器内的元素都会形成次序（物理次序）

3、容器的各项操作并非绝对安全

迭代器：可遍历stl容器内全部或者部分元素的对象，每一个容器的内存模型可能并不相同，每一个容器都有自己的迭代器。智能指针：不需要手动分配和释放，具备遍历复杂数据结构的功能。

半开区间：一个迭代器指向容器的某个位置，两个迭代器会形成区间，这个区间被称为半开区间。

1、为遍历元素，提供循环的结束时机

2、不需要对空区间采取特殊的处理手段

vector：动态数组

顺序表，物理位置连续，可以被排序，支持随机的存取

在末端进行插入删除效率高，中部和前部插入删除效率低

，数组大小可变

#include
#include
using namespace std;
int main() {
vector v;//通过类模板来生成模板类
vector v1(v);//拷贝构造vector，要求数据类型相同

for (int i = 0; i < 10; i++) {
	v.push_back(i + 1);//把i+1当元素备份进v中
	v.pop_back();//把vector的最后一个元素出容器
}
vector<int>::iterator vit,vit1;//vector容器的迭代对象
vector<int> v2(vit, vit1);//构造包含半开区间的vector
vector<int> v4(10);//创建含有10个元素的vector
v2.swap(v4);//交换两个vector中的元素
v.assign(6, 12);//将vector中的元素设置为6个12
vit = v.begin() + 3;
v.insert(vit, 999);//在vit位置插入999
v.erase(vit);//删除vit 位置的数据
for (vit = v.begin(); vit != v.end(); vit++) {
	printf("%d", *vit);
}
int row = 5;
int col = 6;
vector<vector<int>> n(row);//n是一个模板类，表示一个模板数组
for (int i = 0; i < n.size(); i++) {
	n[i].resize(col);
} 
for (int i = 0; i < n.size(); i++) {
	for (int j = 0; j < n[j].size(); j++) {
		n[i][j] = i * col + j + 1;
	}
}
for (int i = 0; i < n.size(); i++) {
	for (int j = 0; j < n[i].size(); j++) {
		printf("%d\t", n[i][j]);
	}
}

return 0;

}

(1)头文件#include.

(2)创建vector对象，vector vec;

(3)尾部插入数字：vec.push_back(a);

(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。

(6)插入元素： vec.insert(vec.begin()+i,a);在第i个元素后面插入a;

(7)删除元素： vec.erase(vec.begin()+2);删除第3个元素

vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始

(8)向量大小:vec.size();

(9)清空:vec.clear()　　　//清空之后，vec.size()为０

1. 使用reverse将元素翻转：需要头文件#include

   reverse(vec.begin(),vec.end());将元素翻转(在vector中，如果一个函数中需要两个迭代器，

   一般后一个都不包含.)

(2)使用sort排序：需要头文件#include，

sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

可以通过重写排序比较函数按照降序比较，如下：

定义排序比较函数：

bool Comp(const int &a,const int &b)
{
return a>b;
}
调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

vector所占用的内存只会增加不会减少，即使将数组后面的元素删除

deque：双向开口的连续空间（双向队列）

1、头尾开放，能够在头尾进行快速的插入和删除

2、支持随机存取

3、在中间段部分插入，删除元素速度相对较慢

#include
#include
using namespace std;
int main() {
deque d;
for (int i = 0; i < 10; i++) {
d.push_back(i + 1);
}
for (int j = 0; j < 10; j++) {
d.push_front((j + 1) * 10);//从头部插入
}
deque::iterator dit;
for (dit = d.begin(); dit != d.end(); dit++) {
printf("%d\t", *dit);
}
deque c1(d);
return 0;
}
//使用deque的具体情况
//1、需要做队列，需要在一个数据结构的头尾部进行不断地数据插入

list：双向链表

1、不支持随机的存取

2、插入和删除动作不会导致指向其他元素的各个指针，迭代器，引用失效。

3、在任何位置上插入和引用都很快

#include
#include
using namespace std;
bool isbase(int val) {
return val % 2 != 0;
}
bool ismax(int a, int b) {
return a > b;
}
int main() {
list mylist;
for (int i = 0; i < 10; i++) {
mylist.push_back(i + 1);
}
for (int j = 0; j < 5; j++) {
mylist.push_front((j + 1) * 10);
}

mylist.remove(1);//删除链表中所有值为1的函数
mylist.remove_if(isbase);//把list双向链表中的所有元素传入到函数中，如果函数的返回值 为true，则删除该元素
mylist.unique();//如果存在若干相邻的重复元素，则删除重复元素，保留一个
mylist.unique(ismax);//如果存在若干元素都使的iamax函数的返回值为ture，则删除其他元素，保留第一个元素
list<int> ::iterator lit;
for (lit = mylist.begin(); lit != mylist.end(); lit++) {
	printf("%d/t", *lit);
}

list<int> mylist1;
mylist.splice(lit, mylist1);//将mylist1中的所有元素移到mylist中，lit之后
mylist.sort(ismax);//按照ismax的准则进行排序
mylist.merge(mylist1);//将mylist与mylist1合并，要求两个链表已经进行过排序，排序准则相同
return 0;

}

list() 声明一个空列表；

list(n) 声明一个有n个元素的列表，每个元素都是由其默认构造函数T()构造出来的

list(n,val) 声明一个由n个元素的列表，每个元素都是由其复制构造函数T(val)得来的

list(n,val) 声明一个和上面一样的列表

list(first,last) 声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素

begin()和end()：**通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator，可以调用list容器的 end() 函数来得到list末端下一位置，相当于：int a[n]中的第n+1个位置a[n]，实际上是不存在的，不能访问，经常作为循环结束判断结束条件使用。

push_back() 和push_front()：****使用list的成员函数push_back和push_front插入一个元素到list中。其中push_back()从list的末端插入，而 push_front()实现的从list的头部插入。

resize()：****** 如果调用resize(n)将list的长度改为只容纳n个元素，超出的元素将被删除，如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val)，则扩展元素要调用构造函数T(val)函数进行元素构造，其余部分相同

****swap()：****交换两个链表(两个重载)，一个是l1.swap(l2); 另外一个是swap(l1,l2)，都可能完成连个链表的交换

map：二叉查找树结构

1、map将key/value当作元素，进行管理。可根据key的排序准则自动将元素排序

#include

1、key/value必须及v被可赋值和可复制的性质

2、对于排序而言，key必须是可比较的

3、map根据元素的key自动对元素进行排序，根据已知key搜索元素是性能较高，根据已知元素进行搜索时较低。

#include
#include

using namespace std;

int main() {
map<int, string> m;//该种形式key可以重复
m[1] = “陈宇航”;//key为6值为“陈宇航”
m[2] = “list”;//
m.insert(make_pair(1, “abc”));//插入元素
printf("%d", m.count(1));//输出key为1的元素位置
m.find(1);
map<int, string>::iterator mit;
for (mit = m.begin(); mit!=m.end(); mit++) {
printf(“key =%d\t， val=%s\n”, (*mit).first, (*mit).second.c_str());
}
multimap<int, double,greater> mul;//把key降序排列，默认为升序排列
mul.insert(make_pair(1, 3.14));
mul.insert(make_pair(1, 99));//该种形式key可以重复
return 0;
}

begin() 返回指向map头部的迭代器

clear(） 删除所有元素

count() 返回指定元素出现的次数

empty() 如果map为空则返回true

end() 返回指向map末尾的迭代器

equal_range() 返回特殊条目的迭代器对

erase() 删除一个元素

find() 查找一个元素

get_allocator() 返回map的配置器

insert() 插入元素

key_comp() 返回比较元素key的函数

lower_bound() 返回键值>=给定元素的第一个位置

max_size() 返回可以容纳的最大元素个数

rbegin() 返回一个指向map尾部的逆向迭代器

rend() 返回一个指向map头部的逆向迭代器

size() 返回map中元素的个数

swap() 交换两个map

upper_bound() 返回键值>给定元素的第一个位置

value_comp() 返回比较元素value的函数