牛刀小试7

内容

vector的时间复杂度？ vector尾部插入怎么写？

写在前面

• vector 属于STL 中的一个容器，STL（标准模板库Standard Template Library）是C++标准程序库。其中包含4个组件，分别为算法、容器、函数、迭代器。模板是C++程序设计语言中的一个重要特征，而标准模板库正是基于此特征。标准模板库使得C++编程语言在有了同Java一样强大的类库的同时，保有了更大的可扩展性。
  在C++标准中，STL被组织为下面的13个头文件：

<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、
<map>、<memory>、<numeric>、<queue>、<set>、<stack>和<utility>

STL六大组件简介（了解内容）

STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。

• 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。

• 算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte.

• 迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++,operator–等指针相关操作予以重载的class template. 所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。

• 仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template

• 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。

• 空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte.

STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。

三大组件介绍（了解内容）

1.容器
几乎可以说，任何特定的数据结构都是为了实现某种特定的算法。STL容器就是将运用最广泛的一些数据结构实现出来。
常用的数据结构：数组(array) , 链表(list), tree(树)，栈(stack), 队列(queue), 集合(set),映射表(map), 根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种。
序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。Set/multiset容器 Map/multimap容器。
2. 算法
算法，问题的解法，以有限的步骤，解决逻辑或数学上的问题。
我们所编写的每个程序都是一个算法，其中的每个函数也都是一个算法，毕竟它们都是用来解决或大或小的逻辑问题或数学问题。STL收录的算法经过了数学上的效能分析与证明，是极具复用价值的，包括常用的排序，查找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。

算法分为:质变算法和非质变算法。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

3.迭代器
迭代器(iterator)是一种抽象的设计概念，现实程序语言中并没有直接对应于这个概念的实物。 在<>一书中提供了23种设计模式的完整描述， 其中iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

迭代器的设计思维-STL的关键所在，STL的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。

从技术角度来看，容器和算法的泛型化并不困难，c++的class template和function template可分别达到目标，如果设计出两这个之间的良好的胶着剂，才是大难题。

• 代码理解

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

//STL 中的容器 算法 迭代器
void test01(){
	vector<int> v; //STL 中的标准容器之一 ：动态数组
	v.push_back(1); //vector 容器提供的插入数据的方法
	v.push_back(5);
	v.push_back(3);
	v.push_back(7);
	//迭代器
	vector<int>::iterator pStart = v.begin(); //vector 容器提供了 begin()方法 返回指向第一个元素的迭代器
	vector<int>::iterator pEnd = v.end(); //vector 容器提供了 end()方法 返回指向最后一个元素下一个位置的迭代器
	//通过迭代器遍历
	while (pStart != pEnd){
		cout << *pStart << " ";
		pStart++;
	}
	cout << endl;
	//算法 count 算法 用于统计元素的个数
	int n = count(pStart, pEnd, 5);
	cout << "n:" << n << endl;
}
//STL 容器不单单可以存储基础数据类型，也可以存储类对象
class Teacher
{
public:
	Teacher(int age) :age(age){};
	~Teacher(){};
public:
	int age;
};
void test02(){
	vector<Teacher> v; //存储 Teacher 类型数据的容器
	Teacher t1(10), t2(20), t3(30);
	v.push_back(t1);
	v.push_back(t2);
	v.push_back(t3);
	vector<Teacher>::iterator pStart = v.begin();
	vector<Teacher>::iterator pEnd = v.end();
	//通过迭代器遍历
	while (pStart != pEnd){
		cout << pStart->age << " ";
		pStart++;
	}
	cout << endl;
}
//存储 Teacher 类型指针
void test03(){
	vector<Teacher*> v; //存储 Teacher 类型指针
	Teacher* t1 = new Teacher(10);
	Teacher* t2 = new Teacher(20);
	Teacher* t3 = new Teacher(30);
	v.push_back(t1);
	v.push_back(t2);
	v.push_back(t3);
	//拿到容器迭代器
	vector<Teacher*>::iterator pStart = v.begin();
	vector<Teacher*>::iterator pEnd = v.end();
	//通过迭代器遍历
	while (pStart != pEnd){
		cout << (*pStart)->age << " ";
		pStart++;
	}
	cout << endl;
}
//容器嵌套容器 难点
void test04()
{
	vector< vector<int> > v;
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;

	for (int i = 0; i < 5;i++)
	{
		v1.push_back(i);
		v2.push_back(i * 10);
		v3.push_back(i * 100);
	}
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);

	for (vector< vector<int> >::iterator it = v.begin(); it != v.end();it++)
	{
		for (vector<int>::iterator subIt = (*it).begin(); subIt != (*it).end(); subIt ++)
		{
			cout << *subIt << " ";
		}
		cout << endl;
	}
} 
int main(){
	//test01();
	//test02();
	//test03();
	test04();
	system("pause");
	return EXIT_SUCCESS;
}

