C++_STL

字符串的构造函数创建一个新字符串，包括:
• 以length为长度的ch的拷贝（即length个ch）；
• 以str为初值 (长度任意)；
• 以index为索引开始的子串，长度为length, 或者
• 以从start到end的元素为初值.
例如,

string str1( 5, 'c' )；
string str2( "Now is the time..." )；
string str3( str2, 11, 4 )；

可以用 ==, >, <, >=, <=, and !=比较字符串. 可以用 + 或者 += 操作符连接两个字符串, 并且可以用[]获取特定的字符.
函数用法

1. 赋值(assign)
   语法:
   basic_string &assign( const basic_string &str );
   basic_string &assign( const char *str );
   basic_string &assign( const char *str, size_type num );
   basic_string &assign(const basic_string &str, size_type index, size_type len );
   basic_string &assign( size_type num, char ch );
   函数以下列方式赋值:
   •用str为字符串赋值；
   •用str的开始num个字符为字符串赋值；
   •用str的子串为字符串赋值,子串以index索引开始，长度为len。
   •用num个字符ch为字符串赋值.
   例如以下代码:

   string str1, str2 = “War and Peace”;
   str1.assign( str2, 4, 3 );
   2.push_back(char _CH): 向字符串尾部插入字符
   3.添加文本(append)
   语法:
   basic_string &append( const basic_string &str );
   basic_string &append( const char *str );
   basic_string &append( const basic_string &str, size_type index, size_type len );
   basic_string &append( const char *str, size_type num );
   basic_string &append( size_type num, char ch );
   basic_string &append( input_iterator start, input_iterator end );

append() 函数可以完成以下工作:
在字符串的末尾添加str,
在字符串的末尾添加str的子串,子串以index索引开始，长度为len；
在字符串的末尾添加str中的num个字符,
在字符串的末尾添加以迭代器start和end表示的字符序列.
例：str1.append(str2);
对字符串元素的访问[],at()
at（[]）
语法:
reference at( size_type index );
①我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效（有效索引0~str.length()），如果索引失效，会引起未定义的行为。而at()会检查，如果使用at()的时候索引无效，会抛出out_of_range异常。
比如下列代码:
string text = “ABCDEF”;
char ch = text.at( 2 );
显示字符 ‘C’.
迭代器的使用
1.iterator begin() :函数返回一个迭代器,得到指向字符串开头的iterator。（第一个元素）
2.Iterator end(): 函数返回一个迭代器,得到指向字符串结尾的iterator。（不是最后一个元素，不可访问）
3.Iterator rbegin() :函数返回一个迭代器,得到指向反向字符串开头的iterator。（最后一个元素。）
4.Iterator rend(): 函数返回一个迭代器,得到指向反向字符串结尾的iterator。（不是第一个元素，不可访问）
string的比较：
bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较；
int compare(const string &s) const;//比较当前字符串和s的大小
int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n,const char *s) const;
int compare(int pos, int n,const char *s, int pos2) const;
compare函数在>时返回1，<时返回-1，==时返回0
string的子串：
string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串
1.size_t size(): 得到字符串大小。（length()功能一样）
2.c_str(): 函数返回一个指向正规C字符串的指针, 内容与本字符串相同。
1.bool empty(): 判断字符串是否为空。(空为真，不为空为0)
2.clear(): 清空字符容器中所有内容。
3.erase():
①basic_string & erase(size_type pos=0, size_type n=npos);
即从给定起始位置pos处开始删除, 要删除字符的长度为n, 返回值修改后的string对象引用.
②iterator erase(const_iterator position)
删除迭代器位置处的单个字符, 并返回下个元素的迭代器

