map和set的使用以及底层原理

目录

1.关联式容器

2.键值对

2.1pair键值对类型,>

2.2make_pair(parameter，parameter)构造键值对

3.树形结构的关联式容器

3.1set

3.1.1set的介绍

3.1.2set和multiset的使用

1.set的模板参数列表

2.set的构造

3.set的迭代器

4.set的容量

5.set修改操作

6.set的使用例子

3.2map和multimap的使用

3.2.1map的介绍

3.2.2map的使用

1.map的模板参数说明

2.map的构造

3.map的迭代器

4.map的容量与元素访问

5.map中元素的修改

6.map的使用例子

3.3map、multimap、set、multiset，这四个容器的区别

4.底层结构

4.1AVL树(高度平衡搜索二叉树)

4.1.1AVL树的概念

4.1.2AVL树节点的定义

4.1.3AVL树的插入

4.1.4AVL树的旋转

4.1.5AVL树的验证

4.1.6AVL树的删除

4.1.7AVL树的性能

4.1.8代码

4.2红黑树

4.2.1红黑树的概念

4.2.2红黑树的性质

4.2.3红黑树节点的定义

4.2.4红黑树的插入操作

4.2.5总结红黑树的插入情况：

4.2.6红黑树的验证

4.2.7红黑树的删除

4.2.8 红黑树与AVL树的比较

4.2.9代码

4.3红黑树模拟实现SRL中的map和set

1.关联式容器

在之前的文章里，我们已经接触过STL中的部分容器，比如：vector、list、deque、forward_list(单链表)(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。

2.键值对

2.1pair<type1, type2>键值对类型

注：type表示类型的意思。

std::pair<Type1, Type2> 是 C++ 标准库中的一个模板类，用于存储一对值。这个类有两个主要成员：first 和 second。first 存储了类型为 Type1 的值，而 second 存储了类型为 Type2 的值。

std::pair 常用于以下情况：

• 作为 std::map 和 std::unordered_map 中的键值对，其中 first 是键，second 是值。
• 作为临时存储两个相关联的值的容器，例如在算法中返回两个结果时。

pair用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。
SGI-STL中关于键值对的定义：

template <class T1, class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;
	T1 first;
	T2 second;
	pair() 
    	: first(T1()), second(T2())
	{}
    
	pair(const T1& a, const T2& b) 
        : first(a), second(b)
	{}
};

int main()
{
    //创建键值对类型
    pair<int, int> p1;
	pair<int, int> p2(10, 20);
    
	return 0;
}

这段代码是一个简单的模板类 pair，用于表示一对值的组合。

pair 类包含两个模板参数 T1 和 T2，分别表示两个值的类型。

该类定义了两个成员变量 first 和 second，分别表示第一个值和第二个值。

类中还定义了两个类型别名 first_type 和 second_type，用于方便访问第一个值和第二个值的类型。

该类提供了两个构造函数，一个是默认构造函数，会使用默认构造函数对 first 和 second 进行初始化；另一个是带参数的构造函数，可以接受两个值作为参数进行初始化。

这个模板类的作用是可以轻松地创建一对不同类型的值，并且可以通过 first 和 second 成员变量来访问和操作这些值。它可以在很多情况下提供便利，并且可以根据需要定义不同类型的 pair 实例。

注：pair就是一个简单的类对象而已，类里面拥有两个成员变量，通过包含头文件#include <utility>和展开 using std::pair 命名空间即可使用。

2.2make_pair(parameter，parameter)构造键值对

std::make_pair 是一个辅助函数，它可以简化创建 std::pair 的过程，尤其是当使用列表初始化时：

auto madePair = std::make_pair(42, "forty-two");

std::make_pair 函数的返回类型是 std::pair。这个函数是一个模板辅助函数，它的作用是根据提供的参数自动推导出 std::pair 的类型，从而避免手动指定类型。std::make_pair 接收两个参数作为 std::pair 的 first 和 second 成员，并返回一个已经构造好的 std::pair 对象。

parameter的意思表示参数，make_pair()的作用是使用两个参数构造一个键值对(pair)类型，如下：

// make_pair example
#include <utility>      // std::pair
#include <iostream>     // std::cout

int main () {
  std::pair <int,int> foo;
  std::pair <int,int> bar;

  foo = std::make_pair (10,20);
  bar = std::make_pair (10.5,'A'); 

  std::cout << "foo: " << foo.first << ", " << foo.second << '\n';
  std::cout << "bar: " << bar.first << ", " << bar.second << '\n';

  return 0;
}

注：在传参时不要把键值对看成两个参数类型，键值对是一个类型，一个整体，不要看他有两个模板参数或类型而当成两个整体，但在传参传递给函数或者类时，它被视为一个整体，只占用一个模板参数或者一个类型，而在使用键值对仍然是由键和值两部分组成。

3.树形结构的关联式容器

根据应用场景的不桶，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡搜索树(即红黑树)作为其底层结果，容器中的元素是一个有序的序列。下面一依次介绍每一个容器。

3.1set

3.1.1set的介绍

在C++中，set是标准库提供的一种容器，用于存储一组已排序的唯一元素。即set中的元素按照一定的排序规则进行排序，并且不允许重复。

set的特点包括：

1. 存储有序：set中的元素按照其值的大小进行排序，默认使用升序排序。可以通过自定义比较函数来实现自定义的排序规则。
2. 唯一性：set中不允许有重复的元素，每个元素在set中都是唯一的。
3. 动态大小：set的大小可以根据需要动态调整，可以在运行时进行元素的插入和删除操作。
4. 快速查找：由于set中的元素是有序的，因此可以使用二分查找算法来快速定位元素的位置。
5. 支持插入和删除操作：可以使用insert()函数来插入元素，erase()函数来删除元素。
6. 支持迭代器操作：可以使用迭代器对set中的元素进行遍历和访问。
7. set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
8. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
9. set在底层是用平衡二叉搜索树(红黑树)实现的。

使用set前需要包含头文件<set>。

注意：

1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set 是一个不含重复元素的集合，它存储的是单一的键(key)，不存储值(value)与之关联。multiset 也是一个集合，但它允许存储重复的元素。在 std::multiset 中，存储的仍然是单一的键（key），没有值（value）与之关联。与 std::set 不同的是，std::multiset 允许多个相同的键值。
2. set中插入元素时，只需要插入key即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列
5. set中的元素默认按照小于来比较
6. set中查找某个元素，时间复杂度为：logN
7. set中的元素不允许修改(为什么?)

因为在 C++ 的 set 容器中，元素的键值是唯一(伪键值对)的且不能被修改。这是因为 std::set 使用红黑树作为底层数据结构来实现有序性和快速查找的特性。