常用容器

• string 容器
  string容器基本概念
  C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类，定义在头文件。
  String和c风格字符串对比：

  • Char是一个指针，String是一个类：string封装了char，管理这个字符串，是一个char*型的容器。

  • String封装了很多实用的成员方法：查找find，拷贝copy，删除delete 替换replace，插入insert

  • 不用考虑内存释放和越界：string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。
    string容器常用操作

    string 构造函数
    
    string();//创建一个空的字符串 例如: string str;      
    string(const string& str);//使用一个string对象初始化另一个string对象
    string(const char* s);//使用字符串s初始化
    string(int n, char c);//使用n个字符c初始化 
    
    string基本赋值操作
    
    string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串
    string& operator=(const string &s);//把字符串s赋给当前的字符串
    string& operator=(char c);//字符赋值给当前的字符串
    string& assign(const char *s);//把字符串s赋给当前的字符串
    string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
    string& assign(const string &s);//把字符串s赋给当前字符串
    string& assign(int n, char c);//用n个字符c赋给当前字符串
    string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
    
    string存取字符操作
    
    char& operator[](int n);//通过[]方式取字符
    char& at(int n);//通过at方法获取字符
    
    string拼接操作
    
    string& operator+=(const string& str);//重载+=操作符
    string& operator+=(const char* str);//重载+=操作符
    string& operator+=(const char c);//重载+=操作符
    string& append(const char *s);//把字符串s连接到当前字符串结尾
    string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
    string& append(const string &s);//同operator+=()
    string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
    string& append(int n, char c);//在当前字符串结尾添加n个字符c
    
    string查找和替换
    
    int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
    int find(const char* s, int pos = 0) const;  //查找s第一次出现位置,从pos开始查找
    int find(const char* s, int pos, int n) const;  //从pos位置查找s的前n个字符第一次位置
    int find(const char c, int pos = 0) const;  //查找字符c第一次出现位置
    int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找
    int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
    int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置
    int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
    string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
    string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
    
    string比较操作
    
    /*
    compare函数在>时返回 1，<时返回 -1，==时返回 0。
    比较区分大小写，比较时参考字典顺序，排越前面的越小。
    大写的A比小写的a小。
    */
    int compare(const string &s) const;//与字符串s比较
    int compare(const char *s) const;//与字符串s比较
    
    string子串
    
    string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
    
    string插入和删除操作
    
    string& insert(int pos, const char* s); //插入字符串
    string& insert(int pos, const string& str); //插入字符串
    string& insert(int pos, int n, char c);//在指定位置插入n个字符c
    string& erase(int pos, int n = npos);//删除从Pos开始的n个字符 
    
    string和c-style字符串转换
    
    //string 转 char*
    string str = "it";
    const char* cstr = str.c_str();
    //char* 转 string 
    char* s = "it";
    string str(s);
    
    在c++中存在一个从const char*到string的隐式类型转换，却不存在从一个string对象到C_string的自动类型转换。对于string类型的字符串，可以通过c_str()函数返回string对象对应的C_string.
    
    通常，程序员在整个程序中应坚持使用string类对象，直到必须将内容转化为char*时才将其转换为C_string.
    
    为了修改string字符串的内容，下标操作符[]和at都会返回字符的引用。但当字符串的内存被重新分配之后，可能发生错误.
    
    string s = "abcdefg";
    	char& a = s[2];
    	char& b = s[3];
    
    	a = '1';
    	b = '2';
    
    	cout << s << endl;
    	cout << (int*)s.c_str() << endl;
    
    	s = "pppppppppppppppppppppppp";
    
    	//a = '1';
    	//b = '2';
    
    	cout << s << endl;
    	cout << (int*)s.c_str() << endl;
    

