【C++11】C++ STL（面试复习整理-2.0）

1、六大组件介绍

STL六大组件
容器：数据结构，用来存放数据
算法：常用算法
迭代器：容器和算法之间的胶合剂，“范型指针”
仿函数：一种重载了operator()的类，使得这个类的使用看上去像一个函数
配置器：为容器分配并管理内存
适配器：修改其他组件接口

2、容器

vector

底层为数组，支持随机访问，节点大小是动态的，支持下标访问。随机存取效率很高（O(1)），插入效率不高。
扩容原理：以原大小的两倍配置一份新空间，将原空间数据拷贝过来，会导致迭代器失效

常用函数
size()：当前vector元素个数
capacity()：vector已分配空间容量
reserve()：预分配空间,分配空间小于现有空间，不改变空间容量
resize()：改变size大小，不改变容量大小
 

#include<iostream>
#include <stdlib.h>
#include <time.h>
#include<vector>

using namespace std;

void Push(vector<int> &vec,int i){
	vec.push_back(i);
	cout<<"vector放入"<<i<<"个元素时"<<endl; 
	cout<<"vec.size()="<<vec.size()<<"	vec.capacity()="<<vec.capacity()<<endl;
}

int main(){
	vector<int> vec;
	
	cout<<"vector未放入元素时"<<endl; 
	cout<<"vec.size()="<<vec.size()<<"	vec.capacity()="<<vec.capacity()<<endl;
	
	for(int i=1;i<4;i++){
		Push(vec,i);
	}
	cout<<"vec中元素现为"<<endl; 
	vector<int>::iterator iter=vec.begin();
	while(iter!=vec.end()){
		cout<<*iter++<<" ";
	}
	cout<<endl;

	vec.resize(2);
	cout<<"在vec.resize(2)后"<<endl; 
	cout<<"vec.size()="<<vec.size()<<"	vec.capacity()="<<vec.capacity()<<endl;
	cout<<"vec中元素变为"<<endl; 
	iter=vec.begin();
	while(iter!=vec.end()){
		cout<<*iter++<<" ";
	}
	cout<<endl;
	
	vec.reserve(3);
	cout<<"在vec.reserve(3)后"<<endl; 
	cout<<"vec.size()="<<vec.size()<<"	vec.capacity()="<<vec.capacity()<<endl;
	
	vec.reserve(5);
	cout<<"在vec.reserve(5)后"<<endl; 
	cout<<"vec.size()="<<vec.size()<<"	vec.capacity()="<<vec.capacity()<<endl;
	return 0;
} 

结果为：
vector未放入元素时
vec.size()=0    vec.capacity()=0
vector放入1个元素时
vec.size()=1    vec.capacity()=1
vector放入2个元素时
vec.size()=2    vec.capacity()=2
vector放入3个元素时
vec.size()=3    vec.capacity()=4
vec中元素现为
1 2 3
在vec.resize(2)后
vec.size()=2    vec.capacity()=4
vec中元素变为
1 2
在vec.reserve(3)后
vec.size()=2    vec.capacity()=4
在vec.reserve(5)后
vec.size()=2    vec.capacity()=5

若是循环体内包含向vector对象添加元素的语句，则不能使用范围for循环。因为范围for语句不应改变其所遍历序列的额大小。原因如下：

 1 vector<int> v={1,2,3,4,5,6,7,8,9};
 2 for(auto &r: v)
 3 {
 4     r*=2;
 5 }
 6 
 7 等价于
 8 for(auto beg=v.begin(),end=v.end();beg !=end;++beg)
 9 {
10     auto &r=*beg;
11     r*=2;
12 }

 即在范围for语句中，预存了end()的值，一旦在序列中添加（删除）元素，end函数的值就可能变的无效了。

由于vector的动态内存变化的机制，在插入和删除时，需要考虑迭代的是否有效问题

《数组和vector、array三者区别和联系》：https://blog.csdn.net/bandaoyu/article/details/85066924

2、vector优缺点
优点：
1)使用连续的存储空间，访问速度快。
2) 支持随机访问，可以通过[ ]操作符和at()方法访问数据。
3）可以不指定内存大小即可实现对像数组一样的操作，实际内部实现vector是预先分配了一块固定大小的内存，当超过该内存块时，vector会重新找一块更大的内存，并把当前的释放掉。
（之前写过两篇文章对vector内存进行过剖析，感兴趣可以看看：
文章1：https://blog.csdn.net/toby54king/article/details/86737201，
文章2：https://blog.csdn.net/toby54king/article/details/88543270）
4)可以快速的在尾部进行插入和删除，即通过push_back() 和pop_back()方法。