红黑树是一种自平衡的二叉搜索树，它的排序是基于节点的键值。当一个元素被插入到红黑树中时，它会被放置到正确的位置以保持树的有序性。如果允许修改元素的键值，那么它将改变元素在红黑树中的位置，破坏了树的有序性和平衡性。

为了维持红黑树的结构和性质，标准库规定在 std::set 中，元素的键值是只读的，一旦插入到容器中就不能被修改。如果确实需要修改键值，应该将该元素从 std::set 中移除，修改后再重新插入。

3.1.2set和multiset的使用

1.set的模板参数列表

T: set中存放元素的类型。
Compare：set中元素默认按照小于来比较
Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理

2.set的构造

注：以下函数的参数类型可以配合函数模板一起看

函数声明	功能介绍
explicit set (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());	构造空的set
template <class InputIterator> set (InputIterator first, InputIterator last, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());	用[first，last)区间中的元素构造set
set (const set& x);	set的拷贝构造

3.set的迭代器

函数使用	功能介绍
iterator begin()	返回set中起始位置元素的迭代器
iterator end()	返回set中最后一个元素后面的迭代器
const_iterator cbegin() const	返回set中起始位置元素的const迭代器
const_iterator cend() const	返回set中最后一个元素后面的const迭代器
reverse_iterator rbegin()	返回set第一个元素的反向迭代器，即end
reverse_iterator rend()	返回set最后一个元素下一个位置的反向迭代器，即rbegin
const_rervrse_iterator crbegin() const	返回set第一个元素的反向const迭代器，即cend
const_reverse_iterator crend() const	返回set最后一个元素下一个位置的反向const迭 代器，即crbegin
iterator lower_bound (const value_type& val) const;	返回迭代器的边界(>=)，即第一个大于或等于给定键的元素的位置的迭代器。
iterator upper_bound (const value_type& val) const;	返回迭代器的边界(>)，即第一个严格大于给定键的元素的位置的迭代器。
pair<iterator,iterator> equal_range (const value_type& val) const;	返回一个区间

4.set的容量

函数声明	功能介绍
bool empty() const	检查set是否为空，返回true，否则返回false
size_type size() const	返回set中有效元素的个数

5.set修改操作

函数声明	功能介绍
pair<iterator,bool> insert ( const value_type& x )	在set中插入元素x，实际插入的是<x, x>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回<x在set中的位置，false>
void erase ( iterator position )	删除set中position位置上的元素
size_type erase ( constkey_type& x )	删除set中值为x的元素，返回删除的元素的个数
void erase ( iterator first, iterator last )	删除set中[first, last)区间中的元素
void swap ( set<Key,Compare,Allocator>&st );	交换set中的元素
void clear ( )	将set中的元素清空
terator find ( constkey_type& x ) const	返回set中值为x的元素的位置
size_type count ( constkey_type& x ) const	返回set中值为x的元素的个数

6.set的使用例子

#include <iostream>
#include <set>