1. vector 容器
   string容器基本概念
   ector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。
   
   Array是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，可以，一切琐碎得由自己来，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。
   
   Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必害怕空间不足而一开始就要求一个大块头的array了。
   
   Vector的实现技术，关键在于其对大小的控制以及重新配置时的数据移动效率，一旦vector旧空间满了，如果客户每新增一个元素，vector内部只是扩充一个元素的空间，实为不智，因为所谓的扩充空间(不论多大)，一如刚所说，是”配置新空间-数据移动-释放旧空间”的大工程,时间成本很高，应该加入某种未雨绸缪的考虑，稍后我们便可以看到vector的空间配置策略。
   
   vector迭代器

```c
Vector<int>::iterator it1;
Vector<Teacher>::iterator it2;
//it1的型别其实就是Int*,it2的型别其实就是Teacher*.

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;

int main(){
	vector<int> v;
	for (int i = 0; i < 10;i ++){
		v.push_back(i);
		cout << v.capacity() << endl;  // v.capacity()容器的容量
	}
	system("pause");
	return EXIT_SUCCESS;
}
```
**vector的数据结构**

Vector所采用的数据结构非常简单，线性连续空间，它以两个迭代器_Myfirst和_Mylast分别指向配置得来的连续空间中目前已被使用的范围，并以迭代器_Myend指向整块连续内存空间的尾端。

为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求大一些，以备将来可能的扩充，这边是容量的概念。换句话说，一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector容器就得另觅居所。

所谓动态增加大小，并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间)，而是一块更大的内存空间，然后将原数据拷贝新空间，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。这是程序员容易犯的一个错误，务必小心。

vector常用API操作

```c
//vector构造函数
vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。


//例子 使用第二个构造函数 我们可以...
int arr[] = {2,3,4,1,9};
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int)); 


//vector常用赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector  &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。


//vector大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。


//vector数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素


//vector插入和删除操作
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素


//vector 小demo: 巧用swap，收缩内存空间
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;

int main(){

	vector<int> v;
	for (int i = 0; i < 100000;i ++){
		v.push_back(i);
	}

	cout << "capacity:" << v.capacity() << endl;
	cout << "size:" << v.size() << endl;

	//此时 通过resize改变容器大小
	v.resize(10);

	cout << "capacity:" << v.capacity() << endl;
	cout << "size:" << v.size() << endl;

	//容量没有改变
	vector<int>(v).swap(v);

	cout << "capacity:" << v.capacity() << endl;
	cout << "size:" << v.size() << endl;


	system("pause");
	return EXIT_SUCCESS;
}

//reserve预留空间
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;

int main(){

	vector<int> v;

	//预先开辟空间
	v.reserve(100000);

	int* pStart = NULL;
	int count = 0;
	for (int i = 0; i < 100000;i ++){
		v.push_back(i);
		if (pStart != &v[0]){
			pStart = &v[0];
			count++;
		}
	}

	cout << "count:" << count << endl;

	system("pause");
	return EXIT_SUCCESS;
}
```

2. deque容器

3. deque容器基本概念
   Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。
   
   Deque容器和vector容器最大的差异，一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector那样，”旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间”这样的事情在deque身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能.
   
   虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque.