缺点：
1)vector内部进行插入删除操作效率低。
2) 只能在vector的尾部进行push和pop。
3) 添加数据占用内存超过vector预先分配的大小时，需要重新分配、拷贝与释放。
原文链接：https://blog.csdn.net/toby54king/article/details/104979593

vector代码示例

// TestVector.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

// 打印函数
void MyPrintf(int &elem)
{
	cout << elem << ", ";
}

// 修改元素函数
void MyAdd(int &elem)
{
	elem = elem + 10;
}

int main()
{
	cout << "------------------------C++序列化容器vector的使用--------------------" << endl;
	// 1、增加元素
	cout << "-----------------------vector增加元素--------------------" << endl;
	vector<int> myVector;
	for (int i=0; i<10; i++)
	{
		//myVector.push_back(i);
		myVector.emplace_back(i); // C++11
	}
	for_each(myVector.begin(),myVector.end(), MyPrintf);
	cout << endl;

	// 2、排序元素
	cout << "-----------------------vector排序元素--------------------" << endl;
	sort(myVector.begin(), myVector.end(), greater<int>());
	for_each(myVector.begin(), myVector.end(), MyPrintf);
	cout << endl;

	// 3、修改元素
	cout << "-----------------------vector修改元素--------------------" << endl;
	for_each(myVector.begin(), myVector.end(), MyAdd);
	for_each(myVector.begin(), myVector.end(), MyPrintf);
	cout << endl;

	// 4、查找元素
	cout << "-----------------------vector查找元素--------------------" << endl;
	vector<int>::iterator index;
	index = find(myVector.begin(), myVector.end(), 10); // 查找元素10
	// 注意：元素的索引从0开始的
	cout << "元素10的索引index是： " << (index - myVector.begin()) << endl;
	index = find_if(myVector.begin(), myVector.end(), bind2nd(less<int>(),15));
	cout << "第一个小于15的元素索引index是： " << (index - myVector.begin()) << endl;

	// 5、删除元素
	cout << "-----------------------vector删除元素--------------------" << endl;
	while (!myVector.empty())
	{
		int backNum = myVector.back();
		cout << backNum << ", ";
		myVector.pop_back();
	}
	cout << endl;
	
    std::cout << "Hello World!\n";
	getchar();
}

运行结果： 

list

底层为双向链表，内存空间不连续，只能通过指针访问数据，插入删除高效，不支持下标访问，list对于随机访问速度慢。适用于对象需要大量删除插入操作的环境。
list的iterator不支持+，+=，<操作

list.sort()：合并前两个元素，合并后两个元素，两个子序列合并，序列大小变化顺序为2->4->8->16…完成排序（O(log(n))）
 

2、list优缺点
优点：
1)不使用连续存储空间来完成动态操作。
2)内部进行插入和删除操作非常方便。
3)可以在两端进行插入和删除操作。
4])不需要预先分配内存空间。

缺点：
1)不能进行内部的随机访问，因为不支持下标索引。
2)比verctor占用内存多，因为要存储其前驱和后继节点的信息。
原文链接：https://blog.csdn.net/toby54king/article/details/104979593

list代码示例

// Testlist.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <list>
#include <algorithm>
#include <functional>

using namespace std;

// 打印函数
void MyPrintf(int &elem)
{
	cout << elem << ", ";
}

// 修改元素函数
void MyAdd(int &elem)
{
	elem = elem + 10;
}