void test_set()
{
    int arr[] = { 2,4,9,7,4,3,1,5,9,8,7,7 };
    //使用一段区间构造set
    //set的作用排序+去重
    set<int> mySet(arr, arr + sizeof(arr) / sizeof(int));

    cout << mySet.size() << endl;//输出元素个数
    cout << mySet.count(7) << endl;//输出7的元素出现次数，输出1

    //迭代器遍历元素
    for (auto it = mySet.begin(); it != mySet.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    //返回迭代器遍历元素
    for (auto rit = mySet.rbegin(); rit != mySet.rend(); ++rit)
    {
        cout << *rit << " ";
    }
    cout << endl;

    // 查找元素
    auto it = mySet.find(2);
    if (it != mySet.end())
        cout << "Found element: " << *it << endl;
    else
        cout << "Element not found" << endl;

    // 删除元素
    mySet.erase(5);

    // 判断元素是否存在
    if (mySet.count(5) > 0)
        cout << "Element exists" << endl;
    else
        cout << "Element does not exist" << endl;

    set<int>::iterator itlow, itup;
    itlow = mySet.lower_bound(3); // >=
    itup = mySet.upper_bound(8);  // >
    cout << *itlow << endl;
    cout << *itup << endl;
    mySet.erase(itlow, itup);//删除这段区间的值

    for (auto e : mySet)
        cout << e << " ";
    cout << endl;

    //pair<iterator, iterator> equal_range(const value_type & val) const;
    //equal_range的函数原型, pair<iterator, iterator> 这个是返回类型，后面介绍，实际上是个类模板。
    auto ret = mySet.equal_range(1);
    itlow = ret.first;
    itup = ret.second;
    cout << *itlow << endl;
    cout << *itup << endl;
    //如果参数是1输出的是1和2，如果参数是2，输出的是2和9，从结果知道equal_range()相当于lower_bound()和upper_bound()的组合
    //返回的是第一个 >= 元素的值，第二个是 > 第一个下一个元素的值，实际不是给set使用的
    //而是给下面的multiset使用的
}
void test_multiset()
{
    //multiset只有排序，允许冗余
    multiset<int> s;
    s.insert(3);
    s.insert(3);
    s.insert(1);
    s.insert(1);
    s.insert(8);
    s.insert(9);
    s.insert(8);
    s.insert(2);

    for (auto e : s)
    {
        cout << e << " "; //1 1 2 3 3 8 8 9
    }
    cout << endl;

    //返回中序遍历的第一个3
    auto pos = s.find(3);
    while (pos != s.end())
    {
        cout << *pos << " ";
        ++pos;
    }
    cout << endl;

    cout << s.count(3) << endl;//count也是为了multiset准备的
    //因为set不存在一段重复连续的区间，而multiset存在一段连续重复的区间，可以使用equal_range对这段区间进行删除
    auto ret = s.equal_range(3);//如果该值小于容器里最大元素并且不存在则返回一个不存在的区间，否则报错
    auto itlow = ret.first;
    auto itup = ret.second;
    cout << *itlow << endl;
    cout << *itup << endl;
    s.erase(itlow, itup);

    for (auto e : s)
    {
        cout << e << " ";//1 1 2 8 8 9
    }
    cout << endl;
    //对比删除之后的结果，里面的3全部删除了
    //除了find，count，equal_range，set和multiset的其他函数使用方法可以说是一样的
}

int main() 
{
    //test_set();
    test_multiset();
    return 0;
}

set和multiset的区别：

C++中的set和multiset都是关联容器，用于存储和操作一组按照特定规则排序的唯一元素。它们之间的主要区别在于元素的唯一性和插入顺序。
1. 唯一性：set中的元素是唯一的，每个元素只能出现一次。而multiset允许多个元素具有相同的值，即允许重复元素存在。
2. 插入顺序：set按照元素的键值自动进行排序，插入元素时会根据键值的顺序将元素插入到正确的位置。multiset也按照元素的键值自动进行排序，但是可以插入具有相同键值的元素，并按照插入的顺序进行存储。
3. 查找和访问：set和multiset都支持快速查找和访问操作，可以根据键值快速查找特定的元素。
4. 删除操作：set和multiset都支持删除元素的操作，但是set只能删除指定键值的第一个元素，而multiset可以删除所有具有指定键值的元素。
总结：set适用于需要存储唯一值的情况，且对元素的顺序有要求。multiset适用于需要存储重复值的情况，且对元素的顺序有要求。

为什么equal_range是给multiset准备的？

equal_range函数是用来获取某个键值范围的函数。对于set容器来说，由于元素是唯一的，所以对于一个给定的键值，要么存在一个元素与之匹配，要么不存在。因此，对于set容器来说，equal_range函数返回的范围要么是一个元素要么是空范围。
而对于multiset容器来说，由于允许元素重复，所以对于一个给定的键值，可能存在多个元素与之匹配。equal_range函数就是为了方便地返回匹配范围而设计的。它返回一个pair对象，包含两个迭代器，第一个迭代器指向范围中第一个匹配元素的位置，第二个迭代器指向范围中最后一个匹配元素的下一个位置。
因此，multiset容器中的元素可以通过equal_range函数进行更加方便的查找和操作，而set容器中由于元素的唯一性，equal_range函数的返回结果只有两种情况：找到匹配元素或者未找到匹配元素。

3.2map和multimap的使用

3.2.1map的介绍

1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair : typedef pair<const key, T> value_type;
3. 在内部，map中的元素总是按照键值key进行比较排序的。
4. map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
5. map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
6. map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。

在使用C++中的map容器时，需要注意以下事项：
1. 区分键和值的类型：map是一种关联容器，它存储的是一对键值对。在定义map时，需要明确指定键和值的数据类型，并确保它们的类型匹配。
2. 确保键的唯一性：map要求每个键必须具有唯一性。当插入键值对时，如果键已经存在于map中，插入操作将不会成功。因此，在使用map时，需要确保键的唯一性，可以使用count()函数或find()函数来检查键是否已经存在。
3. 按键的顺序进行存储：map中的键值对是按照键的大小进行排序存储的。这使得在map中查找或迭代键值对时更加高效。但是需要注意的是，map并不是按照插入的顺序存储键值对的，而是按照键的大小进行排序的。
4. 使用迭代器进行遍历和操作：map提供了迭代器，可以使用迭代器来遍历map中的键值对，或者进行插入、删除和修改操作。在使用迭代器时，需要注意在修改map时可能会导致迭代器失效的情况，应该及时更新和处理迭代器。
5. 使用合适的比较函数：map默认使用小于运算符（<）进行键的比较，如果键的类型不支持小于运算符，需要自定义比较函数。在定义map时，可以通过函数对象或lambda函数来自定义比较函数，以确保正确的键的比较。
6. 了解复杂度：map的插入、删除和查找操作的平均复杂度是O(log n)，其中n是元素的数量。这使得map适用于在较大规模数据集上进行高效的查找和操作。但是，需要注意在插入、删除和查找大量元素时，复杂度可能会影响性能。
总之，在使用C++中的map容器时，需要注意键的唯一性、按键的顺序存储、使用迭代器进行遍历和操作，选择合适的比较函数，以及了解操作的复杂度。这些注意事项可以帮助更好地使用和理解C++中的map容器。

3.2.2map的使用

1.map的模板参数说明

key: 键值对中key的类型
T： 键值对中value的类型
Compare: 比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器
注意：在使用map时，需要包含头文件

2.map的构造

函数声明	功能介绍
explicit map (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());	构造一个空的map
template <class InputIterator> map (InputIterator first, InputIterator last, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());	使用[first，last)区间中的元素构造map
map (const map& x)	拷贝构造函数

3.map的迭代器

函数声明	功能介绍
begin()和end()	begin:首元素的位置，end最后一个元素的下一个位置
cbegin()和cend()	与begin和end意义相同，但cbegin和cend所指向的元素不能修改
rbegin()和rend()	反向迭代器，rbegin在end位置，rend在begin位置，其++和--操作与begin和end操作移动相反
crbegin()和crend()	与rbegin和rend位置相同，操作相同，但crbegin和crend所指向的元素不能修改

4.map的容量与元素访问

函数声明	功能介绍
bool empty ( ) const	检测map中的元素是否为空，是返回true，否则返回false
size_type size() const	返回map中有效元素的个数
mapped_type& operator[] (const key_type& k)	返回key对应的value

问题：当key不在map中时，通过operator获取对应value时会发生什么问题？

当key不在map中时，通过operator获取对应value时会发生以下问题之一：
1. 如果使用`[]`操作符获取值，当key不存在时，会自动插入一个新的key-value对到map中，其中value的默认值会被返回。这可能会导致意外的数据修改，因为插入的新key-value对可能与预期不符。
2. 如果使用`.at()`成员函数获取值，当key不存在时，会抛出一个`std::out_of_range`异常。这可以让程序员意识到key不存在，并进行相应的错误处理。
需要根据具体的需求来选择合适的操作方式。如果不希望自动插入新的key-value对并需要明确处理不存在的key的情况，则应该使用`.at()`成员函数。如果允许自动插入新的key-value对，并且希望默认值被返回，可以使用`[]`操作符。

5.map中元素的修改

函数声明	功能介绍
pair<iterator,bool> insert ( const value_type& x ) (和set一样，不允许 key 被修改，但是它是一个键值对，可以修改value。)	在map中插入键值对x，注意x是一个键值对，返回值也是键值对：iterator代表新插入元素的位置，bool代表释放插入成功
void erase ( iterator position )	删除position位置上的元素
size_type erase ( const key_type& x )	删除键值为x的元素
void erase ( iterator first, iterator last )	删除[first, last)区间中的元素
void swap ( map<Key,T,Compare,Allocator>& mp )	交换两个map中的元素
void clear ( )	将map中的元素清空
iterator find ( const key_type& x ) const	找到并返回该元素的位置的迭代器，否则返回end
const_iterator find ( const key_type& x ) const	找到并返回该元素的位置的const迭代器，否则返回cend
size_type count ( const key_type& x ) const	返回key为x的键值在map中的个数，注意map中key是唯一的，因此该函数的返回值要么为0，要么为1，因此也可以用该函数来检测一个key是否在map中
mapped_type& operator[] (const key_type& k)

6.map的使用例子

#include <iostream>
#include <map>

void test_map1()
{
	map<string, string> dict;

	pair<string, string> kv1("insert", "插入");
	//c++98
	dict.insert(kv1);
	dict.insert(pair<string, string>("sort", "排序"));
	dict.insert(make_pair("string", "字符串"));
	//c++11 支持多参数的构造函数隐身类型转换
	dict.insert({ "right", "右边" });//这种写法相当于上面三种写法
	//dict.insert("left", "左边" );//错误写法,要使用花括号

	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		//it->first = "xxx";//key不允许修改，因为key是const类型
		//it->second = "xxx";//value可以修改

		//cout << *it << " "; //报错是因为库里面没有重载pair的流插入和提取，因为C语言不支持返回多个参数
		//所以就把两个参数封装成一个结构(类)也就是pair，所以在返回时返回的是一个pair类的迭代器
		//cout << (*it).first << ":" << (*it).second << endl;//修改之后
		cout << it->first << ":" << it->second << endl;//改成使用->
		++it;
	}
	cout << endl;

	//范围for遍历
	for (const auto& kv : dict)//如果不修改最好加上const和引用减少不必要的空间浪费
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;

	//insert插入时如果key相同，value不相同，它会插入吗？
	//不插入，不覆盖，插入过程中，只比较key，value是否相同无所谓的
	//key已经有了就不插入了
	dict.insert(make_pair("string", "字符串"));
	map<string, string>::iterator it1 = dict.begin();
	while (it1 != dict.end())
	{
		cout << it1->first << ":" << it1->second << endl;//改成使用->
		++it1;
	}
}