4. deque容器实现原理
   Deque容器是连续的空间，至少逻辑上看来如此，连续现行空间总是令我们联想到array和vector,array无法成长，vector虽可成长，却只能向尾端成长，而且其成长其实是一个假象，事实上(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间 三步骤，如果不是vector每次配置新的空间时都留有余裕，其成长假象所带来的代价是非常昂贵的。
   
   Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间，便配置一段连续定量的空间，串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。
   
   既然deque是分段连续内存空间，那么就必须有中央控制，维持整体连续的假象，数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。
   
   Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque的存储空间的主体。

5. deque常用API

   //deque构造函数
   deque<T> deqT;//默认构造形式
   deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
   deque(n, elem);//构造函数将n个elem拷贝给本身。
   deque(const deque &deq);//拷贝构造函数。
   
   //deque赋值操作
   assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
   assign(n, elem);//将n个elem拷贝赋值给本身。
   deque& operator=(const deque &deq); //重载等号操作符 
   swap(deq);// 将deq与本身的元素互换
   
   //deque大小操作
   deque.size();//返回容器中元素的个数
   deque.empty();//判断容器是否为空
   deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
   deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。
   
   //deque双端插入和删除操作
   push_back(elem);//在容器尾部添加一个数据
   push_front(elem);//在容器头部插入一个数据
   pop_back();//删除容器最后一个数据
   pop_front();//删除容器第一个数据
   
   //deque数据存取
   at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
   operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
   front();//返回第一个数据。
   back();//返回最后一个数据
   
   //deque插入操作
   insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
   insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
   insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
   
   //deque删除操作
   clear();//移除容器的所有数据
   erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
   erase(pos);//删除pos位置的数据，返回下一个数据的位置。
   

6. stack容器
   stack容器基本概念
   stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历行为。
   有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.
   
   stack没有迭代器
   Stack所有元素的进出都必须符合”先进后出”的条件，只有stack顶端的元素，才有机会被外界取用。Stack不提供遍历功能，也不提供迭代器。
   
   stack常用API

   //stack构造函数
   stack<T> stkT;//stack采用模板类实现， stack对象的默认构造形式： 
   stack(const stack &stk);//拷贝构造函数
   
   //stack赋值操作
   stack& operator=(const stack &stk);//重载等号操作符
   
   //stack数据存取操作
   push(elem);//向栈顶添加元素
   pop();//从栈顶移除第一个元素
   top();//返回栈顶元素
   
   //stack大小操作
   empty();//判断堆栈是否为空
   size();//返回堆栈的大小
   

7. queue容器
   queue容器基本概念
   Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素。
   
   queue没有迭代器
   Queue所有元素的进出都必须符合”先进先出”的条件，只有queue的顶端元素，才有机会被外界取用。Queue不提供遍历功能，也不提供迭代器。
   
   queue常用API

   //queue构造函数
   queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：
   queue(const queue &que);//拷贝构造函数
   
   //queue存取、插入和删除操作
   push(elem);//往队尾添加元素
   pop();//从队头移除第一个元素
   back();//返回最后一个元素
   front();//返回第一个元素
   
   //queue赋值操作
   queue& operator=(const queue &que);//重载等号操作符
   queue大小操作
   
   empty();//判断队列是否为空
   size();//返回队列的大小
   

8. list容器
   list容器基本概念
   链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
   
   相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。
   
   List和vector是两个最常被使用的容器。
   
   采用动态存储分配，不会造成内存浪费和溢出
   
   链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
   
   链表灵活，但是空间和时间额外耗费较大
   
   list容器的数据结构
   List容器是一个循环的双向链表。

   #define _CRT_SECURE_NO_WARNINGS
   #include<iostream>
   #include<list>
   using namespace std;
   
   int main(){
   
   	list<int> myList;
   	for (int i = 0; i < 10; i ++){
   		myList.push_back(i);
   	}
   	list<int>::_Nodeptr node =  myList._Myhead->_Next;
   
   	for (int i = 0; i < myList._Mysize * 2;i++){
   		cout << "Node:" << node->_Myval << endl;
   		node = node->_Next;
   		if (node == myList._Myhead){
   			node = node->_Next;
   		}
   	}
   	system("pause");
   	return EXIT_SUCCESS;
   }
   

   list常用API

   //list构造函数
   list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
   list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
   list(n,elem);//构造函数将n个elem拷贝给本身。
   list(const list &lst);//拷贝构造函数。
   
   //list数据元素插入和删除操作
   push_back(elem);//在容器尾部加入一个元素
   pop_back();//删除容器中最后一个元素
   push_front(elem);//在容器开头插入一个元素
   pop_front();//从容器开头移除第一个元素
   insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
   insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
   insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
   clear();//移除容器的所有数据
   erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
   erase(pos);//删除pos位置的数据，返回下一个数据的位置。
   remove(elem);//删除容器中所有与elem值匹配的元素。
   
   //list大小操作
   size();//返回容器中元素的个数
   empty();//判断容器是否为空
   
   resize(num);//重新指定容器的长度为num，
   //若容器变长，则以默认值填充新位置。
   //如果容器变短，则末尾超出容器长度的元素被删除。
   
   resize(num, elem);//重新指定容器的长度为num，
   //若容器变长，则以elem值填充新位置。
   //如果容器变短，则末尾超出容器长度的元素被删除。
   
   //list赋值操作
   assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
   assign(n, elem);//将n个elem拷贝赋值给本身。
   list& operator=(const list &lst);//重载等号操作符
   swap(lst);//将lst与本身的元素互换。
   
   //list数据的存取
   front();//返回第一个元素。
   back();//返回最后一个元素。
   
   //list反转排序
   reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
   sort(); //list排序
   

9. set/multiset容器容器
   set容器基本概念
   Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值。
   
   我们不可以通过set的迭代器改变set元素的值，因为set元素值就是其键值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator.
   
   set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。
   
   multiset容器基本概念
   multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树.
   
   set常用API

   //set构造函数
   set<T> st;//set默认构造函数：
   mulitset<T> mst; //multiset默认构造函数: 
   set(const set &st);//拷贝构造函数
   
   //set赋值操作
   set& operator=(const set &st);//重载等号操作符
   swap(st);//交换两个集合容器
   
   //set大小操作
   size();//返回容器中元素的数目
   empty();//判断容器是否为空
   
   //set插入和删除操作
   insert(elem);//在容器中插入元素。
   clear();//清除所有元素
   erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
   erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
   erase(elem);//删除容器中值为elem的元素。
   
   //set查找操作
   find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
   count(key);//查找键key的元素个数
   lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
   upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
   equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
   
   //set的返回值 指定set排序规则举例:
   
   //插入操作返回值
   void test01(){
   	set<int> s;
   	pair<set<int>::iterator,bool> ret = s.insert(10);
   	if (ret.second){
   		cout << "插入成功:" << *ret.first << endl;
   	}
   	else{
   		cout << "插入失败:" << *ret.first << endl;
   	}
   	
   	ret = s.insert(10);
   	if(ret.second){
   		cout << "插入成功:" << *ret.first << endl;
   	}
   	else{
   		cout << "插入失败:" << *ret.first << endl;
   	}
   
   }
   
   struct MyCompare02{
   	bool operator()(int v1,int v2){
   		return v1 > v2;
   	}
   };
   
   //set从大到小
   void test02(){
   	srand((unsigned int)time(NULL));
   	//我们发现set容器的第二个模板参数可以设置排序规则，默认规则是less<_Kty>
   	set<int, MyCompare02> s;
   	for (int i = 0; i < 10;i++){
   		s.insert(rand() % 100);
   	}
   	for (set<int, MyCompare02>::iterator it = s.begin(); it != s.end(); it ++){
   		cout << *it << " ";
   	}
   	cout << endl;
   }
   
   //set容器中存放对象
   class Person{
   public:
   	Person(string name,int age){
   		this->mName = name;
   		this->mAge = age;
   	}
   public:
   	string mName;
   	int mAge;
   };
   
   
   struct MyCompare03{
   	bool operator()(const Person& p1,const Person& p2){
   		return p1.mAge > p2.mAge;
   	}
   };
   
   void test03(){
   
   	set<Person, MyCompare03> s;
   
   	Person p1("aaa", 20);
   	Person p2("bbb", 30);
   	Person p3("ccc", 40);
   	Person p4("ddd", 50);
   
   	s.insert(p1);
   	s.insert(p2);
   	s.insert(p3);
   	s.insert(p4);
   
   	for (set<Person, MyCompare03>::iterator it = s.begin(); it != s.end(); it++){
   		cout << "Name:" << it->mName << " Age:" << it->mAge << endl;
   	}
   }
   

   对组(pair)
   对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。类模板：template <class T1, class T2> struct pair.

   创建对组:
   //第一种方法创建一个对组
   pair<string, int> pair1(string("name"), 20);
   cout << pair1.first << endl; //访问pair第一个值
   cout << pair1.second << endl;//访问pair第二个值
   //第二种
   pair<string, int> pair2 = make_pair("name", 30);
   cout << pair2.first << endl;
   cout << pair2.second << endl;
   //pair=赋值
   pair<string, int> pair3 = pair2;
   cout << pair3.first << endl;
   cout << pair3.second << endl;
   

10. map/multimap容器
    map/multimap基本概念
    Map的特性是，所有元素都会根据元素的键值自动排序。
    
    Map所有的元素都是pair,同时拥有实值和键值，pair的第一元素被视为键值，第二元素被视为实值，map不允许两个元素有相同的键值。
    
    我们不可以通过map的迭代器改变map的键值, 因为map的键值关系到map元素的排列规则，任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的。
    
    Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
    
    Multimap和map的操作类似，唯一区别multimap键值可重复。
    
    Map和multimap都是以红黑树为底层实现机制。
    
    map/multimap常用API

```c
//map构造函数
map<T1, T2> mapTT;//map默认构造函数: 
map(const map &mp);//拷贝构造函数

//map赋值操作
map& operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器

//map大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空

//map插入数据元素操作
map.insert(...); //往容器插入元素，返回pair<iterator,bool>
map<int, string> mapStu;
// 第一种 通过pair的方式插入对象
mapStu.insert(pair<int, string>(3, "小张"));
// 第二种 通过pair的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过value_type的方式插入对象
mapStu.insert(map<int, string>::value_type(1, "小李"));
// 第四种 通过数组的方式插入值
mapStu[3] = "小刘";
mapStu[5] = "小王";

//map删除操作

clear();//删除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中key为keyElem的对组。

//map查找操作

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end();
count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

//multimap案例

//公司今天招聘了5个员工，5名员工进入公司之后，需要指派员工在那个部门工作
//人员信息有: 姓名 年龄 电话 工资等组成
//通过Multimap进行信息的插入 保存 显示
//分部门显示员工信息 显示全部员工信息

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>
#include<map>
#include<string>
#include<vector>
using namespace std;

//multimap 案例
//公司今天招聘了 5 个员工，5 名员工进入公司之后，需要指派员工在那个部门工作
//人员信息有: 姓名 年龄 电话 工资等组成
//通过 Multimap 进行信息的插入 保存 显示
//分部门显示员工信息 显示全部员工信息


#define SALE_DEPATMENT 1 //销售部门
#define DEVELOP_DEPATMENT 2 //研发部门
#define FINACIAL_DEPATMENT 3 //财务部门
#define ALL_DEPATMENT 4 //所有部门

//员工类
class person{
public:
	string name; //员工姓名
	int age; //员工年龄
	double salary; //员工工资
	string tele; //员工电话
};

//创建5个员工
void CreatePerson(vector<person>& vlist){

	string seed = "ABCDE";
	for (int i = 0; i < 5; i++){
		person p;
		p.name = "员工";
		p.name += seed[i];
		p.age = rand() % 30 + 20;
		p.salary = rand() % 20000 + 10000;
		p.tele = "010-8888888";
		vlist.push_back(p);
	}

}

//5名员工分配到不同的部门
void PersonByGroup(vector<person>& vlist, multimap<int, person>& plist){
	int operate = -1; //用户的操作

	for (vector<person>::iterator it = vlist.begin(); it != vlist.end(); it++){

		cout << "当前员工信息:" << endl;
		cout << "姓名：" << it->name << " 年龄:" << it->age << " 工资:" << it->salary << " 电话：" << it->tele << endl;
		cout << "请对该员工进行部门分配(1 销售部门, 2 研发部门, 3 财务部门):" << endl;
		scanf("%d", &operate);

		while (true){

			if (operate == SALE_DEPATMENT){  //将该员工加入到销售部门
				plist.insert(make_pair(SALE_DEPATMENT, *it));
				break;
			}
			else if (operate == DEVELOP_DEPATMENT){
				plist.insert(make_pair(DEVELOP_DEPATMENT, *it));
				break;
			}
			else if (operate == FINACIAL_DEPATMENT){
				plist.insert(make_pair(FINACIAL_DEPATMENT, *it));
				break;
			}
			else{
				cout << "您的输入有误，请重新输入(1 销售部门, 2 研发部门, 3 财务部门):" << endl;
				scanf("%d", &operate);
			}

		}

	}
	cout << "员工部门分配完毕!" << endl;
	cout << "***********************************************************" << endl;

}

//打印员工信息
void printList(multimap<int, person>& plist, int myoperate){

	if (myoperate == ALL_DEPATMENT){
		for (multimap<int, person>::iterator it = plist.begin(); it != plist.end(); it++){
			cout << "姓名：" << it->second.name << " 年龄:" << it->second.age << " 工资:" << it->second.salary << " 电话：" << it->second.tele << endl;
		}
		return;
	}

	multimap<int, person>::iterator it = plist.find(myoperate);
	int depatCount = plist.count(myoperate);
	int num = 0;
	if (it != plist.end()){
		while (it != plist.end() && num < depatCount){
			cout << "姓名：" << it->second.name << " 年龄:" << it->second.age << " 工资:" << it->second.salary << " 电话：" << it->second.tele << endl;
			it++;
			num++;
		}
	}
}

//根据用户操作显示不同部门的人员列表
void ShowPersonList(multimap<int, person>& plist, int myoperate){

	switch (myoperate)
	{
	case SALE_DEPATMENT:
		printList(plist, SALE_DEPATMENT);
		break;
	case DEVELOP_DEPATMENT:
		printList(plist, DEVELOP_DEPATMENT);
		break;
	case FINACIAL_DEPATMENT:
		printList(plist, FINACIAL_DEPATMENT);
		break;
	case ALL_DEPATMENT:
		printList(plist, ALL_DEPATMENT);
		break;
	}
}

//用户操作菜单
void PersonMenue(multimap<int, person>& plist){

	int flag = -1;
	int isexit = 0;
	while (true){
		cout << "请输入您的操作((1 销售部门, 2 研发部门, 3 财务部门, 4 所有部门, 0退出)：" << endl;
		scanf("%d", &flag);

		switch (flag)
		{
		case SALE_DEPATMENT:
			ShowPersonList(plist, SALE_DEPATMENT);
			break;
		case DEVELOP_DEPATMENT:
			ShowPersonList(plist, DEVELOP_DEPATMENT);
			break;
		case FINACIAL_DEPATMENT:
			ShowPersonList(plist, FINACIAL_DEPATMENT);
			break;
		case ALL_DEPATMENT:
			ShowPersonList(plist, ALL_DEPATMENT);
			break;
		case 0:
			isexit = 1;
			break;
		default:
			cout << "您的输入有误，请重新输入!" << endl;
			break;
		}

		if (isexit == 1){
			break;
		}
	}

}

int main(){

	vector<person>  vlist; //创建的5个员工 未分组
	multimap<int, person> plist; //保存分组后员工信息

	//创建5个员工
	CreatePerson(vlist);
	//5名员工分配到不同的部门
	PersonByGroup(vlist, plist);
	//根据用户输入显示不同部门员工信息列表 或者 显示全部员工的信息列表
	PersonMenue(plist);

	system("pause");
	return EXIT_SUCCESS;
}
```

------------------------------------------------------------------------------分割线-----------------------------------------------------------------------------------------

STL容器使用注意

在使用的过程中，需要考虑的问题有元素顺序、标准的一致性、迭代器能力、内存布局和C的兼容性、查找速度这些，考虑了这些问题你选择的容器应该会非常适合你当前的情景。

1. 需要大量添加新元素：
          vector在大量添加元素的时候问题最大，因为他的一种最常见的内存分配实现方法是当前的容量(capacity)不足就申请一块当前容量2倍的新内存空间，然后将所有的老元素全部拷贝到新内存中，添加大量元素的时候的花费的惊人的大。如果由于其他因素必须使用vector，并且还需要大量添加新元素，那么可以使用成员函数reserve来事先分配内存，这样可以减少很多不必要的消耗。
          list对这种情况的适应能力就非常好，都是常数时间的插入消耗。deque前面说过了，他是vector和list的折衷形式，内存不够了就申请一块新的内存，但并不拷贝老的元素。

2. 查找速度：
          这个因素主要取决于算法，而算法最终是作用在容器中元素上的，所以这里的查找速度指的是容器能够达到的最好查找效率。
          对于序列容器需要分两种情况，区分依据是元素是否排序，1)对于已经排序的序列容器，使用binary_search、lower_bound、upper_bound、equal_range可以获得对数时间复杂度的查找速度(O(logN));2)而未排序的序列容器二分查找肯定是用不了，能达到的最好的时间复杂度是线性的(O(n))。
          对于关联容器，存储的时候存储的是一棵红黑树(一种更为严格的平衡二叉树,文档最后有介绍)，总是能达到对数时间复杂度(O(logN))的效率，因为关联容器是按照键值排好序的。