③iterator erase(const_iterator first, const_iterator last)
删除迭代器[first, last)区间的所有字符,返回一个指向被删除的最后一个元素的下一个字.
插入字符 insert()
语法:
string &insert(int p0, const char *s);
string &insert(int p0, const char *s, int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s, int pos, int n);
//前4个函数在p0位置插入字符串s中pos开始的前n个字符
string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符
void insert(iterator it, int n, char c);//在it处插入n个字符c
替换字符 replace()
string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串s
string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符
string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串s
string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符
string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符c
string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符
string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串
搜索函数 find()
find()函数:
int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//查找成功时返回所在位置，失败返回string::npos的值
int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;
//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值
int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos
int find_first_not_of(char c, int pos = 0) const;
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos,int n) const;
int find_first_not_of(const string &s,int pos = 0) const;
//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos
int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const;
int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s,int pos = npos) const;
//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找

提取字符串 substr()
substr
语法:
basic_string substr( size_type index, size_type num = npos );

substr()返回本字符串的一个子串，从index开始，长num个字符。如果没有指定，将是默认值 string::npos。这样，substr()函数将简单的返回从index开始的剩余的字符串。
例如:
string s(“What we have here is a failure to communicate”);

string sub = s.substr(21);

cout << "The original string is " << s << endl;
cout << "The substring is " << sub << endl;

显示：
The original string is What we have here is a failure to communicate
The substring is a failure to communicate
交换(swap)
语法:
void swap( basic_string &str )；

swap()函数把str和本字符串交换。例如：
string first( “This comes first” );
string second( “And this is second” );
first.swap( second );
字符串流处理：
通过定义ostringstream和istringstream变量实现，头文件中
例如：
string input(“hello,this is a test”);
istringstream is(input);
string s1,s2,s3,s4;
is>>s1>>s2>>s3>>s4;//s1=“hello,this”,s2=“is”,s3=“a”,s4=“test”
ostringstream os;
os< cout<

二、vecotr
向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。
1.构造函数
vector():创建一个空vector
vector(int nSize)： 创建一个vector,元素个数为nSize
vector(int nSize,const t& t)：创建一个vector，元素个数为nSize,且值均为t
vector(const vector&)：复制构造函数
vector(begin,end)：复制[begin,end)区间内另一个数组的元素到vector中
2.增加函数
void push_back(const T& x)： //向量尾部增加一个元素X
iterator insert(iterator it,const T& x)：//向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x)：//向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last)：//向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
3.删除函数
iterator erase(iterator it)： //删除向量中迭代器指向元素
iterator erase(iterator first,iterator last)： //删除向量中[first,last)中元素
void pop_back()： //删除向量中最后一个元素
void clear()： //清空向量中所有元素
4.遍历函数
reference at(int pos)： // 返回pos位置元素的引用
reference front()： // 返回首元素的引用
reference back()： //返回尾元素的引用
iterator begin()： //返回向量头迭代器指针，指向第一个元素
iterator end()： //返回向量尾迭代器指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置
5.判断函数
bool empty() const:判断向量是否为空，若为空，则向量中无元素
6.大小函数
int size() const:返回向量中元素的个数
int capacity() const:返回当前向量张红所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值
7.其他函数
void swap(vector&)： //交换两个同类型向量的数据
void assign(int n,const T& x)： //设置向量中第n个元素的值为x
void assign(const_iterator first,const_iterator last)： //向量中[first,last)中元素设置成当前向量元素。