int main()
{
	cout << "------------------------C++序列化容器list的使用--------------------" << endl;
	// 1、增加元素
	cout << "-----------------------list增加元素--------------------" << endl;
	list<int> myList;
	for (int i = 0; i < 10; i++)
	{
		//myList.push_back(i);
		myList.emplace_back(i); // C++11
	}
	for_each(myList.begin(), myList.end(), MyPrintf);
	cout << endl;

	// 2、排序元素
	cout << "-----------------------list排序元素--------------------" << endl;
	myList.sort(greater<int>());
	for_each(myList.begin(), myList.end(), MyPrintf);
	cout << endl;

	// 3、修改元素
	cout << "-----------------------list修改元素--------------------" << endl;
	for_each(myList.begin(), myList.end(), MyAdd);
	for_each(myList.begin(), myList.end(), MyPrintf);
	cout << endl;
	// list反序排列
	cout << "-----------------------list反序排列元素--------------------" << endl;
	myList.reverse();
	for_each(myList.begin(), myList.end(), MyPrintf);
	cout << endl;

	// 4、查找元素
	cout << "-----------------------list查找元素--------------------" << endl;
	list<int>::iterator index;
	index = find(myList.begin(), myList.end(), 10); // 查找元素10
	if (index != myList.end())
	{
		cout << "找到元素10了，删除该元素" << endl;
		myList.remove(10);
	}
	for_each(myList.begin(), myList.end(), MyPrintf);
	cout << endl;
	index = find_if(myList.begin(), myList.end(), bind2nd(greater<int>(), 15));
	if (index != myList.end())
	{
		cout << "第一个大于15的元素找到了" << endl;
	}

	// 5、删除元素
	cout << "-----------------------list删除元素--------------------" << endl;
	myList.remove_if(bind2nd(equal_to<int>(), 15)); // 删除等于15的元素
	cout << "-----------------------list删除等于15的元素后--------------------" << endl;
	for_each(myList.begin(), myList.end(), MyPrintf);
	cout << endl;
	cout << "删除所有的元素" << endl;
	while (!myList.empty())
	{
		int backNum = myList.back();
		cout << backNum << ", ";
		myList.pop_back();
	}
	cout << endl;

	std::cout << "Hello World!\n";
	getchar();
}

运行结果：

STL 中list的sort()方法使用总结

1、list中数据类型为基本类型，例如为整数类型排序：

#include <iostream> 
#include <list>
using namespace std;
 
int main()
{
    list<int> num;
    num.push_back( 1 );
    num.push_back( 3 );
    num.push_back( 2 );
    num.push_back( 9 );
    num.push_back( 5 );
    num.sort();
    list<int>::iterator vi;
    for( vi=num.begin();vi!=num.end();vi++) 
    {
        cout  << *vi << endl;
    } 
    
    return 0;
}

输出为：

2、list中的类型为自定义类型

比方说是一个自定义的类，那么如果想为这个类所生成的对象排序的话，因为list.sort()默认排序需要重载 < 操作符。所以我们必须在类对象里重载这个操作符。例子如下：

#include <iostream> 
#include <list>
using namespace std;
 
 
class student
 {
    public:
      int age;
      student()
      {}
      student(int a)
      {
          this->age=a;
      }
  public:
      bool operator < (student b)
     {
           return this->age < b.age;
     }
 
     bool operator > (student b)
     {
           return this->age > b.age;
     } 
 
 }; 
 
int main()
{
    list<student> num;
    num.push_back( student(1) );
    num.push_back( student(5));
    num.push_back( student(2));
    num.push_back( student(6));
    num.sort();
   // sort(num.begin(),num.end());
    list<student>::iterator vi;
 
    for( vi=num.begin();vi!=num.end();vi++) 
    {
        cout  << vi->age << endl;
    }
    num.clear();
    
}

输出为：

总结：事实上，list有两个版本的sort成员函数：   

  一个是不带参数的sort()，用来实现升序排列；另一个嘛，另一个是带参数的sort(greater<T>   pr)，用来实现降序排列。后者的greater实际上是被VC实作好的一个二元函数（binary   funtion)对象，具体可以参见参考文档[1]

3、自定义规则进行排序