3. 是否是连续内存：
          连续内存的容器有个明显的缺点，就是有新元素插入或老元素删除的时候，为了给新元素腾出位置或者填充老元素的空缺，同一块内存中的其他数据需要进行整体的移位，这种移位的拷贝代价有时是非常巨大的。标准容器中的vector、deque是连续内存的，其中vector是完全连续内存，而deque是vector和list的折衷实现，是多个内存块组成的，每个块中存放的元素连续内存，而内存块又像链表一样连接起来。所以需要考虑在操作的过程中是否有在任意位置插入元素的需求，有这种需求的话尽量避免使用连续内存的vector、deque

4. 元素的排序：
          序列容器中的元素不会自动排序，程序员插入什么顺序内存中就是什么顺序，而关联容器不是这样的，他会以自己的键值按照某种等价关系(equivalence)进行排序。所以默认情况下序列容器中的元素是无序的，而关联容器中的元素是有序的。
   所以容器在遍历元素的时候序列容器输出的顺序和插入的顺序式一致的，关联容器就不一定了。下面给出两个例子：
          通过例子看到序列容器vector遍历的顺序和插入的顺序是一样的，而关联容器set把插入的元素按照某种顺序重新组织了，所以选择容器的时候如果很在意插入顺序的话就选择序列容器。