1. 如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector；
2. 如果你需要大量的插入和删除，而不关心随即存取，则应使用list；
3. 如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。
   List
   Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.
   list的特点：
   不使用连续的内存空间这样可以随意地进行动态操作；
   (2)可以在内部任何位置快速地插入或删除，当然也可以在两端进行push和pop。
   (3)不能进行内部的随机访问，即不支持[ ] 操作符和vector.at() ；
   (4)相对于verctor占用更多的内存。
   2.1 list中的构造函数
   list() 声明一个空列表；
   list(n) 声明一个有n个元素的列表，每个元素都是由其默认构造函数T()构造出来的；
   list(n,val) 声明一个由n个元素的列表，每个元素的值都是val得来的；
   list(first,last) 声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素；
   list list1(10,0); 创建长度为10，每个元素的值都为0；
   2.2 begin()和end()：
   通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator，可以调用list容器的 end() 函数来得到list末端下一位置，相当于：int a[n]中的第n+1个位置a[n]，实际上是不存在的，不能访问，经常作为循环结束判断结束条件使用。
   2.3 push_back() 和push_front()：
   使用list的成员函数push_back和push_front插入一个元素到list中。其中push_back()从list的末端插入，而 push_front()实现的从list的头部插入。
   2.4 empty()：利用empty() 判断list是否为空。
   2.5 clear()： 清空list中的所有元素。
   2.6 resize()：
   如果调用resize(n)将list的长度改为只容纳n个元素，超出的元素将被删除，如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val)，则扩展元素要调用构造函数T(val)函数进行元素构造，其余部分相同。
   2.7 pop_back和pop_front()：
   通过pop_back()删除最后一个元素，通过pop_front()删除第一个元素；序列必须不为空，如果当list为空的时候调用pop_back()和pop_front()会使程序崩掉。
   2.8 front()和back()：
   通过front()可以获得list容器中的头部元素，通过back()可以获得list容器的最后一个元素。但是有一点要注意，就是list中元素是空的时候，这时候调用front()和back()会发生什么呢？实际上会发生不能正常读取数据的情况，但是这并不报错，那我们编程序时就要注意了，个人觉得在使用之前最好先调用empty()函数判断list是否为空。
   2.9 assign()：
   具体和vector中的操作类似，也是有两种情况，第一种是：l1.assign(n,val)将 l1中元素变为n个T(val）。第二种情况是：l1.assign(l2.begin(),l2.end())将l2中的从l2.begin()到l2.end()之间的数值赋值给l1。
   2.10 swap()：
   交换两个链表(两个重载)，一个是l1.swap(l2); 另外一个是swap(l1,l2)，都可能完成连个链表的交换。
   2.11 reverse()：通过reverse()完成list的逆置。
   2.12 merge()：
   合并两个链表并使之默认升序(也可改)，l1.merge(l2，greater()); 调用结束后l2变为空，l1中元素包含原来l1 和 l2中的元素，并且排好序，升序。其实默认是升序，greater()可以省略，另外greater()是可以变的，也可以不按升序排列。
   2.13 insert()：在指定位置插入一个或多个元素(三个重载)：
   l1.insert(l1.begin(),100); 在l1的开始位置插入100。
   l1.insert(l1.begin(),2,200); 在l1的开始位置插入2个100。
   l1.insert(l1.begin(),l2.begin(),l2.end());在l1的开始位置插入l2的从开始到结束的所有位置的元素。
   2.14 erase()：删除一个元素或一个区域的元素(两个重载)
   l1.erase(l1.begin()); 将l1的第一个元素删除。
   l1.erase(l1.begin(),l1.end()); 将l1的从begin()到end()之间的元素删除。

stack：
1.1栈，一个后进先出的容器。
1.2 stack是一种操作受限制的线性表，只能通过top()来访问栈顶元素。
1.3、stack常用函数
1.3.1、push()
push(x)：将x入栈，时间复杂度为O(1)
1.3.2、top()
top()：获取栈顶元素，时间复杂度为O(1)
1.3.3、pop()
pop()：出栈顶元素。
1.3.4、empty()
empty():判断栈是否为空。
1.3.5、size()
size()：获得栈元素个数。

Deque(双端队列的操作)
1.构造函数和析构函数
deque c //default构造函数，产生一个空的deque
deque c(c2) //copy构造函数，建立c2的同型deque并成为c2的一份拷贝
deque c(n) //利用default构造函数生成一个大小为n的deque
deque c(n,t) //建立一个大小为n的deque，每个元素值都是t
deque c(beg,end) //建立一个deque，以区间[beg,end)作为元素初值
c.~deque() //销毁所有元素，释放内存
2.非更易型操作
c.empty() //返回容器是否为空
c.size() //返回目前的元素个数
c.max_size() //返回元素个数之最大可能量
c.shrink_to_fit() //要求降低容量，以符合元素个数
c[id] //返回索引id指向的元素，不检查范围
c.at(id) //返回索引id指向的元素，如果超出范围就跑出range-error异常
c.front() //返回第一元素
c.back() //返回最末元素
c.begin() //返回一个迭代器指向第一元素
c.end() //返回一个迭代器指向最末元素的下一位置
c.rbegin() //返回一个反向迭代器指向反向迭代的第一元素
c.rend() //返回一个反向迭代器指向反向迭代的最末元素的下一位置

更易型操作
c=c2 //将c2的全部元素赋给c
c.push_back(elem) //附加一个elem的拷贝于末尾
c.pop_back() //移除最后一个元素，但是不返回它
c.push_front(elem) //在头部插入一个elem的拷贝
c.pop_front() //移除第一个元素，但是不返回它
c.assign(n,elem) //复制n个elem，赋值给c
c.assign(beg,end) //将区间[beg,end)所有元素赋值给c
c.insert(pos,elem) //在iterator位置pos之前方插入一个elem拷贝，并返回新元素的位置
c.insert(pos,n,elem) //在ierator位置pos之前方插入n个elem拷贝，并返回第一个新元素的位置，若没有元素，则返回pos
c.insert(pos,beg,end) //在ierator位置pos之前方插入区间[beg,end)内所有元素的拷贝，并返回第一个新元素的位置，若没有元素，则返回pos
c.erase(pos) //移除iterator位置pos上的元素，返回下一个元素的位置
c.erase(beg,end) //移除区间[beg,end)内的所有元素，返回下一个元素的位置
c.resize(num) //将元素数量改为num，如果size()变大，多出的新元素都要以default函数初始化
c.resize(num,elem) //将元素数量改为num，如果size()变大，多出新元素都是elem的拷贝
c.clear() //移除所有元素，清空容器

deque的操作并不复杂，在以下情形中最好采用deque：
需要在两端安插和移除元素（毕竟双端队列）
无需指向容器内的元素
要求不再使用的元素必须释放
queue 队列是一种容器适配器，专门用来满足先进先出的操作，也就是元素在容器的一端插入并从另一端提取。
1.1、queue的定义
queue name;
queue q;
queue q;
queue q;
queue q;//Node是结构体
1.2、queue容器元素的访问
queue是一种先进先出的限制性数据结构。通过front()访问队首元素，通过back()来访问队尾元素。
1.3、queue常用函数
1.3.1、front()，back()
获取队首，队尾元素，时间复杂度为O(1)
1.3.2、pop()
队首元素出队，时间复杂度为O(1)
1.3.3、empty()
检测queue是否为空，返回bool类型，true为空。
1.3.4、size()
返回queue内元素个数
1.4、queue的用途
当需要实现广度优先搜索的时候，可以使用queue代替。
使用front()和back()的时候，必须判断队列是否为空，empty()。

map
map 是一种有序无重复的关联容器。
关联容器与顺序容器不同，他们的元素是按照关键字来保存和访问的，而顺序元素是按照它们在容器中的位置保存和访问的。
构造函数
　　(1) 默认构造： map m;　　构造一个空的map，注意，必要时要给出模板参数中的 Compare。需要时给出 Alloc
　　(2) 范围构造： map m(iterator first, iterator last);　　将迭代器[frist, last)范围内的元素填入map中
　　(3) 拷贝构造： map m(cosnt map& m2);　　用m2构造m
　　(4) 初始化列表构造： map m(initializer_list il) //由于map 的 value_type 是 pair类型，所以要构造成pair作为列表，这是三种构造 pair的方式
map m{{key k1, value v1},{k2, v2}, …}　　// 通过 {}构造 pair
　　　map m{make_pair(key k1, value v1), make_pair(k2, v2), …}　　// 通过 make_pair() 函数构造 pair
　　　map m{pair(k1, v1), pair(k2, v2), …}　　// 通过类型转换构造 pair
赋值操作符=
　　map& operator= (const map& x)　 // map赋值
　　map& operator= (map&& x)　　　
　　map& operator= (initializer_list il)　　// 参数列表赋值
迭代器
　　begin, end, rbegin, rend
　　cbegin, cend, crbegin, crend
　　map 的迭代器支持 ++, – 操作，但是不支持 +i 操作。
　　注意 map中是根据 key的值来排列元素的位置的，所以通过迭代器遍历出来的结果顺序，可能和插入值的顺序不同。
　　另外对 map的迭代器解引用的结果是得到一个 pair类型的对象。它有两个共有成员 first, second。first保存 key的值，second 保存value的值。
　　由于map的 key 是 const的，所以得到的 pair 的first 也是const 的。
成员函数
　　容量
　　　　empty()　　// 如果map 为空，返回true。否则返回 false
　　　　　　　　　　// bool empty() const noexcept;
　　　　size()　　　 // 返回map 中元素的大小，即 key-value 的个数
　　　　　　　　　　// size_type size() const noexcept;
　　　　max_size() 　　// 返回由于存储空间的限制，map有可能包含的最大元素数。但不保证一定能达到这个数量，有可能在中途申请空间失败。
　　　　　　　　　　　　 // size_type max_size() const noexcept;
　　元素访问
　　　　操作符[]　　// m[k] 返回map 中 Key为 k的元素的value的引用。
　　　　　　　　　　// 如果 k不存在，那么将会插入一个 key为 k的元素，并返回其默认 value。
　　　　　　　　　　// []操作总会将 map的大小 +1
　　　　　　　　　　// 注意，对于map，解引用迭代器得到 pair，操作符[]得到 value
　　　　at()　　　　// m.at(k) 返回map中Key为k的元素的value的引用。
　　　　　　　　　　// 如果k不存在，抛一个 out_of_range 异常。
　　　　　　　　　　// 使用 at 不会添加元素，不会增加 map的大小
　　修改
　　　　insert　插入
　　　　(1) pair insert(const pair &val);
　　　　　// 单个值插入，参数为 pair类型，first 为 key, second为 value
　　　　　 // 返回值也是一个 pair，first为插入后的 iterator，second 为bool类型， true表示插入成功，false 表示插入失败
　　　　　　　　　　 // 插入失败是因为 map 中已经有一个 key 与输入相同。这次插入操作对map 不会有任何影响， 失败时返回值的 first指向已有的key-value
　　　(2) iterator insert(const_iterator pos, const pair &val);
　　　 // 提示值插入
　　 　// 从 pos 指定的位置开始查找 val应该插入的位置
　　　 // 如果设定值合适，可以减少插入时做查找的时间
　　　(3) void insert(iterator first, iterator second);
　　　 // 范围插入，插入[first, second)范围内的内容
　　　(4) void insert(initializer_list il);
　　　　// 初始化列表插入
　　　　erase　　删除
　　　(1) iterator erase(const_iterator position);　　// 删除迭代器指向的内容, 函数返回 NULL
　　　(2) iterator erase(const_iterator first, const_iterator last);　　// 删除迭代器范围内的内容，函数返回NULL
　　　 (3) size_type erase(const key_type &k);　　 // 删除 type 为k的元素，返回删除的数目。对于 map，成功删除返回1，k不存在则返回0
　　　(4) 1，2中如果迭代器无效，会产生 undefined behavior
　　　　swap　交换两个 map对象的内容
　　　 (1) void swap(map &x)
　　　(2) void swap(map &x1, map &x2)　　// 非成员重载函数
　clear　　清空一个容器的所有元素
　　　　void clear() noexcept;
操作
find　查找
　　　在map中查找key 为 k的元素，返回指向它的迭代器。若k不存在，返回 map::end.
　　　// iterator find(const key_type &k);
　　　count　 计数
　　　统计map中 key为k的元素的个数，对于map，返回值不是1(存在)，就是0(不存在)
　　　// size_type count(const key_type &k) const;

Set
Set：集合，一个内部自动有序而且不重复元素的容器。
1.1、Set的定义
set name;
set name;
set name;
set name;
set name;//Node是结构体类型
/*
定义和写法和vector基本一样，同样typename可以是任何基本类型，结构体，STL容器类型。
同样，typename是容器的时候，>>后要加空格，避免编译器当成位运算出错。
*/
1.2、set容器内元素的访问
　　 set只能通过迭代器iterator访问
　 因为除了vector和string之外的STL的容器都不支持以下标的方式访问。
set内的元素，自动递增排序，并且去重。
1.3、set常用函数
　　　　1.2.1、insert()函数
　　　　insert(x)：将x插入set容器中，并且自动递增排序和去重。时间复杂度为O(logN)，N为元素个数
　　　　1.2.2、find()函数
　　　　find(value)：查找值为value的元素，返回它的迭代器。时间复杂度为O(logN),N为元素个数
　　　　1.2.3、erase()函数
　　　　erase(x)：删除单个元素，时间复杂度为O(logN)
　　　　erase(a,b);删除左闭右开区间内[a,b)的元素，时间复杂度为O(b-a)
　　　　1.2.4、size()函数
　　　　size()：用来获得set内元素的个数，时间复杂度为O(1)
　　　　1.2.5、clear()函数
　　　　clear()：用来清空set所有元素，时间复杂度为O(N)　
vector和list区别
底层实现的数据结构不同（造成两者差异的本质原因）
Vector：数组实现，拥有一段连续的内存空间，数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝，重新申请开辟的内存大小是原来的两倍
list是由双向链表实现的，因此内存空间是不连续的。
2，应用场景不同
如果需要高效的随机存在，而不在乎插入和删除的效率，使用vector;如果需要大量的插入和删除，而不关心随机存取，则要使用list
vector和list对于迭代器的支持不同
相同点:迭代器都重载了”++”运算符
不同点:vector 迭代器支持 iter“+”, ”+=“ ， ”<"等操作。而list中则不支持

算法:排序
C++STL标准库中包含了algorithm 库
本次主要介绍sort()函数的用法及细节
算法复杂度:O(nlogn)，执行效率较高
适用范围分析:首先，关系型容器拥有自动(set、map)排序功能，因为底层采用了RB-Tree(红黑树 )，其次序列式容器(queue)都有特定的出入口，不允许用户对元素排序，剩下的vector、deque适用sort()算法，当然基本的数据类型也可以使用。另外，list类中提供了自己的排序方法。
Sort()的底层实现
1快速排序，2插入排序，3 堆排序

函数原型
Sort(V.begin(),V.end（）,[swap]); //[ ]表示缺省值
分析:第一个和第二个参数指定排序的范围，是地址或者迭代器，第三个参数是比较函数的函数名。
注:当第三个参数缺省时默认从小到大排序，如想从大到小排序，无论是否为基本数据类型，都需要自定义比较函数。
重写比较函数的原则:
自定义的比较函数原型为：bool 函数名（类型1 参数1，类型2 参数2）；如果返回false，那么就需要调换数据的位置，如果返回true，则不用调换
对基本数据类型排序时举例如下
#include
#include < algorithm >
bool wap(int a,int b);
{
return a > b; //给从大到小排序做准备
}
void main( )
{
vector v{5,1,8,9,6,7};
sort(v.begin(),v.end()); //缺省第三个参数，输出结果 1,5,6,7,8,9
sort(v.begin(),v.end(),wap);//从大到小排序，输出 9,8,7,6,5,1
}
对自定义数据类型的排序时，必然要看情况重写排序函数，排序函数可以是全局函数，也可以是成员函数。
这种情况下包含缺不缺省sort（）的第三个参数。
如果缺省第三个函数，那么只能是重载”<”运算符，否则，第三个参数必须给，至于排序顺序，取决于能不实现的方式
bool Student::operator<(StudentLib& other) //类中的运算符重载
{
return this->age > other.age;
}
int main( )
{
vector A；
…省略插值过程…
Sort（A.begin()，A.end()） //排序 由大到小，缺省了第三个参数，因为重载的小于号
//想由小到大排序，重载运算时符return this->age < other.age;即可
}