void test_map2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜","苹果", "香蕉", "苹果", "香蕉", };
	map<string, int> countMap;
	//第一种写法
	//for (auto e : arr)
	//{
	//	auto it = countMap.find(e);
	//	if (it == countMap.end())
	//	{
	//		countMap.insert(make_pair(e, 1));
	//	}
	//	else
	//	{
	//		it->second++;
	//	}
	//}
	//第二种写法 -- 优化之后
	for (auto e : arr)
	{
		countMap[e]++;
	}

	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}

void test_map3()
{
	map<string, string> dict;
	dict.insert(make_pair("string", "字符串"));
	dict.insert(make_pair("sort", "排序"));
	dict.insert(make_pair("insert", "插入"));

	cout << dict["sort"] << endl;	//查找 + 读
	dict["map"];					//查找 + 插入
	dict["map"] = "映射，地图";		//查找 + 修改(替换)
	dict["insert"] = "xxx";			//查找 + 修改(替换)
	dict["set"] = "集合";			//插入 + 修改
}

int main()
{
	test_map3();

	return 0;
}

map和multimap的区别：

map和multimap是C++标准库提供的两种关联容器，它们的主要区别如下：

1. 键的唯一性：

map容器中的键是唯一的，每个键只能与一个值关联。如果尝试插入已经存在的键，则旧的键值对将被替换。

multimap容器中的键允许重复，每个键可以与多个值关联。可以插入多个具有相同键的键值对。

2. 元素的排序：

map容器中的元素按照键的大小进行排序，默认情况下使用键的比较函数或操作符进行排序。

multimap容器中的元素按照键的大小进行排序，但允许具有相同键的元素按照插入的顺序保持多个副本。

3. 存储结构：

map容器使用平衡二叉搜索树（通常是红黑树）来实现，这样可以保持元素的有序性。