5. 内存是否和C兼容：
          适合的容器只有一个vector，意思就是如果需要把容器中的数据放到C类型的数组中那么不需要做多余复杂的操作，如果有vector v，只需要直接使用&v[0]就可以得到v中第一个元素的指针，因为vector和C数组的内存布局是一样的，这个要求同时也是标准C++委员会制定的标准。所以能保证有这样特性的容器只有vector，那么vector以外的其他STL容器中的数据如果需要变换成C数组形式，或者C数组放到其他类型容器中，可以把vector作为一个桥梁，下面给个例子：

   //假设函数void read(const int* pInt, unsigned int num);
   
   //从pInt指针位置开始读取num个int型数据
   
   std::set<int> temp_set;
   
   ... //省略给temp_set插入元素的操作
   
   std::vector<int> temp_vector(temp_set.begin(), temp_set.end());
   
   if (!temp_vector.empty())
   
   read(&temp_vector[0], temp_vector.size());
   

总结

• 容器优缺点

• 用哪种容器的选择看起来非常繁琐，头脑中如果有个每个容器大概的模型，在选择的时候会更为轻松点。

  • Vector的数据模型就是数组。
    　优点：内存和C完全兼容、高效随机访问、节省空间　
    　缺点：内部插入删除元素代价巨大、动态大小查过自身容量需要申请大量内存做大量拷贝。

  • List 的数据结构模型是链表
    　优点：任意位置插入删除元素常量时间复杂度、两个容器融合是常量时间复杂度
    　缺点：不支持随机访问、比vector占用更多的存储空间

  • Deque的数据模型是数组和链表的折衷：
    　优点：高效随机访问、内部插入删除元素效率方便、两端push pop
    　缺点：内存占用比较高

  • Map、set、multimap、multiset的数据结构模型是二叉树(红黑树)
    　优点：元素会按照键值排序、查找是对数时间复杂度、通过键值查元素、map提供了下标访问

