C++容器（一）

C++中为了方便使用，引入了容器这个概念，容器的本质是一个类模板，可以存放任意类型的数据，而为了能操作类中的数据，又不破坏封装性，采用迭代器来访问类中的成员，同时还提供泛型算法，提高编程效率。简单来说，算法通过迭代器来对容器内的数据进行处理。

容器分为顺序容器、关联容器、容器适配器，今天主要说顺序容器。

顺序容器中又有三个容器，分别是vector（矢量容器）、list（双向链表容器）、deque（双端队列容器），vector容器的本质是一个数组，list可以看成是一个双向循环链表，deque可以看成是一个双端队列。

vector容器

vector容器的优点：尾部快速插入删除元素，直接访问任意元素
vector容器的缺点：按位置插入删除时间复杂度高

#include <vector>
template<typename Iterator>
void Show(Iterator first,Iterator last)
{
	for(first; first != last; first++)
	{
		std::cout<< *first << " ";
	}
	std::cout << std::endl;
}
int main()
{
	std::vector<int> vec1(10);     //创建10个int型大小的空间
	std::vector<int> vec2(10,2);      //创建10个int型大小的空间，并用2进行初始化
	int arr[] = {1,2,3,4,5,6,7,8,9,10};      
	int len = sizeof(arr)/sizeof(arr[0])
	std::vector<int> vec3(arr, arr + len);      //传入数组的起始地址和结尾地址，并用数组中的数据初始化
 	Show(vec1.begin(),vec1.end());         //vec1.begin() 表示vec1的首元素
	Show(vec2.begin(),vec2.end());
	Show(vec3.begin(),vec3.end())；
}
//vector容器中常用的函数：
//vec1.begin()   容器中首元素
//vec1.end()   容器中最后一个元素的下一个位置
//vec1.size()  当前元素所占的大小
//vec1.max_size() 最大可插入元素个数
//vec1.push_back()   尾插
//vec1.pop_back()    尾删
//vec1.erase()    按位置删

运行结果如下：

list容器

list容器的优点：头插、尾插，按位置插入删除时间复杂度低
list容器的缺点：访问慢

//list容器     迭代器：双向迭代器（只能++，--     不能+i，-i）
#include <iostream>
#include <iterator>
#include <list>

template <typename Iterator>
void Show(Iterator first,Iterator last)
{
	while(first != last)
	{
		std::cout << *first << " ";
		first ++;
	}
	std::cout << std::endl;
}
int main()
{
	std::list<int> lst1(10);
	std::list<int> lst2(10,20);
	
	int arr[] = {12,34,56,78,9,10};
	int len = sizeof(arr)/sizeof(arr[0]);
	std::list<int> lst3(arr,arr+len);
	Show(lst1.begin(),lst1.end());

	Show(lst2.begin(),lst2.end());
	Show(lst3.begin(),lst3.end());

	std::list<int> lst4(1);
	lst4.push_back(100);
	Show(lst4.begin(),lst4.end());
	lst4.push_front(200);
	Show(lst4.begin(),lst4.end());
	lst4.pop_back();
	Show(lst4.begin(),lst4.end());
	lst4.pop_front();
	Show(lst4.begin(),lst4.end());

	lst3.sort();          //对lst3进行排序     此处不能使用泛型算法库中的sort，因为list的迭代器是双
						 //向迭代器，不能进型+i -i的访问（只能使用list类中提供的sort函数）
	Show(lst3.begin(),lst3.end());  
	return 0;
}

运行结果如下：

deque容器

deque容器优点：头插头删，尾插尾删，访问，时间复杂度为o(1)
deque容器缺点：按位置插入删除时间复杂度为o(n)

template<typename Iterator>
void Show(Iterator first,Iterator last)
{
	while(first != last)
	{
		std::cout<< *first << " ";
		first ++;
	}
	std::cout<< std::endl;
}

int main()
{
	std::deque<int> dq1(10);
	std::deque<int> dq2(10,20);

	int arr[] = {12,34,56,78,90,100};
	int len = sizeof(arr)/sizeof(arr[0]);
	std::deque<int> dq3(arr,arr + len);

	Show(dq1.begin(),dq1.end());
	Show(dq2.begin(),dq2.end());
	Show(dq3.begin(),dq3.end());

	std::deque<int> dq4;
	for(int i = 5; i > 0;i--)
	{
		dq4.push_back(i);
	}
	Show(dq4.begin(),dq4.end());
	sort(dq4.begin(),dq4.end());           //用泛型算法库中的函数对dq4进行排序
	Show(dq4.begin(),dq4.end());

	dq4.erase(dq4.begin()+2);         //按位置删除
	Show(dq4.begin(),dq4.end());
	dq4.insert(dq4.begin()+2,20);   //按位置插入
	Show(dq4.begin(),dq4.end());
	return 0;
}

运行结果如下：

deque容器的扩容：
上端扩容：
deque容器底层有一个指针数组的映射区，保存数据区的地址。每个指针所指向的内存区域大小相同。刚开始，数组中有两个指针，记作p0，p1，deque的两个指针刚开始指向数据区的中间，随着不停的头插操作，头指针移动到内存区域第一个元素的前面时进行扩容操作，首先判断数组中 p0 的前面是否有指针，如果有，则在 p0 的前面开辟同样大小的空间，并将头指针移动到新开辟区域的尾部；如果没有，判断 p0 后面是否有空间，如果有则将 p1 = p0，让 p0 指向新开辟的内存将头指针指向新开辟空间的尾部。
下端扩容：
与上端扩容刚好相反，先判断p0指针后面是否有指针…再判断p0指针前面是否有指针 …