3.1 使用函数对象 (参考[2]）

#include<iostream>
#include<list>
using namespace std;
 
class A{
public:
 int a,b;
 A(int t1,int t2){a=t1,b=t2;}
};
 
 
struct node{
 bool operator()(const A& t1,const A& t2){
  return t1.a<t2.a;    //会产生升序排序,若改为>,则变为降序
 }
};
 
int main() {
 list<A> list_a;
 A a1(1,2), a2(4,6), a3(2,8);
 list_a.push_back(a1);
 list_a.push_back(a2);
 list_a.push_back(a3);
 
 list_a.sort(node()); //排序操作； 
 
 list<A>::iterator ite;
 ite=list_a.begin();
 for(int i=0;i<3;i++)  {cout<<ite->a<<endl; ite++;}
 
 return 0;
 
}

输出为

3.2 使用回调函数自定义排序规则：（参考[3]）

#include<iostream>
#include<list>
using namespace std;

class A
{
public:
    int a, b;
    A(int t1, int t2)
    {
        a = t1, b = t2;
    }
};

bool compare(A a1, A a2)
{
    return a1.a < a2.a;  //会产生升序排列，若改为>,则会产生降序；
}

int main()
{
    list<A> list_a;
    A a1(1, 2), a2(4, 6), a3(2, 8);
    list_a.push_back(a1);
    list_a.push_back(a2);
    list_a.push_back(a3);

    list_a.sort(compare); //排序操作；

    list<A>::iterator ite;
    ite = list_a.begin();
    for(int i = 0; i < 3; i++)
    {
        cout << ite->a << endl;
        ite++;
    }

    return 0;

}

输出为：

注：使用C-Free中的gcc版本 ：4.9.2

三、map

1、map概述
map是采用红黑树实现的key-value一对一映射的关联容器，红黑树能够自动对数据进行排序，因此map内部所有的数据都是有序的；作为键值key的元素不允许重复，比较函数只对元素的键值进行比较，元素的各项数据可以通过键值进行查找、重新赋值等操作；可以使用键值key作为下标来获取对应的值；map默认的排序准则是从小到大。

2、map优缺点
优点:
1)map的数据结构采用红黑树自身是有序的,插入数据时会自动排序。
2)内部结构采用红黑树，红黑树的时间复杂度是在log(n)，时间复杂度低，效率高。
3)索引方便，可以通过下标key方便的进行存取。

缺点:
1)map内部采用红黑数实现，需要额外空间保存节点，会占用多余的空间，典型的以“空间换时间”。
2)通过key值索引时，如果key值不存在，map会直接插入一个key-value键值对。

// Testmap.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

// 打印函数
void MyPrintf(pair<int, double> mpair)
{
	cout << "( " << mpair.first << "," << mpair.second << ") " << endl;
}

// 以value值进行排序
bool CompVector(pair<int, double> mpair1, pair<int, double> mpair2)
{
	return mpair1.second > mpair2.second;
}

int main()
{
	cout << "------------------------C++关联容器map的使用--------------------" << endl;
	// 1、增加元素
	cout << "-----------------------map增加元素--------------------" << endl;
	map<int, double> myMap;
	for (int i = 0; i < 10; i++)
	{
		double fNum = i + 0.5;
		myMap.insert(pair<int, double>(i,fNum));
	}
	for_each(myMap.begin(), myMap.end(), MyPrintf);
	cout << endl;


	// 2、排序元素
	cout << "------map排序元素，map没有提供直接排序的函数,需要借助vector排序-------" << endl;
	vector<pair<int, double> >mapVector(myMap.begin(), myMap.end());
	sort(mapVector.begin(), mapVector.end(), CompVector);
	for_each(mapVector.begin(), mapVector.end(), MyPrintf);
	cout << endl;

	// 3、修改元素
	cout << "-----------------------map修改元素--------------------" << endl;
	for (int i = 0; i < 10; i++)
	{
		double fNum = i + 10.1;
		myMap[i]=fNum;
	}
	for_each(myMap.begin(), myMap.end(), MyPrintf);
	cout << endl;

	// 4、查找元素
	cout << "-----------------------map查找元素--------------------" << endl;
	map<int,double>::iterator iterFind;
	iterFind = myMap.find(1); // key值为1的元素
	if (iterFind != myMap.end())
	{
		cout << "找到了key值为1的元素: " << iterFind->second << endl;;
	}
	
	// 随机查找元素功能的函数lower_bound和upper_bound
	iterFind = myMap.lower_bound(3); // 从键值key的最小开始，注意下标从0开始，即正序
	cout << "lower_bound(3): " << "(" << iterFind->first << ", " << iterFind->second << ")" << endl;
	iterFind = myMap.upper_bound(4);// 从键值key的最大开始，注意下标从最大开始，即倒序
	cout << "upper_bound(4): " << "(" << iterFind->first << ", " << iterFind->second << ")" << endl;

	// 5、删除元素
	cout << "-----------------------map删除元素--------------------" << endl;
	// 删除第一个元素
	cout << "-----------------------删除map第一个元素--------------------" << endl;
	myMap.erase(myMap.begin());
	for_each(myMap.begin(), myMap.end(), MyPrintf);
	// 删除所有的元素
	cout << "-----------------------删除map中所有的元素--------------------" << endl;
	myMap.erase(myMap.begin(),myMap.end());
	if (myMap.empty())
	{
		cout << "map中所有的元素都已经删除！" << endl;
	}

	std::cout << "Hello World!\n";
	getchar();
}