multimap`容器也使用平衡二叉搜索树来实现。

4. API和功能：

map和multimap容器均提供了类似的API，包括插入、查找、删除等操作。

map容器还提供了operator[]运算符，可以通过键直接访问值，而multimap没有提供这个运算符。

综上所述，map适用于需要唯一键和排序的场景，而multimap适用于需要允许重复键和排序的场景。根据具体的需求，选择适合的关联容器可以提高代码的效率和可读性。

（API是Application Programming Interface（应用程序编程接口）的缩写，指的是一组定义了软件组件（函数、方法、类、对象等）之间交互的规范和约定。API定义了组件之间如何通信、调用和共享数据，提供了一种编程接口，使得开发者能够利用已经构建好的组件来实现自己的应用程序。

API可以是操作系统、软件库、框架或服务等的一部分。通过使用API，开发者可以通过调用提供的函数或方法来使用已经构建好的组件的功能，而无需了解其内部的具体实现细节。

API提供了一种抽象层，隐藏了底层的复杂性，并提供了常用操作的简化接口。它不仅可以简化开发过程，还可以促进代码的重用和模块化，提高软件的可靠性和可维护性。开发者可以根据API的规范和文档来正确地使用提供的功能，并根据需要进行自定义扩展。）

int main() 
{
    map<int, string> myMap;
    myMap.insert(make_pair(1, "apple"));
    myMap.insert(make_pair(2, "banana"));
    myMap.insert(make_pair(3, "cherry"));
    myMap.insert(make_pair(2, "pear")); // 键2已经存在，将替换值

    multimap<int, string> myMultimap;
    myMultimap.insert(make_pair(1, "apple"));
    myMultimap.insert(make_pair(2, "banana"));
    myMultimap.insert(make_pair(3, "cherry"));
    myMultimap.insert(make_pair(2, "pear")); // 键2允许重复，插入多个值

    std::cout << "Map:\n";
    for (const auto& pair : myMap) 
    {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    std::cout << "\nMultimap:\n";
    for (const auto& pair : myMultimap) 
    {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

结论：

1.multimap允许插入多个相同键值的键值对

2.没有重载operator[]。为什么没有重载？

multimap没有重载operator[]的主要原因是，由于键允许重复，使用operator[]来访问值的操作会变得复杂。

当使用operator[]时，我们希望通过键直接访问与之关联的值。在map中，由于键的唯一性，我们可以直接使用operator[]来进行访问，因为每个键只有一个关联的值。但在multimap中，一个键可以对应多个值，使用operator[]时就无法确定应该返回哪一个值。

如果multimap重载了operator[]，可能会有两种可能的行为：

1. 返回第一个与键匹配的值：这种行为可能会误导开发者，因为并不是所有与键匹配的值都是第一个插入的值。
2. 返回键对应的所有值的集合：这种行为可能会导致返回的对象变得复杂，因为需要存储多个值，并且不符合operator[]通常用于直接访问一个值的预期行为。

因此，在multimap中没有重载operator[]，而是提供了其他方法来访问和操作它的元素。

3.3map、multimap、set、multiset，这四个容器的区别

这四个容器都属于C++ STL中的关联容器，它们的区别主要体现在以下几个方面：

1. 存储方式：Map和Multimap是键值对存储方式，每个元素都包含一个键和一个值；Set和Multiset是单值存储方式，每个元素只包含一个值。

2. 键的唯一性：Map和Set要求键的唯一性，不允许重复的键存在；而Multimap和Multiset允许重复的键存在。

3. 排序方式：Map和Multimap会根据键的排序规则自动将元素按键排序；Set和Multiset会根据值的排序规则自动将元素排序。

4. 迭代器的稳定性：Map和Multimap中的迭代器在插入或删除元素后仍然有效，并指向相同的元素；Set和Multiset中的迭代器在插入或删除元素后可能失效。

5. 元素插入规则：Map和Set使用insert()函数插入元素，如果插入的键已经存在，则insert()不会改变容器；Multimap和Multiset使用insert()函数插入元素，无论键是否已经存在，都会插入。

6. 访问元素：Map和Multimap可以根据键来查找元素并进行访问；Set和Multiset的元素访问只能通过迭代器进行。

总结：

- Map适用于需要根据键快速查找值，并且需要键的排序功能。

- Multimap适用于允许重复键的场景，需要根据键快速查找值，并且需要键的排序功能。

- Set适用于需要快速判断某个元素是否存在，并且需要元素的排序功能。

- Multiset适用于允许重复元素的场景，需要快速判断某个元素是否存在，并且需要元素的排序功能。

4.底层结构

前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

4.1AVL树(高度平衡搜索二叉树)

4.1.1AVL树的概念

二叉树搜索树虽可以缩短查找的效率但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年，发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

1.它的左右子树都是AVL树

2.任何节点的左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

注：左子树减去右子树等于父节点的平衡因子，平衡因子的定义为：平衡因子 = 左子树的高度 - 右子树的高度。如果平衡因子为0，表示左子树和右子树高度相等；如果平衡因子为正数，表示左子树较高；如果平衡因子为负数，表示右子树较高。

注：AVL树不一定有平衡因子，使用平衡因子只是它的一种实现方式，因为这种方式简单一些

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在O(log_2 n)，搜索时间复杂度O(log_2 n)。

注：AVL树是一种自平衡二叉搜索树，其中每个节点的左子树包含的值都小于该节点本身的值，而每个节点的右子树包含的值都大于该节点本身的值。这与一般的二叉搜索树的性质相同。

4.1.2AVL树节点的定义

template<class K, class V>
class AVLTreeNode
{
	AVLTreeNode<K, V>* _left; // 该节点的左孩子
	AVLTreeNode<K, V>* _right; // 该节点的右孩子
	AVLTreeNode<K, V>* _parent; // 该节点的父亲
	pair<K, V> _kv;
	//pair类型的原型：
    // template <class T1, class T2>
    // struct pair
    // {
    // typedef T1 first_type;
    // typedef T2 second_type;
    // T1 first;
    // T2 second;
    // pair() 
    //     : first(T1()), second(T2())
    // {}
    
    // pair(const T1& a, const T2& b) 
    //     : first(a), second(b)
    // {}
    // };

	int _bf;// balance factor -- 平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)//新增节点的平衡因子都是0，因为以当前节点为一颗树，则它没有左右孩子
	{}
};

AVL树比二叉搜索树的节点多了一个成员，多了一个指向父节点的指针，这个父指针对于维护AVL树的平衡性质至关重要，因为在进行插入、删除等操作时，需要知道节点在树中的相对位置。通过比较节点与其子节点的平衡因子，以及利用父指针来调整树的结构，AVL树可以确保在任何修改操作之后都能重新获得平衡，从而保持操作效率。

4.1.3AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

1.按照二叉搜索树的方式插入新节点

2.调整节点的平衡因子

bool Insert(const pair<K, V>& kv)
{
    //1.先按照二叉搜索树的规则将节点插入到AVL树中
    if (_root == nullptr)
    {
        _root = new Node(kv);
        return true;
    }

    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else//相等，则什么该元素已存在
        {
            return false;
        }
    }
    //当走到位置为空时插入节点
    cur = new Node(kv);
    if (parent->_kv.first > kv.first)
        parent->_left = cur;
    else
        parent->_right = cur;
	//AVL树中要让插入的节点的_parent指针指向父节点，除了根节点之外
    cur->_parent = parent;//反向链接父节点

    //2.新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了
    //AVL树的平衡性。分为以下两种情况：
    //2.1如果更新完以后，平衡因子没有出现问题即 |bf| <= 1，说明新插入节点对树平衡结构
    //不影响，不需要厂里
    //2.2如果更新完以后，平衡出现问题 |bf| > 1，平衡结构受到影响，需要进行处理(旋转处理)
    while (parent)//更新平衡因子
    {
        //理解了平衡因子是如何增加或者减少的，有助于对于AVL树的理解就会更加深入(个人观点)
        //平衡因子的关系：每当增加一个节点，平衡因子都是从下往上更新的，从插入节点的父亲节点
        //开始的平衡因子开始更新，当父亲节点的平衡因子等于2或者-2时2就进行旋转。
        if (cur == parent->_right)
        {
            parent->_bf++;
        }
        else
        {
            parent->_bf--;
        }

        if (parent->_bf == 1 || parent->_bf == -1)
        {
            //继续更新
            parent = parent->_parent;
            cur = cur->_parent;
        }
        else if (parent->_bf == 0)
        {
            break;
        }
        else if (parent->_bf == 2 || parent->_bf == -2)
        {
            //需要旋转处理
            //1.让这颗子树平衡
            //2.降低这颗子树的高度
            if (parent->_bf == 2 && cur->_bf == 1)
            {
                RotateL(parent);//左单旋
            }
            else if (parent->_bf == -2 && cur->_bf == -1)
            {
                RotateR(parent);//右单旋
            }
            else if (parent->_bf == -2 && cur->_bf == 1)
            {
                RotateLR(parent);//左右双旋
            }
            else if (parent->_bf == 2 && cur->_bf == -1)
            {
                RotateRL(parent);//右左双旋
            }
            else
            {
                assert(false);
            }

            break;//旋转之后跳出循环
        }
        else//出现大于2或者小于-2的情况
        {
            assert(false);
        }
    }

    return true;
}

4.1.4AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：

1.新节点插入较高右子树的右侧---右右：左单旋(父节点的因子是2，孩子节点的因子是1)

//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;//sub -- 子(孩子)
		Node* subRL = subR->_left;//R是right的缩写，L是left的缩写

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* ppnode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (ppnode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
				ppnode->_left = subR;
			else
				ppnode->_right = subR;

			subR->_parent = ppnode;
		}

		parent->_bf = subR->_bf = 0;
	}

2.新节点插入较高左子树的左侧---左左：右单旋(父节点的因子是-2，孩子节点的因子是-1)

//右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* ppnode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;
		
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
				ppnode->_left = subL;
			else
				ppnode->_right = subL;
			subL->_parent = ppnode;
		}

		subL->_bf = parent->_bf = 0;
	}

3.新节点插入较高左子树的右侧---左右：先左单旋再右单旋(父节点的因子是-2，孩子节点的因子是1)

//左右旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == 1)
		{
			parent->_bf = 0;
			subLR->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else
			assert(false);//防止发生意外
	}

4.新节点插入较高右子树的左侧---右左：先右单旋再左单旋(父节点的因子是2，孩子节点的因子是-1)

//右左旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else if(bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

总结AVL树的四种旋转的条件要求：

4.1.5AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

1.验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

2.验证其为平衡树

每个节点子树高度差的绝对值不超过1。

节点的平衡因子是否计算正确

int _Height(Node* root)//计算树的高度
{
    if (root == NULL)
        return 0;
    int leftH = _Height(root->_left);
    int rightH = _Height(root->_right);

    return leftH > rightH ? leftH + 1 : rightH + 1;
}

bool IsBalance()//进行封装方便调用，封装之后不需要传参
{
    return _IsBalance(_root);
}
bool _IsBalance(Node* root)//判断一棵树是否是AVL树
	{
		if (root == NULL)
			return true;

		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		if (rightH - leftH != root->_bf)
		{
			cout << root->_kv.first << "节点平衡因子异常" << endl;
			return false;
		}

		return abs(leftH - rightH) < 2 && _IsBalance(root->_left) && 
            _IsBalance(root->_right);//判断所有的子树是否满足条件
	}

//测试用例
void Test_AVLTree1()
{
	//int a[] = { 16,3,7,11,9,26,18,14,15 };
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };

	AVLTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(make_pair(e, e));
		cout << e << "插入" << t1.IsBalance() << endl;//如果插入出现问题则输出0
	}

	t1.InOrder();
	cout << t1.IsBalance() << endl;
}

4.1.6AVL树的删除

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。具体实现可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

注：有空在实现。

4.1.7AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log_2 (N)。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

4.1.8代码

//AVLTree.h
#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include <assert.h>
#include <iostream>
#include <utility>
#include <time.h>
using namespace std;

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left; // 该节点的左孩子
	AVLTreeNode<K, V>* _right; // 该节点的右孩子
	AVLTreeNode<K, V>* _parent; // 该节点的父亲
	pair<K, V> _kv;
	int _bf;// balance factor -- 平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)//新增节点的平衡因子都是0，因为以当前节点为一颗树，则它没有左右孩子
	{}
};

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;

		cur->_parent = parent;//反向链接父亲节点 -- 除了根节点不用进行链接，因为根节点没有父亲

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}

			if (parent->_bf == 1 || parent->_bf == -1)
			{
				//继续更新
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//需要旋转处理
				//1.让这颗子树平衡
				//2.降低这颗子树的高度
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}

				break;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}

	int Height()
	{
		return _Height(_root);
	}
private:
	int _Height(Node* root)
	{
		if (root == NULL)
			return 0;
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		return leftH > rightH ? leftH + 1 : rightH + 1;
	}

	bool _IsBalance(Node* root)//判断一棵树是否是AVL树
	{
		if (root == NULL)
			return true;

		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		if (rightH - leftH != root->_bf)
		{
			cout << root->_kv.first << "节点平衡因子异常" << endl;
			return false;
		}

		return abs(leftH - rightH) < 2 && _IsBalance(root->_left) && _IsBalance(root->_right);//判断所有的子树是否满足条件
	}

	//左旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* ppnode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (ppnode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
				ppnode->_left = subR;
			else
				ppnode->_right = subR;

			subR->_parent = ppnode;
		}

		parent->_bf = subR->_bf = 0;
	}
	//右旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* ppnode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;
		
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}

		subL->_bf = parent->_bf = 0;
	}

	//左右旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == 1)
		{
			parent->_bf = 0;
			subLR->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	//右左旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;//提前记录subRL旋转前的平衡因子

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else if(bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

void Test_AVLTree1()
{
	//int a[] = { 16,3,7,11,9,26,18,14,15 };
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };

	AVLTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(make_pair(e, e));
		cout << e << "插入" << t1.IsBalance() << endl;//如果插入出现问题则输出0
	}

	t1.InOrder();
	cout << t1.IsBalance() << endl;
}

//main.cpp
#define _CRT_SECURE_NO_WARNINGS 1

#include "AVLTree.h"

int main()
{
	Test_AVLTree1();

	return 0;
}

4.2红黑树

4.2.1红黑树的概念

红黑树，也是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是近似平衡的。

4.2.2红黑树的性质

1. 每个节点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，不能出现连续的红色节点
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点(意思是每条路劲上都有相同数量的黑色节点)
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点也就是NIL)

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？因为，最短路径是全黑，最长路径是：一黑一红，红黑相间，根据规则3和4。

红黑树的性质保证了其最长路径中节点个数不会超过最短路径节点个数的两倍，这是由红黑树的性质和构造规则决定的。

首先，红黑树的性质之一是，从根节点到任意叶子节点的每条路径上的黑色节点个数是相同的，这个数目被称为树的黑色高度。因此，最短路径就是从根节点到叶子节点的路径，最长路径就是从根节点到最深的叶子节点的路径。

其次，红黑树的性质之二是，红色节点之后只能是黑色子节点。这保证了红黑树中红色节点之间不能直接相连，即红色节点之间必须经过黑色节点。所以，如果最长路径中出现了一个红色节点，那么它的子节点一定是黑色节点。而在最短路径中，只有黑色节点。

综上所述，最长路径中的红色节点都是有对应的黑色节点作为子节点的，而最短路径只包含黑色节点。由于红黑树的性质之一是根节点到叶子节点的每条路径上的黑色节点个数是相同的，因此最长路径中的黑色节点个数与最短路径中的黑色节点个数相等。而红色节点本身并不增加所有路径的长度，所以只有当一条路径增加黑色节点的时候所有路径都要增加黑色节点，所以在插入新增节点时不能插入黑色节点只能是红色节点，为了保持红黑树的平衡和性质。因此，最长路径中节点个数不会超过最短路径节点个数的两倍。

假设全部的黑色节点有N个，那么最短路径的长度是log(N+1)，而在最坏的情况下，红色节点可以出现在任何位置，但它们不会减少路径的长度，只是改变了红色和黑色节点的分布。因此，最长路径的长度是2 * (最短路径的长度)，即2 * log(N+1)。但是，由于根节点是黑色，所以最长路径的长度总是比最短路径长一个单位，即2 * log(N+1) + 1。

所以，最长路径的长度是2 * log(N+1) + 1。这个公式反映了在最坏情况下红黑树最长路径的长度，其中红色节点最多可以使路径长度增加到最短路径长度的两倍，再加上根节点本身的长度，根据性质4。

假设全部黑色节点的数量为N，在最坏的情况下，红黑树的形状可以接近一条链，这种情况下，总节点数大约是黑色节点数的两倍再加一。即如果黑色节点数为 (N)，那么最坏情况下总节点数的下限大约是 (2N + 1)。

在最优的情况下，红黑树接近平衡的二叉树，这时候每个黑色节点最多有一个红色父节点和一个红色子节点。在这种情况下，总节点数的下限大约是 (3N - 1)（每个黑色节点可以有一个红色父节点和一个红色子节点，再加上一个额外的黑色节点作为根节点）。因此，红黑树的总节点数范围大致在 (2N + 1) 到 (3N - 1) 之间。

4.2.3红黑树节点的定义

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left; // 该节点的左孩子指针
	RBTreeNode<K, V>* _right; // 该节点的右孩子指针
	RBTreeNode<K, V>* _parent; // 该节点的父节点指针
	pair<K, V> _kv;
	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)//缺省参数使用RED，宁愿违反规则3，也不违反规则4 -- 默认新增为红色节点
	{}
};

4.2.4红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

1. 按照二叉搜索的树规则插入新节点

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

        //插入新节点
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;

		cur->_parent = parent;

		while (parent && parent->_col == RED)//如果父节点为红需要进行处理，违反性质3
		{
			//对新增节点进行处理
            //....
		}
		_root->_col = BLACK;//保持根节点是颜色是黑的
		return true;
	}

2.检测新节点插入后，红黑树的性质是否造到破坏

因为新节点的默认颜色是红色，因此:如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整;但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论:

插入函数的代码：

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;

		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//情况1: u存在且为红，变色处理，并继续往上走
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;	// parent -- 父节点
					uncle->_col = BLACK;	// uncle -- 叔叔节点
					grandfather->_col = RED;// grandfather -- 祖父节点

					//继续网上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2 + 3：u不存在或者u存在且为黑，旋转 + 变色
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED; // 本身是红的
						grandfather->_col = RED;
					}
					break;
				}
			}
			else //(grandfather->_right == parent)
			{
				Node* uncle = grandfather->_left;
				//情况1: u存在且为红，变色处理，并继续往上走
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;	// parent -- 父节点
					uncle->_col = BLACK;	// uncle -- 叔叔节点
					grandfather->_col = RED;// grandfather -- 祖父节点

					//继续网上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2 + 3：u不存在或者u存在且为黑，旋转 + 变色
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

4.2.5总结红黑树的插入情况：

如果看不懂图可以根据总结来进行写代码或者分析

4.2.6红黑树的验证

红黑树的检测分为两步：
1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
2. 检测其是否满足红黑树的性质

bool IsBalance()//检查这颗树是否是红黑树
	{
		if (_root && _root->_col == RED)//检查根节点颜色
		{
			cout << "根节点颜色是红色" << endl;
			return false;
		}
		
		//benchmark -- 基准值,用来记录一条路径的黑色节点数量,然后用来和其他路径的黑色
		//节点数量进行相比较,判断每一条路径的黑色节点数量是否相等
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;
			cur = cur->_left;
		}
		//检查是否存在连续的红色节点
		return _Check(_root, 0, benchmark);
	}

bool _Check(Node* root, int blackNum, int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == BLACK)//计算每一条路径黑节点的个数
		{
			++blackNum;
		}

		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		return _Check(root->_left, blackNum, benchmark) && _Check(root->_right, blackNum, benchmark);
	}

4.2.7红黑树的删除

可参考：《算法导论》或者《STL源码剖析》

注：有空再实现。

红黑树 - _Never_ - 博客园

4.2.8 红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(log_2 N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

4.2.9代码

//RBTree.h
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <time.h>
using namespace std;

enum Colour
{
	RED,//红
	BLACK//黑
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left; // 该节点的左孩子指针
	RBTreeNode<K, V>* _right; // 该节点的右孩子指针
	RBTreeNode<K, V>* _parent; // 该节点的父节点指针
	pair<K, V> _kv;
	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)//缺省参数使用RED宁愿违反规则3，也不违反规则4 -- 默认新增为红色节点
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	~RBTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;

		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//情况1: u存在且为红，变色处理，并继续往上走
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;	// parent -- 父节点
					uncle->_col = BLACK;	// uncle -- 叔叔节点
					grandfather->_col = RED;// grandfather -- 祖父节点

					//继续网上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2 + 3：u不存在或者u存在且为黑，旋转 + 变色
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED; // 本身是红的
						grandfather->_col = RED;
					}
					break;
				}
			}
			else //(grandfather->_right == parent)
			{
				Node* uncle = grandfather->_left;
				//情况1: u存在且为红，变色处理，并继续往上走
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;	// parent -- 父节点
					uncle->_col = BLACK;	// uncle -- 叔叔节点
					grandfather->_col = RED;// grandfather -- 祖父节点

					//继续网上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2 + 3：u不存在或者u存在且为黑，旋转 + 变色
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	bool IsBalance()//检查这颗树是否是红黑树
	{
		if (_root && _root->_col == RED)//检查根节点颜色
		{
			cout << "根节点颜色是红色" << endl;
			return false;
		}
		
		//benchmark -- 基准值,用来记录一条路径的黑色节点数量,然后用来和其他路径的黑色
		//节点数量进行相比较,判断每一条路径的黑色节点数量是否相等
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;
			cur = cur->_left;
		}
		//检查是否存在连续的红色节点
		return _Check(_root, 0, benchmark);
	}

	int Height()
	{
		return _Height(_root);
	}

private:
	void _Destroy(Node* root)
	{
		if (root == nullptr)
			return;

		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		return leftH > rightH ? leftH + 1 : rightH + 1;
	}

	bool _Check(Node* root, int blackNum, int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		return _Check(root->_left, blackNum, benchmark) && _Check(root->_right, blackNum, benchmark);
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
	//左旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* ppnode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (ppnode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
				ppnode->_left = subR;
			else
				ppnode->_right = subR;

			subR->_parent = ppnode;
		}
	}
	//右旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* ppnode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}
private:
	Node* _root = nullptr;
};

void Test_RBTree1()
{
	//int a[] = { 16,3,7,11,9,26,18,14,15 };
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };

	RBTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(make_pair(e, e));
	}

	t1.InOrder();
}

void Test_RBTree2()
{
	srand((unsigned int)time(0));
	const size_t N = 5000000;
	RBTree<int, int> t;
	for (size_t i = 0; i < N; i++)
	{
		size_t x = rand() + i;
		t.Insert(make_pair(x, x));
	}

	cout << t.IsBalance() << endl;
	cout << t.Height() << endl;
}

//main.cpp
#include "RBTree.h"

int main()
{
	Test_RBTree1();
	return 0;
}

4.3红黑树模拟实现SRL中的map和set

如何使用同一颗红黑树封装map和set？其中的区别在于如何存储和操作数据：

1. 对于Map的封装：每个节点包含一个键值对，其中键用于快速查找对应的值。节点的插入和删除操作需要根据键的大小来调整树的结构。对于查找操作，可以通过比较节点的键与目标键的大小来判断应该向左子树还是右子树查找，直到找到对应的键值对或者遍历完整个树。
2. 对于Set的封装：每个节点只包含一个元素值，用于去重和快速判断是否包含某个元素。节点的插入和删除操作同样需要根据元素值的大小来调整树的结构。对于查找操作，同样可以通过比较节点的元素值与目标元素的大小判断应该向左子树还是右子树查找，直到找到对应的元素值或者遍历完整个树。

//修改之后的红黑树
//RBTerr.h
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <time.h>
using namespace std;

enum Colour
{
	RED,//红
	BLACK//黑
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left; // 该节点的左孩子
	RBTreeNode<T>* _right; // 该节点的右孩子
	RBTreeNode<T>* _parent; // 该节点的双亲
	T _data;
	Colour _col;

	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)//缺省参数使用RED宁愿违反规则3，也不违反规则4 -- 默认新增为红色节点
	{}
};

template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;//成员

	__RBTreeIterator(Node* node)
		:_node(node)
	{}

	//1.typedef __RBTreeIterator<T, T&, T*> iterator; 拷贝构造
	//2.typedef __RBTreeIterator<T, const T&, const T*> const_iterator;支持普通迭代器构造const迭代器的构造函数
	__RBTreeIterator(const __RBTreeIterator<T, T&, T*>& it)
		:_node(it._node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	Self& operator++()
	{
		if (_node->_right)
		{
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

			_node = subLeft;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* subRight = _node->_left;
			while (subRight->_right)
			{
				subRight = subRight->_right;
			}

			_node = subRight;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}
};

//KeyOfT -- 仿函数
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;
	typedef __RBTreeIterator<T, const T&, const T*> const_iterator;

	iterator begin()
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}

		return iterator(cur);
	}

	iterator end()
	{
		return iterator(nullptr);
	}

	iterator begin() const
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}

		return iterator(cur);
	}

	iterator end() const
	{
		return iterator(nullptr);
	}

	~RBTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_date) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_date) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);//iterator(_root)是一个匿名对象
		}

		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}

		cur = new Node(data);
		Node* newnode = cur;
		if (kot(parent->_data) > kot(data))
			parent->_left = cur;
		else
			parent->_right = cur;

		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//情况1: u存在且为红，变色处理，并继续往上走
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;	// parent -- 父节点
					uncle->_col = BLACK;	// uncle -- 叔叔节点
					grandfather->_col = RED;// grandfather -- 祖父节点

					//继续网上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2 + 3：u不存在或者u存在且为黑，旋转 + 变色
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED; // 本身是红的
						grandfather->_col = RED;
					}

					break;
				}
			}
			else //(grandfather->_right == parent)
			{
				Node* uncle = grandfather->_left;
				//情况1: u存在且为红，变色处理，并继续往上走
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;	// parent -- 父节点
					uncle->_col = BLACK;	// uncle -- 叔叔节点
					grandfather->_col = RED;// grandfather -- 祖父节点

					//继续网上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2 + 3：u不存在或者u存在且为黑，旋转 + 变色
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(iterator(newnode), true);
	}

	bool IsBalance()//检查这颗树是否是红黑树
	{
		if (_root && _root->_col == RED)//检查根节点颜色
		{
			cout << "根节点颜色是红色" << endl;
			return false;
		}
		
		//benchmark -- 基准值,用来记录一条路径的黑色节点数量,然后用来和其他路径的黑色
		//节点数量进行相比较,判断每一条路径的黑色节点数量是否相等
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;
			cur = cur->_left;
		}
		//检查是否存在连续的红色节点
		return _Check(_root, 0, benchmark);
	}

	int Height()
	{
		return _Height(_root);
	}

private:
	void _Destroy(Node* root)
	{
		if (root == nullptr)
			return;

		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		return leftH > rightH ? leftH + 1 : rightH + 1;
	}

	bool _Check(Node* root, int blackNum, int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		return _Check(root->_left, blackNum, benchmark) && _Check(root->_right, blackNum, benchmark);
	}

	//左旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* ppnode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (ppnode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
				ppnode->_left = subR;
			else
				ppnode->_right = subR;

			subR->_parent = ppnode;
		}
	}
	//右旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* ppnode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}
private:
	Node* _root = nullptr;
};

//使用红黑树封装的map
//map.h
#define _CRT_SECURE_NO_WARNINGS 1

#pragma once

namespace bit
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		//typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _t.Insert(make_pair(key, V()));//V()匿名对象会被自动初始化为0
			//return ret.first._node->_data.second;
			return ret.first->second;//因为中间调用了operator->，所以可以简写为这种写法
		}

		pair<iterator, bool> insert(const pair<const K, V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};


	void test_map1()
	{
		map<string, string> dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("string", "字符串"));
		dict.insert(make_pair("count", "计数"));
		//dict.insert(make_pair("string", "(字符串)"));//插入失败

		map<string, string>::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}

	void test_map2()
	{
		string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };
		map<string, int> countMap;
		
		for (auto& e : arr)
		{
			countMap[e]++;
		}
		
		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
	}
}

//使用红黑树封装的set
//set.h
#define _CRT_SECURE_NO_WARNINGS 1

#pragma once

namespace bit
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

	public:
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
	

	void test_set1()
	{
		set<int> s;
		s.insert(3);
		s.insert(1);
		s.insert(2);
		//pair<set<int>::iterator, bool> pa = s.insert(2);
		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
}

总结：map和set不过都是通过调用红黑树的接口进行封装来使用而已。