• 容器特性

容器类型	容器特性
vector	典型的序列容器，C++标准严格要求次容器的实现内存必须是连续的唯一可以和标准C兼容的stl容器，任意元素的读取、修改具有常数时间复杂度，在序列尾部进行插入、删除是常数时间复杂度，但在序列的头部插入、删除的时间复杂度是O(n)，可以 在任何位置插入新元素，有随机访问功能，插入删除操作需要考虑
deque	典型的序列容器，C++标准严格要求次容器的实现内存必须是连续的，唯一可以和标准C兼容的stl容器，任意元素的读取、修改具有常数时间复杂度，在序列尾部进行插入、删除是常数时间复杂度，但在序列的头部插入、删除的时间复杂度是O(n)，可以 在任何位置插入新元素，有随机访问功能，插入删除操作需要考虑
list	典型的序列容器，C++标准严格要求次容器的实现内存必须是连续的，唯一可以和标准C兼容的stl容器，任意元素的读取、修改具有常数时间复杂度，在序列尾部进行插入、删除是常数时间复杂度，但在序列的头部插入、删除的时间复杂度是O(n)，可以 在任何位置插入新元素，有随机访问功能，插入删除操作需要考虑
set	关联容器，元素不允许有重复，数据被组织成一棵红黑树，查找的速度非常快，时间复杂度是O(logN)
multiset	关联容器，和set一样，却别是允许有重复的元素，具备时间复杂度O(logN)查找功能。
map	关联容器，按照{键，值}方式组成集合，按照键组织成一棵红黑树，查找的时间复杂度O(logN)，其中键不允许重复
multimap	和map一样，区别是键可以重复

• 关键记忆点

  1） 如果需要随机访问，用vector

  2） 如果存储元素的数目已知，用vector

  3） 需要任意位置随机插入删除，用list

  4） 只有需要更多在容器的首部尾部插入删除元素，用deque

  5） 元素是复杂结构用list，也可以用vector存储指针(需要额外的精力去维护内存)，看需求

  6） 如果操作是基于键值，用set map

  7） 如果需要经常的搜索，用map set

  8） map set 的区别是map中的元素都是pair