运行结果：

原文链接：https://blog.csdn.net/toby54king/article/details/104979593

四、set

1、set概述
set属于关联型容器，能够按顺序存储一组值，该集合是一个有序的链表，元素以升序的顺序存储，集合中的每一个值都不允许重复，其内部实现与map一样，可以认为是一种key = value的特殊map。

2、set优缺点
优点：
1)set会自动排序功能。
2)内存采用红黑树，查询效率高。

缺点：
1)不能直接修改 set 容器中元素的值，修改set容器中的某个值，需要先删除该元素，再插入新元素。
2)需要额外空间保存节点，会占用多余的空间。

3、set代码示例

// TestSet.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

// 打印函数
void MyPrintf(int elem)
{
    cout << elem << ", ";
}

int main()
{
    cout << "------------------------C++关联容器set的使用--------------------" << endl;
    // 1、增加元素
    cout << "-----------------------set增加元素--------------------" << endl;
    set<int> myset;
    for (int i = 0; i < 10; i++)
    {
        myset.insert(i);
    }
    for_each(myset.begin(), myset.end(), MyPrintf);
    cout << endl;


    // 2、排序元素
    cout << "------set排序元素，set没有提供直接排序的函数,需要借助vector排序-------" << endl;
    vector<int> setVector(myset.begin(), myset.end());
    sort(setVector.begin(), setVector.end(), greater<int>());
    for_each(setVector.begin(), setVector.end(), MyPrintf);
    cout << endl;

    // 3、查找元素
    cout << "-----------------------set查找元素--------------------" << endl;
    set<int>::iterator iterFind;
    iterFind = myset.find(1); // key值为1的元素
    if (iterFind != myset.end())
    {
        cout << "找到了key值为1的元素: " << *iterFind << endl;;
    }

    // 随机查找元素功能的函数lower_bound和upper_bound
    iterFind = myset.lower_bound(3); // 从键值key的最小开始，注意下标从0开始，即正序
    cout << "lower_bound(3): " << *iterFind << endl;
    iterFind = myset.upper_bound(4);// 从键值key的最大开始，注意下标从最大开始，即倒序
    cout << "upper_bound(4): " << *iterFind << endl;

    // 4、删除元素
    cout << "-----------------------set删除元素--------------------" << endl;
    // 删除第一个元素
    cout << "-----------------------删除set第一个元素--------------------" << endl;
    myset.erase(myset.begin());
    for_each(myset.begin(), myset.end(), MyPrintf);
    cout << endl;
    // 删除所有的元素
    cout << "-----------------------删除set中所有的元素--------------------" << endl;
    myset.erase(myset.begin(), myset.end());
    if (myset.empty())
    {
        cout << "set中所有的元素都已经删除！" << endl;
    }

    std::cout << "Hello World!\n";
    getchar();
}

运行结果：

原文链接：https://blog.csdn.net/toby54king/article/details/104979593

五、deque

1、deque概述
deque属于序列式容器，采用动态数组来管理序列中的元素，提供了对序列随机访问的功能，可以在序列的两端进行快速的插入和删除，并可以根据需要调整自身的大小，是典型的双端队列。

（双向队列，一个中央控制器+多个缓冲区，支持首尾快速增删，支持随机访问。）

2、deque优缺点
优点：
1)支持随机访问，可以通过[ ]操作符和at()方法访问数据。
2)可以在两端方便的进行插入和删除操作。
3)容器deque的迭代指针属于智能型指针。
3)容器deque的迭代器属于随机存取迭代器。

缺点：
1)占用内存多，要通过迭代器来维护内存的整体连续，实际内部并不是连续的。
2)在中间进行插入和删除时比较慢。

（emplace_back和push_back的区别：

相同点：两者都是向容器内添加数据

不同点：当数据为类的对象时，emplace_back相对push_back可以避免额外的移动和复制操作。https://blog.csdn.net/p942005405/article/details/84764104）

#// TestDeque.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <deque>
#include <algorithm>
#include <functional>

using namespace std;

// 打印函数
void MyPrintf(int &elem)
{
	cout << elem << ", ";
}

// 修改元素函数
void MyAdd(int &elem)
{
	elem = elem + 10;
}

int main()
{
	cout << "------------------------C++序列化容器deque的使用--------------------" << endl;
	// 1、增加元素
	cout << "-----------------------deque增加元素--------------------" << endl;
	deque<int> myDeque;
	for (int i = 0; i < 10; i++)
	{
		//myDeque.push_back(i);
		//myDeque.push_front(i);
		//myDeque.emplace_front(i); // C++11 头部增加元素
		myDeque.emplace_back(i); // C++11 尾部增加元素
	}
	for_each(myDeque.begin(), myDeque.end(), MyPrintf);
	cout << endl;

	// 2、排序元素
	cout << "-----------------------deque排序元素--------------------" << endl;
	sort(myDeque.begin(), myDeque.end(), greater<int>());
	for_each(myDeque.begin(), myDeque.end(), MyPrintf);
	cout << endl;

	// 3、修改元素
	cout << "-----------------------deque修改元素--------------------" << endl;
	for_each(myDeque.begin(), myDeque.end(), MyAdd);
	for_each(myDeque.begin(), myDeque.end(), MyPrintf);
	cout << endl;
	cout << "-----------------------打印myDeque2中的元素-----------------------" << endl;
	deque<int> myDeque2;
	myDeque2.assign(myDeque.rbegin(),myDeque.rend());
	for_each(myDeque.begin(), myDeque.end(), MyPrintf);
	cout << endl;

	// 4、查找元素
	cout << "-----------------------deque查找元素--------------------" << endl;
	deque<int>::iterator index;
	index = find(myDeque.begin(), myDeque.end(), 10); // 查找元素10
	// 注意：元素的索引从0开始的
	cout << "元素10的索引index是： " << (index - myDeque.begin()) << endl;
	index = find_if(myDeque.begin(), myDeque.end(), bind2nd(less<int>(), 15));
	cout << "第一个小于15的元素索引index是： " << (index - myDeque.begin()) << endl;

	// 5、删除元素
	cout << "-----------------------deque删除元素--------------------" << endl;
	while (!myDeque.empty())
	{
		int backNum = myDeque.back();
		cout << backNum << ", ";
		myDeque.pop_back();
	}
	cout << endl;

	std::cout << "Hello World!\n";
	getchar();
}

运行结果：

原文链接：https://blog.csdn.net/toby54king/article/details/104979593

stack

底层为deque/list，封闭头部，不使用vector作为底层的原因是vector扩容耗时。

queue & priority_queue

queue：底层为deque/list，封闭头部，不使用vector作为底层的原因是vector扩容耗时。
priority_queue：优先队列，以vector为底层，以heap为处理规则管理底层实现。

3、红黑树为底层的容器及红黑树

红黑树为底层的容器

	有序	元素可重复
set	是	否
multiset	是	是
map	是	否
multimap	是	是

插入删除，查找时间复杂度为O(log(n))
作为关联容器，set不同于map的地方在于，set的key就是value。

红黑树

红黑树的特点：根节点是黑色，叶节点是黑色的null节点，任意节点到其叶节点经过的黑色节点数量是相同的。
去除掉黑色null节点，红黑树是一层黑一层红。
红黑树是近平衡的二叉搜索树，和平衡二叉搜索树相比，红黑树的平衡没有那么平衡，插入后可以保证调整三次之间可以使树达到平衡条件。

hash表为底层的容器及hash表

hash表为底层的容器

	有序	元素可重复
hash_set	否	否
hash_multiset	否	是
hash_map	否	否
hash_multimap	否	是

查询时间复杂度O(1)

hash表冲突解决

1、扩大每个桶的容量
2、闭地址：桶后增加溢出链
3、开地址；寻找下一个有空间的桶

原文链接：https://blog.csdn.net/Chuwei_xu/article/details/89321692 

六、各个容器的使用场景

1、容器使用场景
vector：当需要高效的随机存取数据时，而不在乎插入和删除的效率，可以使用vector。
list：当需要大量的插入和删除数据时，而不关心随机存取，可以使用list。
map：当需要以键值对的方式存储数据时，可以使用map。
set:当需要存储不重复的数据时，可以使用set。
deque:当需要随机存取数据时，还关心两端数据的插入和删除，可以使用deque。

2、C++官方网址
C++的容器使用类模板实现，各个容器提供的方法也非常多，限于篇幅不可能一一列举出来，文中只是列举了部分使用方法，具体每个容器的使用方法可以根据官方提供的网址查看，官方网址：http://www.cplusplus.com/reference/vector/vector/?kw=vector

原文链接：https://blog.csdn.net/toby54king/article/details/104979593