map && set

目录

1. 序列式容器和关联式容器

2. 键值对

2.1. make_pair

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

3.1. set(Key模型)

3.1.1. std::set::find && std::set:count

3.2. map(Key-Value模型)

3.2.1. std::map::insert 

3.2.2. operator[]

3.3. multimap

3.4. multiset

3.4.1. std::multiset::find

3.4.2. std::multiset::count

3.5. 关于map和set的练习题

3.5.1. 前K个高频单词：

3.5.2.  两个数组的交集

4. 底层结构 

4.1. AVL树

4.1.1 AVL树的插入

4.1.1.1 平衡因子的更新

4.1.1.2. AVL树的旋转

4.1.1.2.1. 左单旋

4.1.1.2.2. 右单旋

4.1.1.2.3. 左右双旋

​编辑

4.1.1.2.4. 右左双旋

 4.1.1.3. 验证AVL树的插入

4.1.1.4. AVL树插入的完整实现

4.2. 红黑树

4.2.1. 红黑树的插入

4.2.1.1. 情况一：新增节点的父亲为空

4.2.1.2. 情况二：新增节点的父亲非空且为黑色节点

4.2.1.3. 情况三：当父亲为红节点，叔叔存在且为红

 4.2.1.4. 情况四：当父亲为红节点，叔叔不存在或者存在为黑

4.2.1.5. 情况五：父亲为红、叔叔不存在或者为黑

 4.2.1.5. 验证红黑树的插入

4.2.1.6.  rb_tree插入的完整实现

4.3. map和set的封装

4.3.1. map的封装

4.3.2. set的封装

---

1. 序列式容器和关联式容器

在之前我们已经学过了一些容器，例如string、vector、list等它们都被称之为序列式容器

那什么叫做序列式容器？什么叫做关联式容器呢？

序列式容器：

序列式容器是指一种数据结构其底层为线性序列的数据结构，里面存储的是元素本身。

序列式容器的特点是元素之间有固定的次序关系，并且可以根据位置进行访问。常见的序列式容器包括list、vector、string、deque等

这些容器在使用时可以根据需要进行插入、删除、查找等操作，还可以使用迭代器来遍历容器中的元素。序列式容器提供了不同的访问和操作方式，满足不同场景下的需求。

关联式容器：

关联式容器是指一种数据结构，用于存储和管理以关键字（Key）为主要标识的数据元素。与序列式容器不同，关联式容器的元素是按照关键字进行组织和访问的。

关联式容器通常使用红黑树（Red-Black Tree）等高效的数据结构来实现，在插入、删除、查找等操作上具有较高的效率。它们提供了基于关键字的访问和操作能力。

常见的关联式容器包括集合（Set）、多重集合（Multiset）、映射（Map）和多重映射（Multimap）等。集合和多重集合存储唯一的关键字（Key），映射和多重映射存储关键字-值（Key-Value）对（也被称之为键值对）。

关联式容器可以根据关键字（Key）进行快速的查找，使得数据的访问更加高效。同时，关联式容器往往还提供了排序、去重等功能，适用于需要按照关键字进行检索和排序的场景。

2. 键值对

键值对（Key-Value Pair）是一种数据表示方式，用于将一个值（Value）与一个唯一标识符（Key）相关联，我们可以通过Value找到Key。

在键值对中，键（Key）用于唯一标识和索引值，而值（Value）则是与该键关联的数据。通过使用键作为索引，可以快速地访问和操作与之相关联的值。

键值对可以用于表示和管理各种数据，例如字典、映射和属性列表等。它是一种非常常见和重要的数据组织方式，广泛应用于计算机科学和编程领域。

在关联式容器中，键值对经常被使用。例如，在映射（Map）中，每个键对应一个唯一的值（这里的键具有唯一性）；在多重映射（Multimap）中，一个键可以对应多个值（即允许相同的键值）；在属性列表中，键值对用于表示对象的属性和对应的取值等。通过键值对的方式，我们可以方便地访问和操作数据。

而在SGI-STL(Standard Template Library)中定义了名为pair的键值对结构：

pair是一个模板类，用于表示具有两个成员的键值对

pair的定义如下：

template 
struct pair 
{
    typedef T1 first_type;   // 键类型
    typedef T2 second_type;  // 值类型

    T1 first;   // 键(Key)
    T2 second;  // 值(Value)

    // 构造函数
    pair()
    :first(T1())
    ,second(T2())
    {}
    
    pair(const T1& x, const T2& y)
    :first(x)
    ,second(y)
    {}  

    template 
    pair(const pair& p)
    :first(p.first)
    ,seconde(p.second)
    {}   
};

pair模板类具有两个模板参数，分别表示键的类型（T1）和值的类型（T2）。它包含了两个公有成员变量 first 和 second，分别用于存储键和值。

pair提供了多个构造函数，使得可以方便地创建和初始化键值对对象。除了默认构造函数外，还有一个接受键和值作为参数的构造函数，以及一个模板构造函数，允许从其他类型的 pair 对象转换。

通过使用 pair，我们可以方便地组织和操作键值对数据。在STL的各种关联式容器中，经常使用 pair 来表示键值对，以实现高效的数据存储和访问。

2.1. make_pair

make_pair 是一个 C++ STL（标准模板库）中的函数模板，用于创建一个 pair 对象。

pair 是一个模板类，可以保存两个不同类型的值。make_pair 函数模板允许你通过传递两个值作为参数，创建一个 pair 匿名对象，并自动推断出适当的类型

在 C++ STL 中，make_pair 函数模板的具体实现通常是位于  头文件中，下面是它的一种简单实现示例：

template 
pair make_pair(T1 t, T2 u) 
{
    return pair(t, u);
}

上述示例只是make_pair一种常见的实现方式，但实际实现可能会有所不同。在编写代码时，通常可以直接使用  头文件中的 make_pair，而不需要关心其具体实现细节。 

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

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

3.1. set(Key模型)

T: set 中存放元素的类型，实际在底层存储 的键值对。

Compare ： set 中元素默认按照小于来比较

Alloc ： set 中元素空间的管理方式，使用 STL 提供的空间配置器管理

set是一种集合模型（Set Model），它是关联式容器的一种。集合模型是一种数据结构，用于存储一组唯一值的集合，并提供高效的插入、删除和查找操作。

在集合模型中，每个元素都是唯一的（Key值是唯一的），不会存在重复值。集合模型通常基于某种平衡树或哈希表实现，以确保高效的查找和去重功能。

C++标准库中的 set 是一种基于红黑树（Red-Black-Tree）的关联式容器。C++中的set以红黑树的方式存储唯一值，并提供了一系列的操作，如插入新元素、删除指定元素、查找特定元素等。由于使用了红黑树作为底层数据结构，set 在插入和删除操作时能够维持自动的排序和平衡，具有较快的查找性能。

set 提供了一系列的成员函数和算法，用于操作和访问集合中的元素。它的特点是按照升序排列元素，并且每个元素都是唯一的。如果需要存储多个相同值的元素，可以使用 multiset 容器。set 在各种场景中都有广泛的应用，例如去重、排序、查找等。

在 C++ 的 set 容器中，元素的键值是不可修改的。这是因为 set 是基于红黑树实现的，红黑树中的每个元素节点的键值是用于按照特定顺序进行排序和比较的，保持元素的有序性。

一旦将一个元素插入到 set 中，它的键值就不能再被修改。如果需要修改元素的键值，你需要先将该元素从 set 中删除，然后修改其值，最后再将修改后的元素重新插入到 set 中。

测试一：验证set中的Key是否具有唯一性和它的排序性

void Test1(void)
{
	std::vector v{ 6, 2, 4, 3, 1, 2, 6, 4, 3, 8, 7 };
	std::set s;
	for (auto e : v)
	{
		s.insert(e);
	}
	std::set::iterator it = s.begin();
	while (it != s.end())
	{
		std::cout << *it << " ";
		++it;
	}
	std::cout << std::endl;
}

测试结果：

1 2 3 4 6 7 8 

我们发现，std::set中的元素的确不可重复， 且迭代器遍历的顺序默认是升序。即set的作用：去重 + 排序

 测试二：set中的Key值是否可以被修改

 可以看到，在 C++ 的 set 容器中，元素的键值是不可修改的。

3.1.1. std::set::find && std::set:count

/*
***value_type: The first template parameter (T)
***size_type: usually the same as size_t
*/
iterator find (const value_type& val) const;
size_type count (const value_type& val) const;

set::find()可以判断某个Key在不在

找到了返回迭代器的位置，如果没找到返回end()

set::count()也可以判断某个Key在不在

如果存在返回1，otherwise，返回0

测试三：测试find

void Test3(void)
{
	std::vector v{ 6, 2, 4, 3, 1, 2, 6, 4, 3, 8, 7 };
	std::set s;
	for (auto e : v)
	{
		s.insert(e);
	}
	int x = 0;
	while (1)
	{
		std::cin >> x;
		std::set::iterator pos = s.find(x);
        //找到了返回对应迭代器,没找到返回end()        
		if (pos != s.end())
		{
			std::cout << "找到了" << std::endl;
		}
		else
		{
			std::cout << "没找到" << std::endl;
		}
	}
}

测试四： 测试count

void Test4(void)
{
	std::vector v{ 6, 2, 4, 3, 1, 2, 6, 4, 3, 8, 7 };
	std::set s;
	for (auto e : v)
	{
		s.insert(e);
	}

	int x = 0;
	while (1)
	{
		std::cin >> x;
		size_t ret = s.count(x);
		// 找到了返回1,没找到返回0
		if (ret)
		{
			std::cout << "找到了" << std::endl;
		}
		else
		{
			std::cout << "没找到" << std::endl;
		}
    }
}

3.2. map(Key-Value模型)

key: 键值对中Key 的类型

T ： 键值对中V alue 的类型

Compare: 比较器的类型， map 中的元素是按照 key 来比较的，缺省情况下按照小于来比较，一般情况下( 内置类型元素 ) 该参数不需要传递，如果无法比较时 ( 自定义类型 ) ，需要用户自己显式传递比较规则( 一般情况下按照函数指针或者仿函数来传递 )

Alloc ：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的

空间配置器

注意：在使用 map 时，需要包含头文件 #include

map 是 C++ STL（标准模板库）中的一个关联容器，它提供了一种将键（key）与值（value）关联起来的方式。

map 类似于字典，它由一系列键值对组成。每个键与一个对应的值相关联，这样就可以通过键来快速查找和访问对应的值。map 中的键是唯一的，每个键对应一个值。

map 内部使用一种红黑树的数据结构来实现，它能够保持键的有序性，这使得 map 在数据查找方面非常高效。对于大量的数据，map 的插入、查找和删除操作的时间复杂度都是 O(log n)。

3.2.1. std::map::insert 

/*
***value_type :  pair
***key_type   :  The first template parameter (Key)
***mapped_type:  The second template parameter (T)
*/
single element (1)	
pair insert (const value_type& val);
with hint (2)	
iterator insert (iterator position, const value_type& val);
range (3)	
template 
  void insert (InputIterator first, InputIterator last);

测试六：测试insert(1)

void Test6(void)
{
	std::map dict;
	dict.insert(std::pair("current", "当前的"));
	dict.insert(std::pair("note", "注意"));
	// 但是我们一般不使用上面的方式(通过构造pair的匿名对象)
	// 我们一般使用std::make_pair
    // make_pair会根据我们传入的参数自动构造pair的匿名对象并返回
	dict.insert(std::make_pair("delete", "删除"));
	dict.insert(std::make_pair("segmentation", "分割"));
	dict.insert(std::make_pair("exist", "存在"));

    // map支持插入相同的Key吗？
	dict.insert(std::make_pair("note", "笔记"));

	// 如何遍历 ？
	std::map::iterator it = dict.begin();
	while (it != dict.end())
	{
		// note: 如果这里直接对迭代器进行解引用，那么会调用迭代器的operator*，返回的是一个pair的对象
		// 因此在这里要以下面的方式取pair的first(Key)和second(Value)
		//std::cout << (*it).first << ":" << (*it).second << std::endl;
		// 但是,我们并不喜欢上面的方式(太麻烦了),我们直接调用迭代器的operator->，返回的是pair对象的地址
		// 因此此时在用->就可以取到pair的first(Key)和second(Value)
        // 但是为了代码的可读性,编译器省略了这个->
		std::cout << it->first << ":" << it->second << std::endl;
		++it;
	}
	std::cout << std::endl;
}

测试结果：

current:当前的
delete:删除
exist:存在
note:注意
segmentation:分割

从结果上面来看，map不支持插入相同的Key（map不支持键值冗余）。

当使用 std::map 的 insert 函数插入一个键值对时，如果插入的键已经存在，则 insert 不会进行插入操作，而是保持 map 不变，返回一个迭代器指向已存在的键值对。

具体地说，如果插入的键已经在 std::map 中存在，insert 函数将返回一个指向已存在键值对的迭代器，而不会插入新的键值对。如果插入的键是新的，则会将该键值对插入 std::map 中，并返回指向新插入键值对的迭代器。

因此可以认为：insert有插入+修改和查找的功能；

当插入一个未存在的Key就是插入Key+修改Valuye

当插入一个已存在的Key，通过返回值（pair）的first可以得到这个已经存在的Key的迭代器，可以起到查找的作用。

测试七：测试insert(2)

统计动物的个数，利用map，如果存在该动物就++Value，不存在就直接插入即可

void Test7(void)
{
	std::map get_count;
	std::string str[] = { "老虎", "狮子", "大熊猫", "长颈鹿", "孔雀" };
	srand((unsigned int)time(nullptr));
	for (size_t i = 0; i < 10; ++i)
	{
        std::string tmp = str[rand() % 5];
		std::map::iterator pos = get_count.find(tmp);
        // 如果该动物没存在,就插入map中,并将Value赋值为1
		if (pos == get_count.end())
		{
			get_count.insert(make_pair(tmp,1));
		}
        // 如果该动物存在,将Value值++即可
		else
		{
			++pos->second;
		}
	}
	auto it = get_count.begin();
	while (it != get_count.end())
	{
		std::cout << it->first << ":" << it->second << std::endl;
		++it;
	}
	std::cout << std::endl;
}

测试结果：

长颈鹿:2
大熊猫:1
孔雀:3
老虎:2
狮子:2

3.2.2. operator[]

/*
***value_type :  pair
***key_type   :  The first template parameter (Key)
***mapped_type:  The second template parameter (T)
*/
pair insert (const value_type& val);

mapped_type& operator[] (const key_type& k);

// A call to this function is equivalent to:
(*((this->insert(make_pair(k,mapped_type()))).first)).second

表达式 (*((this->insert(std::make_pair(k, mapped_type()))).first)).second 可以被理解为在 std::map 中插入一个键值对，并返回插入的键所对应的值。

让我们逐步解释这个表达式：

1. 首先，std::make_pair(k, mapped_type()) 使用键 k 和默认构造的值 mapped_type() （假设 mapped_type 是键 k 对应的值类型的占位符）创建一个新的键值对pair。
2. 然后，this->insert(std::make_pair(k, mapped_type())) 将上述键值对插入到当前的 std::map 对象中。这个 insert 操作返回一个 std::pair 对象(这个pair对象的first和second分别是：iterator,bool)，其中的 first 成员表示插入的迭代器位置，second 成员表示是否进行了插入操作（true 表示插入成功，false 表示键已存在）。
3. 接着，*((this->insert(std::make_pair(k, mapped_type()))).first) 解引用插入操作返回的迭代器，即得到插入的键值对。
4. 最后，(*((this->insert(std::make_pair(k, mapped_type()))).first)).second 取得插入的键值对的值部分，即当前插入的键所对应的值。

这个表达式的目的是获取插入键 k 对应的值，无论是已经存在的键还是新插入的键。它的效果等同于使用 [] 运算符来访问键对应的值，例如 map[k]。通过这个表达式，可以确保插入操作执行后，可以立即获取到插入的键所对应的值，即使该键已存在

insert已经存在的Key，会返回<之前已经存在的Key的迭代器,false>

insert不存在的Key，会返回<插入Key的迭代器,true>

operator[] 的功能：

1. 插入             (如果这个Key不存在)

2. 修改             (如果这个Key存在，修改Value)

3. 插入 + 修改 (这个Key不存在插入，然后修改Value)

4. 查找             (这个Key存在,且不修改Value)

因此上面统计动物个数的代码，我们可以用operator[]实现：

void Test8(void)
{
	std::map get_count;
	std::string str[] = { "老虎", "狮子", "大熊猫", "长颈鹿", "孔雀" };
	srand((unsigned int)time(nullptr));
	for (size_t i = 0; i < 10; ++i)
	{
        // 如果这个动物不存在那么就是:  插入Key + 修改Value
        // 如果这个动物存在那么就是  :  修改Value
		++get_count[str[rand() % 5]];
	}
	auto it = get_count.begin();
	while (it != get_count.end())
	{
		std::cout << it->first << ":" << it->second << std::endl;
		++it;
	}
	std::cout << std::endl;
}

我们上面的dict也可以用operator[]来实现：

void Test9(void)
{
	std::map dict;
	dict.insert(std::pair("current", "当前的"));
	dict.insert(std::pair("note", "注意"));
	// 但是我们一般不使用上面的方式(通过构造pair的匿名对象)
	// 我们一般使用std::make_pair
	dict.insert(std::make_pair("delete", "删除"));
	dict.insert(std::make_pair("segmentation", "分割"));
	dict.insert(std::make_pair("exist", "存在"));

	// 但是，我们有时候也会用operator[]完成一系列工作,利用operator[]的四个功能:
	/*operator[] 的功能：
	***插入(如果这个key不存在)
	***修改(如果这个key存在)
	***插入 + 修改(这个key不存在插入，然后修改Value)
    ***查找 (这个Key存在,且不修改Value)
	*/
	dict["step"];              // "step"这个Key不存在,直接插入Key
	dict["step"] = "步骤";     // "step"这个Key存在,修改Value
	dict["patience"] = "耐心"; // "patience"这个Key不存在,通过返回值的引用实现 插入Key + 修改Value
    std::cout <<"exist: " << dict["exist"] << std::endl;  //注意：当要查找的Key是存在的才是查找,otherwise,就是插入了
	
	auto it = dict.begin();
	while (it != dict.end())
	{
		std::cout << it->first << ":" << it->second << std::endl;
		++it;
	}
	std::cout << std::endl;
}

测试结果：

exist: 存在
current:当前的
delete:删除
exist:存在
note:注意
patience:耐心
segmentation:分割
step:步骤 

有了map，我们之前遇到的一些问题，现在就简单多了，例如，下面的这道题：

138. 随机链表的复制 - 力扣（LeetCode）

以前我们的做法就是分为三步：

1、遍历原表，复制原表节点，尾插到原节点的后面

2、 根据原节点，处理random        

a. 如果原表中节点的random为nullptr，那么新表中的节点的random也会nullptr        

b. 根据原节点位置，得到我们需要的random

3、建立新表，恢复原表

而现在我们提出了新的解法：

1、遍历原表，复制一个新表

2、将原表和新表insert进map中

3、新表的random就是对应map的Key的random的second

代码如下：

class Solution {
public:
    Node* copy_list(Node* head)
    {
        Node* newhead = nullptr;
        Node* newtail = nullptr;
        while(head)
        {
            if(newhead == nullptr)
            {
                newhead = newtail = new Node(head->val);
            }
            else
            {
                newtail->next = new Node(head->val);
                newtail = newtail->next;
            }
            head = head->next;
        }
        return newhead;
    }
    Node* copyRandomList(Node* head) {
        if(!head)
            return nullptr;
        // 1、建立新表
        Node* newhead = copy_list(head);
     
        // 2、将旧表和新表insert到node_map中
        // 即Key就是旧表节点，Value是新表节点
        std::map node_map;
        Node* cur = head;
        Node* tmp = newhead;
        while(cur != nullptr)
        {
            node_map[cur] = tmp;
            cur = cur->next;
            tmp = tmp->next;
        }
        // 3、通过map的Key-Value处理新表的random
        Node* ret = head;
        while(ret)
        {
            auto pos = node_map.find(ret);
            if(pos != node_map.end())
            {
                // 如果旧表的random == nullptr，那么新表的random也为nullptr
                if(pos->first->random == nullptr)
                {
                    pos->second->random = nullptr;
                }
                // otherwise,新表的random就是对应map的Key的random的second
                else
                {
                   pos->second->random = node_map[ret->random];
                }
            }
            ret = ret->next;
        }
        return newhead;
    }
};

3.3. multimap

std::multimap 是 C++ 标准库中的容器之一，它是一个关联容器，允许存储多个相同键(允许键值冗余)的键值对。

std::multimap 类模板提供了一种将键和值关联的方式，它所存储的键值对可以具有相同的键（Key）。这就是与 std::map 的主要区别，std::map 只允许每个键关联一个值，而 std::multimap 允许一个键关联多个值。

std::multimap 在内部使用红黑树（一种平衡二叉搜索树）数据结构来实现。这使得插入、查找和删除操作的平均时间复杂度都为对数级别（O(log n)），提供了效率较高的键值对访问。

为什么multimap没有operator[]呢？

std::multimap 没有提供 operator[] 运算符的原因是，operator[] 通常用于直接访问容器中特定键对应的值，而对于 std::multimap 这种允许一个键关联多个值的容器来说，使用 operator[] 并不明确应该返回哪个值。

operator[] 用于在映射容器中使用键直接访问值，例如对于 std::map，可以使用 map[key] 来获取键 key 对应的值（因为对于std::map中的operator[]是键值对中的Value的引用）。但是在 std::multimap 中，由于一个键可以对应多个值，所以 operator[] 的行为就变得模糊不清。

如果 std::multimap 提供了 operator[] 运算符，那么它将需要决定返回哪个值，这可能会引起混淆。为避免歧义，std::multimap 不提供 operator[]。

如果你想要访问 std::multimap 中特定键对应的所有值，可以使用 equal_range 函数或迭代器来获取一个表示值范围的区间，然后通过遍历该区间来访问所有的值。

3.4. multiset

multiset 是 C++ STL（标准模板库）中的一个容器，用于存储一组元素，允许包含相同值的元素（即允许存储相同的Key或者叫允许键值冗余）。

multiset 是基于红黑树实现的，它类似于 set 容器，但允许存储重复的元素。这意味着你可以向 multiset 中插入多个相同的值，并且 multiset 会根据元素值的顺序自动进行排序（默认是升序）。与 set 一样，multiset 也支持快速的插入、删除和查找操作。

multiset 容器可以方便地用于处理需要存储重复元素且有序的情况。它提供了一些有用的成员函数，如 insert（插入元素）、erase（删除元素）、find（查找元素）等，以及一些迭代器相关的操作来遍历容器中的元素。

3.4.1. std::multiset::find

iterator find (const value_type& val) const;

multiset 是一种基于红黑树实现的容器，它允许存储重复的元素，并且会根据键的排序准则来自动对元素进行排序。当进行查找操作时，multiset 会使用红黑树的查找算法，找到中序遍历（LNR）第一个匹配的键。

3.4.2. std::multiset::count

size_type count (const value_type& val) const;

std::multiset::count 是 C++ STL（标准模板库）中 std::multiset 容器的成员函数之一，用于计算指定键（Key）在 multiset 中的出现次数。

std::multiset 是一种基于红黑树实现的容器，允许存储重复的元素，并且按键的排序准则自动对元素进行排序。std::multiset::count 函数接受一个参数，即要计算出现次数的键，返回该键在 multiset 中的出现次数

测试五：

void Test5(void)
{
	std::vector v{ 6, 2, 4, 3, 1, 2, 6, 4, 3, 8, 7 };
	std::multiset s;
	for (auto e : v)
	{
		s.insert(e);
	}

	size_t cnt = s.count(2);
	if (!cnt)
		std::cout << "没有这个Key" << std::endl;
	else
		std::cout << "Key的cnt: " << cnt << std::endl;
}

测试结果：

Key的cnt: 2 

可以看到：std::multiset::count可以计算特定键（Key）的个数

3.5. 关于map和set的练习题

3.5.1. 前K个高频单词：

692. 前K个高频单词 - 力扣（LeetCode）

思路：先统计每个单词出现的个数(建立单词和单词个数的联系)，题干要求，如果K相等，需要按照字典顺序排序，因此要控制比较逻辑

第一种思路：

1、用map统计每个单词出现的次数

2、将map中的数据导入vector>中

3、用标准库的sort(sort只支持随机迭代器)，当然还需要我们控制比较逻辑

第二种思路：

1、用map统计每个单词出现的次数

2、set,comapre> 因为set可以传递仿函数，因此我们可以通过set控制比较逻辑             

//第一种思路
class Solution {
public:
    vector topKFrequent(vector& words, int k) {
        struct compare
        {
            bool operator()(const std::pair& kv1,const std::pair& kv2) const
            {
                return kv1.second > kv2.second || (kv1.second == kv2.second && kv1.first < kv2.first);
            }
        };
        // 第一步:计算单词出现的个数
        std::map count_map;
        for(auto& e : words)
        {
            ++count_map[e];
        }
        // 第二步: 将数据导入vector中
        std::vector> v(count_map.begin(),count_map.end());

        // 第三步: 排序,需要控制比较逻辑,个数不相等，大的在前;个数相等,按照字典顺序排序
        std::sort(v.begin(),v.end(),compare());
        std::vector ret;
        for(size_t i = 0; i < k; ++i)
        {
            ret.push_back(v[i].first);
        }
        return ret;
    }
};

//第二种思路：
class Solution {
public:
    vector topKFrequent(vector& words, int k) {
        struct compare
        {
            bool operator()(const std::pair& kv1,const std::pair& kv2) const
            {
                return kv1.second > kv2.second || (kv1.second == kv2.second && kv1.first < kv2.first);
            }
        };
        // 第一步:计算单词出现的个数
        std::map count_map;
        for(auto& e : words)
        {
            ++count_map[e];
        }
        // set可以显示传递仿函数，利用仿函数的比较逻辑
        std::set,compare> s(count_map.begin(),count_map.end());

        std::vector ret;

        auto pos = s.begin();
        while(k--)
        {
            ret.push_back(pos->first);
            ++pos;
        }
        return ret;
    }
};

3.5.2.  两个数组的交集

349. 两个数组的交集 - 力扣（LeetCode）

找交集(需要先排序+去重)：

1、不相等，小的++

2、相等，就是交集，同时++

3、一个集合走完就结束

找差集(先排序)

1、相等，同时++

2、不相等，小的就是差集，小的++

3、一个集合走完了，剩下没有走完的集合的值也是差集

class Solution {
public:
    vector intersection(vector& nums1, vector& nums2) {
        std::set s1;
        
        // 排序 + 去重
        for(auto& e : nums1)
            s1.insert(e);
        std::set s2(nums2.begin(),nums2.end());

        // 根据交集的求解方法
        auto pos1 = s1.begin();
        auto pos2 = s2.begin();
        std::vector ret;
        while(pos1 != s1.end() && pos2 != s2.end())
        {
            // 小的++
            if(*pos1 < *pos2)
                ++pos1;
            else if(*pos1 > *pos2)
                ++pos2;
            // 相等就是交集
            else
            {
                ret.push_back(*pos1);
                ++pos1;
                ++pos2;
            }
        }
        return ret;
    }
};

4. 底层结构 

4.1. AVL树

AVL树的概念：

AVL树是一种自平衡的二叉搜索树，它以其发明者 G.M.Adelson-Velsky 和 E.M.Landis 的名字命名。AVL树保持树的左右子树高度的平衡，使得树的整体高度相对较小，提供了快速的查找、插入和删除操作。

在AVL树中，每个节点都包含一个键值对，且满足以下性质：

1. 左子树中的所有节点的键都小于该节点的键。
2. 右子树中的所有节点的键都大于该节点的键。
3. 每个节点的左子树和右子树的高度差（平衡因子）最多为 1。

为了维持这种平衡，AVL树在每次插入或删除节点时会根据需要进行旋转操作。旋转操作包括左旋和右旋，并通过重新分配节点的位置使得树重新平衡。这种自平衡的机制保证了AVL树的高度始终保持在较小的范围内，时间复杂度为O(log n)。

相对于其他平衡二叉搜索树（如红黑树），AVL树的平衡因子要求更为严格，不允许有任何节点的平衡因子绝对值超过1。这使得AVL树的修改操作更加频繁，但在查询操作上性能优于红黑树。

总结来说，AVL树是一种自平衡二叉搜索树，通过保持树的左右子树高度的平衡来提供快速的查找、插入和删除操作。它在每个节点上维护了平衡因子，并通过旋转操作来保持树的平衡性。这种自平衡的特性使得AVL树在一些对插入和删除操作要求较频繁的场景中具有优势。

AVL树的性质：

AVL树具有以下几个性质：

1. 二叉搜索树性质：AVL树是一种二叉搜索树，即满足以下性质：

   • 左子树中的所有节点的键都小于该节点的键。
   • 右子树中的所有节点的键都大于该节点的键。
   • 左右子树都是二叉搜索树。

2. 平衡性：AVL树的关键特点是保持平衡，即每个节点的左子树和右子树的高度差（平衡因子）最多为 1，确保了树的整体高度相对较小。

3. 平衡因子：每个节点都有一个平衡因子，定义为右子树的高度减去左子树的高度（或左子树的高度减去右子树的高度）。平衡因子可为 -1、0 或 1。

4. 自平衡：当进行插入或删除操作导致AVL树不再平衡时，AVL树会通过旋转操作来恢复平衡。旋转操作包括左旋和右旋以及左右双旋和右左双旋，并通过重新分配节点的位置调整树的结构，使得树重新达到平衡状态。

5. 高效性：由于AVL树的平衡性，其高度相对较小，从而保证了查找、插入和删除操作的平均时间复杂度为 O(log n)。

综上所述，AVL树是一种平衡二叉搜索树，具有二叉搜索树的性质，同时通过自平衡保持平衡性。它的平衡性和高效性使得它在某些场景中具有优势。

注意：AVL树不一定有平衡因子(balance factor)，我们在这里使用平衡因子只是它的一种实现方式，在这里我们的平衡因子 =  右子树的高度 - 左子树的高度

如下图所示：这就是一颗AVL树

我们在这里实现的AVL树采用三叉链的形式，大致框架如下：

namespace Xq
{
  template
  struct avl_tree_node
  {
    // 采用三叉链的形式
    avl_tree_node* _left;
    avl_tree_node* _right;
    avl_tree_node* _parent;
    std::pair _kv;
    int _bf;  // balance factor
    avl_tree_node(const std::pair& kv = std::pair())
      :_left(nullptr)
       ,_right(nullptr)
       ,_parent(nullptr)
       ,_kv(kv)
       ,_bf(0)
    {}
  };

  template
  class avl_tree
  {
  private:
    typedef avl_tree_node Node;
  public:
    avl_tree(Node* root = nullptr):_root(root){}

    bool insert(const std::pair& kv){}

  private:

  private:
    Node* _root;
  };
}

4.1.1 AVL树的插入

AVL树的插入元素，也符合普通二叉搜索树的原则，找到合适的位置进行插入元素

我们可以将AVL树的insert分为三个过程：

1、在合适位置插入元素

2、更新平衡因子

3、如果平衡因子 > 1，需要进行旋转处理

4.1.1.1 平衡因子的更新

1、如果更新完以后，平衡因子没有出现问题(平衡因子的绝对值 |bf|<= 1)，那么说明插入对AVL树的平衡结构不影响，不需要处理

2、如果更新的过程中，平衡因子出现问题(平衡因子的绝对值大于1)，平衡结构受到影响，需要停止更新，并旋转处理；

旋转分为四种：左旋、右旋、左右旋、右左旋

插入新增节点，会影响祖先的bf(全部或者部分祖先)。

平衡因子的更新有三种情况：

那么，什么决定了平衡因子是否要继续往上更新？取决于parent的所在的子树高度(即左右子树高度的较大值)是否变化？如果变了(例如会影响祖先的平衡因子(全部或部分))继续更新，不变则不再更新

cur是新增节点

如果 cur == parent->right  那么父亲parent的平衡因子bf++

如果 cur == parent->left    那么父亲parent的平衡因子bf--

注意：插入之前我们需要保证原树是一颗AVL树，因此插入之前所有节点的|bf| <= 1

第一种情况： parent->bf == 1 || parent->bf == -1

-> 说明parent所在的子树的高度变了，继续向上更新，为什么？-> 因为插入元素之后parent的bf==1或者bf ==-1，那么说明插入之前parent->bf == 0，说明原左右子树的高度相等，现在有一边的子树高度高1，说明parent一边高一边低，高度变了，继续向上更新。

如图所示：

第二种情况：parent->bf == 0

说明parent所在的子树高度不变，不用继续往上更新，这一次插入了就结束 ---> 插入之前parent->bf == 1 || parent->bf == -1，说明插入之前一边高一边低，新增节点插入在矮的那边，插入之后，左右子树高度相同，parent的高度不变，因此平衡因子不用向上更新了，插入结束。

如图所示：

第三种情况：parent->bf == -2 || parent->bf == 2

说明插入新增节点后parent的所在的子树不平衡（|bf| >= 2），因此需要停止向上更新，处理这颗子树

如何处理 --- 旋转处理，处理完插入就结束。

如图所示：

平衡因子的更新的代码框架如下：

while (parent)
{
	if (cur == parent->_left)
		--parent->_bf;
	else
		++parent->_bf;
	//case 1:  继续向上更新
	if (parent->_bf == 1 || parent->_bf == -1)
	{
		cur = parent;
		parent = parent->_parent;
		continue;
	}
	// case 2: 符合AVL树,结束更新
	else if (parent->_bf == 0)
	{
		break;
	}
	// case 3: 当前子树出现问题了(|bf| >= 2),需要停止更新,处理当前AVL子树,处理后,插入结束
	else if (parent->_bf == 2 || parent->_bf == -2)
	{
		// 旋转处理:
		break;
	}
	// case 4:非法情况,说明前面的AVL树不符合规则
	else
	{
		// 直接断死
		assert(false);
	}
}

4.1.1.2. AVL树的旋转

旋转操作是为了保持或恢复AVL树的平衡性。

AVL树的平衡在于每个节点的左子树和右子树的高度差（平衡因子）最多为 1。当进行插入或删除操作后，可能会打破原本的平衡性，导致某个节点的平衡因子超过了允许的范围。

为了恢复平衡，AVL树采用不同类型的旋转操作，包括左旋和右旋。旋转操作通过重新分配节点的位置，使得树重新达到平衡状态，确保每个节点的平衡因子保持在允许的范围内。

旋转操作的具体目的如下：
1. 左旋：当一个节点的右子树高度大于左子树高度时，进行左旋操作。左旋将当前节点和其右子节点进行交换，使得原先的右子节点成为新的根节点，同时保证原来左子树不变、右子节点的左子树作为新的右子树，从而降低了树的高度差。
2. 右旋：当一个节点的左子树高度大于右子树高度时，进行右旋操作。右旋将当前节点和其左子节点进行交换，使得原先的左子节点成为新的根节点，同时保证原来右子树不变、左子节点的右子树作为新的左子树，从而降低了树的高度差。

通过旋转操作，AVL树可以在插入或删除节点后自动调整自己，降低AVL树的高度，维持其平衡结构 ，提供更高效的查找、插入和删除操作。

总结来说，旋转操作的目的是为了保持或恢复AVL树的平衡性，通过重新分配节点的位置降低树的高度差，确保每个节点的平衡因子在允许范围内。这样可以提供更好的性能和效率。

旋转处理的情况分为四种：左单旋、右单旋、左右双旋、右左双旋

旋转的原则：旋转后仍是一颗AVL树

旋转的目的：左右均衡，降低整棵AVL树的高度

我们依次来看：

4.1.1.2.1. 左单旋

如下图所示：

当h==0时，情况如下：

当h==1时，情况如下： 

当h == 2时，情况如下： 

上面列出了三种情况，当然远远不止，虽然有很多种情况，但是对于AVL树的左单旋的处理方式是固定的：

只要满足 cur->bf == 2 && cur_right->bf == 1，那么就对cur进行左单旋

旋转后将cur和cur_right的平衡因子置为0即可

具体如下图所示：

有了上面的分析，我们可以得出结论：

当cur->bf == 2 && cur_right->bf == 1，那么就对cur进行左单旋

旋转后更新平衡因子cur->bf = 0; cur_right->bf = 0;

因此，我们的左单旋实现如下 ：

为了更好地实现左单旋，我们借助下面的图来实现

void left_rotate(Node* parent)
{
	// 确立四个节点的初始位置
	Node* cur = parent;
	Node* cur_right = cur->_right;
	Node* cur_right_left = cur_right->_left;
	Node* cur_parent = cur->_parent;

	cur->_right = cur_right_left;
	// 当h == 0时,cur_right_left是为空的,因此在这里要判断一下
	if (cur_right_left)
		cur_right_left->_parent = cur;

	cur_right->_left = cur;
	cur->_parent = cur_right;

	// 如果parent是根节点,那么cur_right就是新根
	if (!cur_parent)
	{
		cur_right->_parent = nullptr;
		_root = cur_right;
	}
	// 如果parent不是根节点,那么cur_parent不为空
	else
	{
		if (cur_parent->_kv.first > cur_right->_kv.first)
		{
			cur_parent->_left = cur_right;
		}
		else
		{
			cur_parent->_right = cur_right;
		}
		cur_right->_parent = cur_parent;
	}
    // 更新cur和cur_right的平衡因子
    cur_right->_bf = cur->_bf = 0;
}

4.1.1.2.2. 右单旋

对于右单旋来说，分析思路与左单旋差别不大，只不过右单旋是单纯的左边高，进行右单旋，在这里只以h==1的具象图和抽象图用以举例说明

 当h==1时，如下图所示：

右单旋的抽象图，如下图所示：

与左单旋同样，虽然右单旋会有很多种情况，但是它们的处理方式是一样的，只要满足

cur->bf == -2 && cur_left->bf == -1 就对cur进行右单旋，旋转玩后将cur和cur_left的bf更新为0，旋转结束。

有了上面的分析，我们可以得出结论：

当cur->bf == -2 && cur_left->bf == -1，那么就对cur进行右单旋

旋转后更新平衡因子cur->bf = 0; cur_left->bf = 0;

因此，我们的右单旋实现如下 ：

为了更好地实现右单旋，我们借助下面的图来实现：

void right_rotate(Node* parent)
{
	// 确立四个节点的初始位置
	Node* cur = parent;
	Node* cur_left = cur->_left;
	Node* cur_left_right = cur_left->_right;
	Node* cur_parent = cur->_parent;

	cur->_left = cur_left_right;
	// 当h == 0时,cur_left_right为空,因此在这里要判断一下
	if (cur_left_right)
		cur_left_right->_parent = cur;

	cur_left->_right = cur;
	cur->_parent = cur_left;

	// 如果cur_parent为空,那么cur_left就是新根
	if (!cur_parent)
	{
		cur_left->_parent = nullptr;
		_root = cur_left;
	}
	else
	{
        // 在这里需要判断一下kv.first的大小，以确定cur_left是左孩子还是右孩子
		if (cur_parent->_kv.first > cur_left->_kv.first)
		{
			cur_parent->_left = cur_left;
		}
		else
		{
			cur_parent->_right = cur_left;
		}
        // 最后也要链接父亲
		cur_left->_parent = cur_parent;
	}
	// 更新平衡因子
	cur->_bf = cur_left->_bf = 0;
}

4.1.1.2.3. 左右双旋

左右双旋：‘例如这种形状<’，整体看是左边高，但是左子树又是右边高

先对左子树进行左单旋、在对整体进行右单旋。

先左单旋的目的是：让这棵AVL子树变成单纯的左边高，在进行右单旋

如图所示：

当h == 0时，如下图所示 

当 h == 1时，如下图说式：

左右双旋的抽象图：

将上面的图联系到一起，我们可以发现，他们的旋转方式和旋转条件是一样的。

旋转条件： cur->bf == -2 && cur_left->bf == 1  (对应到上图：(100就是cur,50就是cur_left) )

旋转方式：先对左子树进行左单旋，在对整体进行右单旋。

但是最后的平衡因子的更新却不一样，可以分为三种情况

当插入元素后：

case 1：cur_left_right->bf == 0

旋转后：cur->bf = 0; cur_left->bf = 0; cur_left_right->_bf = 0;

case 2：cur_left_right->bf == -1

旋转后：cur->bf = 1; cur_left->bf = 0; cur_left_right->_bf = 0;

case 3：cur_left_right->bf == 1

旋转后：cur->bf = 0; cur_left->bf = -1; cur_left_right->_bf = 0;

void left_right_rotate(Node* parent)
{
	Node* cur = parent;
	Node* cur_left = cur->_left;
	Node* cur_left_right = cur_left->_right;
	int bf = cur_left_right->_bf;

	// 先左旋、后右旋
	left_rotate(cur_left);
	right_rotate(cur);

	if (bf == 0)
	{
		cur->_bf = 0;
		cur_left->_bf = 0;
		cur_left_right->_bf = 0;
	}
	else if (bf == -1)
	{
		cur->_bf = 1;
		cur_left->_bf = 0;
		cur_left_right->_bf = 0;
	}
	else if (bf == 1)
	{
		cur->_bf = 0;
		cur_left->_bf = -1;
		cur_left_right->_bf = 0;
	}
	else
	{
		// 非法情况,直接断死
		assert(false);
	}
}

4.1.1.2.4. 右左双旋

右左双旋的分析思路和左右双旋没有太大差异。在这里只以h == 0 和 对应的抽象图举例分析其中细节。

如图所示，这就是右左双旋的抽象图：

当h == 0时的具象图，如下图所示

 剩下两种情况的抽象图，如下图所示：

 将上面的图联系到一起，我们可以发现，他们的旋转方式和旋转条件是一样的。

旋转条件: cur->bf == 2 && cur_right->bf == -1 (对应到上图:(50就是cur,100就是cur_right)) 

旋转方式：先对右子树进行右单旋，在对整体进行左单旋。

但是最后的平衡因子的更新却不一样，可以分为三种情况

当插入元素后：

case 1：cur_right_left->bf == 0

旋转后：cur->bf = 0;cur_right->bf = 0; cur_right_left->bf = 0;

case 2：cur_right_left->bf == -1

旋转后：cur->bf = 0;cur_right->bf = 1; cur_right_left->bf = 0;

case 3：cur_right_left->bf == 1

旋转后：cur->bf = -1;cur_right->bf = 0; cur_right_left->bf = 0;

void right_left_rotate(Node* parent)
{
	Node* cur = parent;
	Node* cur_right = cur->_right;
	Node* cur_right_left = cur_right->_left;

	int bf = cur_right_left->_bf;

	right_rotate(cur_right);
	left_rotate(cur);

	if (bf == 0)
	{
		cur->_bf = 0;
		cur_right->_bf = 0;
		cur_right_left->_bf = 0;
	}
	else if (bf == -1)
	{
		cur->_bf = 0;
		cur_right->_bf = 1;
		cur_right_left->_bf = 0;
	}
	else if (bf == 1)
	{
		cur->_bf = -1;
		cur_right->_bf = 0;
		cur_right_left->_bf = 0;
	}
	else
	{
		// 非法情况,直接断死
		assert(false);
	}
}

 4.1.1.3. 验证AVL树的插入

如何验证：

我们需要验证每一棵AVL子树的左右子树高度差是否小于等于1，且要判断每个节点的平衡因子是否等于当前节点的左右子树的高度差

代码实现：

int _get_tree_high(Node* root)
{
	if (!root)
		return 0;
	else
	{
		int left_high = _get_tree_high(root->_left);
		int right_high = _get_tree_high(root->_right);
		return left_high > right_high ? ++left_high : ++right_high;
	}
}

bool _is_balance_tree(Node* root)
{
	// 空树可以认为是AVL树
	if (!root)
		return true;
	else
	{
		int left_high = get_tree_high(root->_left);
		int right_high = get_tree_high(root->_right);

        // 如果当前节点的平衡因子不等于当前节点的左右子树的高度差,说明异常
		if (right_high - left_high != root->_bf)
		{
			std::cout << root->_kv.first << " : 该节点的平衡因子出现异常" << std::endl;
			return false;
		}
		// 计算每颗AVL子树的左右子树高度差,如果存在大于1的情况,说明异常
		int bf = right_high - left_high;
		if (bf < 0)
			bf *= -1;
		return bf <= 1
			&& _is_balance_tree(root->_left)
			&& _is_balance_tree(root->_right);
	}
}

4.1.1.4. AVL树插入的完整实现

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 

namespace Xq
{
  template
  struct avl_tree_node
  {
    avl_tree_node* _left;
    avl_tree_node* _right;
    avl_tree_node* _parent;
    std::pair _kv;
    int _bf;  // balance factor
    avl_tree_node(const std::pair& kv = std::pair())
      :_left(nullptr)
       ,_right(nullptr)
       ,_parent(nullptr)
       ,_kv(kv)
       ,_bf(0)
    {}
  };

  template
  class avl_tree
  {
  private:
    typedef avl_tree_node Node;
  public:
    avl_tree(Node* root = nullptr):_root(root){}

    bool insert(const std::pair& kv)
    {
      if(_root == nullptr)
      {
        _root = new Node(kv);
        return true;
      }
      else
      {
        Node* cur = _root;
        Node* parent = nullptr;
        while(cur)
        {
          if(cur->_kv.first > kv.first)
          {
            parent = cur;
            cur = cur->_left;
          }
          else if(cur->_kv.first < kv.first)
          {
            parent = cur;
            cur = cur->_right;
          }
          else
          {
            return false;
          }
        }
        cur = new Node(kv);
        if(kv.first > parent->_kv.first)
        {
          parent->_right = cur;
          cur->_parent = parent;
        }
        else
        {
          parent->_left = cur;
          cur->_parent = parent;
        }

        // 调整平衡因子
        while(parent)
        {
          if(cur == parent->_left)
            --parent->_bf;
          else
            ++parent->_bf;
          //case 1:  继续向上更新
          if(parent->_bf == 1 || parent->_bf == -1)
          {
            cur = parent;
            parent = parent->_parent;
            continue;
          }
          // case 2: 符合AVL树,结束更新
          else if(parent->_bf == 0)
          {
            break;
          }
          // case 3: 当前子树出现问题了(|bf| >= 2),需要停止更新,处理当前AVL子树,处理后,插入结束
          else if(parent->_bf == 2 || parent->_bf == -2)
          {
            // 旋转处理:
            
            //case 1: 左单旋
            if(parent->_bf == 2 && parent->_right->_bf == 1)
            {
              left_rotate(parent);
            }
            //case 2: 右单旋
            else if(parent->_bf == -2 && parent->_left->_bf == -1)
            {
              right_rotate(parent);
            }
            //case 3:左右双旋
            else if(parent->_bf == -2 && parent->_left->_bf == 1)
            {
              left_right_rotate(parent);
            }
            //case 4:右左双旋
            else if(parent->_bf == 2 && parent->_right->_bf == -1)
            {
              right_left_rotate(parent);
            }
            //非法情况,断死
            else 
            {
              assert(false);
            }
            break;
          }
          // case 4:非法情况,说明前面的AVL树不符合规则
          else
          {
            // 直接断死
            assert(false);
          }
        }
        return true;
      }
    }

    void left_rotate(Node* parent)
    {
      // 1. 确立四个节点的初始位置
      Node* cur = parent;
      Node* cur_right = cur->_right;
      Node* cur_right_left = cur_right->_left;
      Node* cur_parent = cur->_parent;

      cur->_right = cur_right_left;
      // 当h == 0时,cur_right_left是为空的,因此在这里要判断一下
      if(cur_right_left)
        cur_right_left->_parent = cur;

      cur_right->_left = cur;
      cur->_parent = cur_right;

      // 如果parent是根节点,那么cur_right就是新根
      if(!cur_parent)
      {
        cur_right->_parent = nullptr;
        _root = cur_right;
      }
      // 如果parent不是根节点,那么cur_parent不为空
      else
      {
        if(cur_parent->_kv.first > cur_right->_kv.first)
        {
          cur_parent->_left = cur_right;
        }
        else
        {
          cur_parent->_right = cur_right;
        }
        cur_right->_parent = cur_parent;
      }
      cur->_bf = cur_right->_bf = 0;
    }

    void right_rotate(Node* parent)
    {
      // 确立四个节点的初始位置
      Node* cur = parent;
      Node* cur_left = cur->_left;
      Node* cur_left_right = cur_left->_right;
      Node* cur_parent = cur->_parent;

      cur->_left = cur_left_right;
      // 当h == 0时,cur_left_right为空,因此在这里要判断一下
      if(cur_left_right)
        cur_left_right->_parent = cur;

      cur_left->_right = cur;
      cur->_parent = cur_left;

      // 如果cur_parent为空,那么cur_left就是新根
      if(!cur_parent)
      {
        cur_left->_parent = nullptr;
        _root = cur_left;
      }
      else
      {
        if(cur_parent->_left == cur)
        {
          cur_parent->_left = cur_left;
        }
        else
        {
          cur_parent->_right = cur_left;
        }
        cur_left->_parent = cur_parent;
      }
      // 更新平衡因子
      cur->_bf = cur_left->_bf = 0;
    }

    void left_right_rotate(Node* parent)
    {
      Node* cur = parent;
      Node* cur_left = cur->_left;
      Node* cur_left_right = cur_left->_right;
      int bf = cur_left_right->_bf;

      // 先左旋、后右旋
      left_rotate(cur_left);
      right_rotate(cur);

      if(bf == 0)
      {
        cur->_bf = 0;
        cur_left->_bf = 0;
        cur_left_right->_bf = 0;
      }
      else if(bf == -1)
      {
        cur->_bf = 1;
        cur_left->_bf = 0;
        cur_left_right->_bf = 0;
      }
      else if(bf == 1)
      {
        cur->_bf = 0;
        cur_left->_bf = -1;
        cur_left_right->_bf = 0;
      }
      else 
      {
        // 非法情况,直接断死
        assert(false);
      }
    }

    void right_left_rotate(Node* parent)
    {
      Node* cur = parent;
      Node* cur_right = cur->_right;
      Node* cur_right_left = cur_right->_left;

      int bf = cur_right_left->_bf;

      right_rotate(cur_right);
      left_rotate(cur);

      if(bf == 0)
      {
        cur->_bf = 0;
        cur_right->_bf = 0;
        cur_right_left->_bf = 0;
      }
      else if(bf == -1)
      {
        cur->_bf = 0;
        cur_right->_bf = 1;
        cur_right_left->_bf = 0;
      }
      else if(bf == 1)
      {
        cur->_bf = -1;
        cur_right->_bf = 0;
        cur_right_left->_bf = 0;
      }
      else 
      {
        // 非法情况,直接断死
        assert(false);
      }
    }

    void level_order()
    {
      _level_order(_root);
    }

    int get_tree_high(Node* root)
    {
      return _get_tree_high(root);
    }

    bool is_balance_tree()
    {
      return _is_balance_tree(_root);
    }

    int in_outside_get_tree_high()
    {
      return _get_tree_high(_root);
    }

  private:

    void _level_order(Node* root)
    {
      if(!root)
        return ;
      else
      {
        std::queue qu;
        qu.push(root);
        while(!qu.empty())
        {
          Node* front = qu.front();
          qu.pop();
          if(front)
          {
            qu.push(front->_left);
            qu.push(front->_right);
          }
          if(!front)
            std::cout << "N ";
          else
            std::cout << front->_kv.first << " ";
        }
        std::cout << std::endl;
      }
    }

    int _get_tree_high(Node* root)
    {
      if(!root)
        return 0;
      else
      {
        int left_high = _get_tree_high(root->_left);
        int right_high = _get_tree_high(root->_right);
        return left_high > right_high ? ++left_high : ++right_high;
      }
    }

    bool _is_balance_tree(Node* root)
    {
      // 空树可以认为是AVL树
      if(!root)
        return true;
      else
      {
         int left_high = get_tree_high(root->_left);
         int right_high = get_tree_high(root->_right);

         if(right_high - left_high != root->_bf)
         {
           std::cout << root->_kv.first <<" : 该节点的平衡因子出现异常" << std::endl;
           return false;
         }
         // 计算每颗AVL子树的左右子树高度差,如果存在大于1的情况,说明异常
         int bf = right_high-left_high;
         if(bf < 0)
           bf *= -1;
         return bf <= 1 
           && _is_balance_tree(root->_left)
           && _is_balance_tree(root->_right);
      }
    }

  private:
    Node* _root;
  };
}

4.2. 红黑树

红黑树是一种自平衡的二叉搜索树，它通过约束节点的颜色和结构来保持平衡。红黑树是由 Rudolf Bayer 在1972年发明的，被认为是一种优秀的平衡树结构，广泛应用于各种数据结构和算法中。

红黑树具有以下几个性质：

1. 二叉搜索树性质：红黑树是一种二叉搜索树，即满足以下性质：

   • 左子树中的所有节点的键都小于该节点的键。
   • 右子树中的所有节点的键都大于该节点的键。
   • 左右子树都是二叉搜索树。

2. 节点颜色性质：每个节点被标记为红色或黑色。

3. 根节点性质：根节点为黑色。

4. 叶子节点（NIL节点）性质：叶子节点都为黑色的空节点(NIL节点)，并被视为树的终止节点。

5. 红色节点性质：红节点的子节点必须是黑节点，不能出现连续的红色节点。

6. 黑节点性质：从任一节点到其每个叶子节点的路径上，经过的黑节点数量是相同的（黑色平衡性）。

7. 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路
   径会比其他路径长出俩倍以上，因而是接近平衡的。

这些性质保证了红黑树的平衡性和有序性。红黑树通过在插入和删除操作中进行颜色调整和旋转操作来维护平衡性。与AVL树相比，红黑树对于平衡性的要求相对宽松，因此插入和删除操作的平衡调整(旋转)相对较少。

由于红黑树的平衡性，其高度相对较小，平均时间复杂度为 O(log n)，提供了快速的查找、插入和删除操作。红黑树在各种应用中被广泛使用，例如C++ STL中的map和set容器，以及各种数据库、编译器和操作系统的实现。

总结来说，红黑树是一种具有自平衡性质的二叉搜索树，通过约束节点的颜色和结构来保持平衡。它具有二叉搜索树的性质，并通过节点颜色、根节点性质、叶子节点性质、红色节点性质和黑节点性质来维护平衡性。红黑树提供了高效的查找、插入和删除操作，被广泛应用于不同领域的数据结构和算法中。

思考 ：为什么红黑树可以保证任何一条路径不会比其他路径长出两倍以上呢？

首先我们要知道什么是路径？

路径是从根节点开始，沿着树的分支一直走到达叶子节点。注意：这里的叶子节点特指为空节点，在这里一般用NIL节点表示空节点，且NIL节点是黑色的。

对于一棵红黑树而言，它的最短路径和最长路径分别为：

最短路径：就是这条路径上的节点是全黑的。

最长路径：该路径是由一黑一红连续组成的。

红黑树的性质告诉我们，每条路径上的黑色节点个数是一定的，且没有连续的红色节点

那么我们假设最短路径的黑色节点个数为N

那么最长路径的黑色节点个数也为N，其红色节点个数最多也为N，那么最长路径的节点个数为2N

因此我们可以得出，红黑树的最长路径可以是最短路径的二倍，但是不会超过二倍， 因此红黑树的任意一条路径的节点个数不可能比其他任何一条路径长过两倍以上，以达到近似平衡的状态。

综上所述，红黑树通过对节点的着色和结构的限制，确保了树的高度相对较小，从而保证了没有一条路径会比其他路径长出两倍以上。这种限制确保红黑树保持近似平衡的状态，从而提供了较好的性能。当插入、删除或查找操作发生时，红黑树能够在O(logN)的时间内完成操作，其中N是树中节点的数量。最长路径接近最短路径长度的情况下，红黑树的高度相对较小，保证了快速的操作效率。

4.2.1. 红黑树的插入

如下图所示，这就是一颗红黑树

 第一个问题，如果我们现在要插入一个新节点，我们是把这个新节点的初始颜色设置为黑色还是红色呢？？？

假设我把新增节点设置为黑色，那么就会有下面的场景：

我们发现，此时就出现了问题，插入了5之后，这棵树还是红黑树吗？抱歉，根据红黑树的性质：每个路径上的黑色节点个数必须相等，我们可以知道，此时这棵树已经不是红黑树了。

但如果我将新增节点的初始颜色设置为红色呢，又会出现什么情况？如下图所示：

 我们发现，当我们把新增节点的初始颜色设置为红色的时候，插入之后会有两种情况：

第一种情况：插入之后违反了红黑树的规则，即不能出现连续的红色节点。

第二种情况：插入之后没有违反任何规则。

综上所述，我们将新增节点的初始颜色设置为红色。因为如果新增节点是黑色，那么一定会违反红黑树的规则，反之，如果是红色，则可能插入之后不违反任何规则，因此我们将新增节点设置为红色。

严格意义上讲，红黑树的插入会有五种情况，让我们一一进行理解。

4.2.1.1. 情况一：新增节点的父亲为空

这种情况最为简单，就是当是一颗空树的时候，直接插入即可。并将新增节点的颜色更新为黑即可。

4.2.1.2. 情况二：新增节点的父亲非空且为黑色节点

这种情况也很简单，直接插入红色节点即可，不会破环红黑树的规则。

4.2.1.3. 情况三：当父亲为红节点，叔叔存在且为红

当新增节点的父亲节点和叔叔节点非空且为红时，变色即可。

因为parent为红，那么它一定不是根节点，因此它一定有父亲节点，即grandfather一定不为空。

声明:

g --- grandfather(祖父节点 )  p --- parent(父节点)  u --- uncle(叔叔节点)  c --- cur(新增节点)

变色规则：p、u变黑，g变红

如图所示：

 1、当祖父为根节点的时候

2、 当祖父不是根节点的时候

总结，当p、u为红的时候，那么将p、u变黑、将g变红，c = g; p = c->parent，继续判断，如果符合前面的条件(p、u为红)继续向上更新，最后为了避免不同的情况，将根节点的颜色更新为黑即可。

 4.2.1.4. 情况四：当父亲为红节点，叔叔不存在或者存在为黑

父亲为红、叔叔不存在或者存在为黑，且g、p、c在同一条直线上，单旋处理，处理完，插入结束。

因为parent为红，那么它一定不是根节点，因此它一定有父亲节点，即grandfather一定不为空。

单旋非为左单旋和右单旋两种情况，具体操作如图所示：

其中，a、b、c、d、e代表红黑树子树

总结：当g、p、c在同一条直线上，就进行单旋，虽然有两种情况，但是最后它们的变色情况是一致的，p：由红变黑 g：由黑变红

4.2.1.5. 情况五：父亲为红、叔叔不存在或者为黑

父亲为红、叔叔不存在或者存在为黑，且g、p、c不在同一条直线上，需要双旋处理，处理完，插入结束。

因为parent为红，那么它一定不是根节点，因此它一定有父亲节点，即grandfather一定不为空。

双旋非为左右双旋和右左双旋两种情况，具体操作如图所示：

其中，a、b、c、d、e代表红黑树子树

 总结：当g、p、c不在同一条直线上(一条折线就是双旋)，就进行双旋，虽然有两种情况，但是最后它们的变色情况是一致的，c由红变黑  g由黑变红  p不变，保持红色

 4.2.1.5. 验证红黑树的插入

 思路：只要满足下面的所有条件就是红黑树

<1> 第一个条件：

根节点是黑色的

<2> 第二个条件：

红色的节点的左右子树都必须是黑色的，也就是说父子节点只能有一个红色节点

思路： 只要某节点是红色的，那么只要判断它的父亲即可，如果父亲是红色的，那么就不是红黑树，反之，则符合红黑树

<3> 第三个条件：

每一条路径的黑色节点是相等的。

路径：从根节点到"叶子节点"

注意：这里的叶子节点不是传统意义上的叶子节点，在这里把空节点当作叶子节点

思路：根据DFS思想，在这里我们用前序，计算出每一条路径的黑色节点个数。

bool is_balance_tree()
{
    // 检查根节点
	if (_root->_col != BLACK)
	{
		std::cout << "根节点是红色,异常" << std::endl;
        return false;
	}	
	return _is_balance_tree(_root);
}

bool _is_balance_tree(Node* root)
{
	if (!root)
		return true;
	else
	{
        // basic_value作为这颗红黑树的黑色节点个数的基准值
		int basic_value = _get_black_node_num(root);
		return _is_check_rb_tree(root, 0, basic_value);
	}
}

bool _is_check_rb_tree(Node* root, int black_num, int basic_value)
{
	// basic_value: 红黑树的一条路径中的黑色节点个数，在这里作为基准值
	if (root == nullptr)
	{
		if (black_num != basic_value)
		{
			std::cout << "某条路径中的黑色节点个数不相等,异常" << std::endl;
			return false;
		}
		else
			return true;
	}
	else
	{
		if (root->_col == BLACK)
			++black_num;
		// 如果一个节点是红色的,那么该节点一定不是根,因此一定有父亲
		// 如果这个节点的父亲也是红色的,那么就说明出现异常
		if (root->_col == RED && root->_parent->_col == RED)
		{
			std::cout << "child: " << root->_kv.first << "parent: " << root->_parent->_kv.first << "出现了连续的红色节点,异常" << std::endl;
			return false;
		}
		return _is_check_rb_tree(root->_left, black_num, basic_value)
			&& _is_check_rb_tree(root->_right, black_num, basic_value);
	}
}

int _get_black_node_num(Node* root)
{
	if (root == nullptr)
		return 0;
	else
	{
		int ret = 0;
		while (root)
		{
			if (root->_col == BLACK)
				++ret;
			root = root->_left;
		}
		return ret;
	}
}

4.2.1.6.  rb_tree插入的完整实现

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 

namespace Xq
{
	enum color
	{
		RED,
		BLACK
	};

	template
	struct rb_tree_node
	{
		rb_tree_node* _left;
		rb_tree_node* _right;
		rb_tree_node* _parent;
		std::pair _kv;
		color _col;

		rb_tree_node(const std::pair& kv = std::pair())
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _kv(kv)
			, _col(RED)
		{}
	};

	template
	class rb_tree
	{
	private:
		typedef rb_tree_node Node;
	public:
		rb_tree(Node* root = nullptr) :_root(root){}

		bool insert(const std::pair& kv)
		{
			if (!_root)
			{
				_root = new Node(kv);
				_root->_col = BLACK;
				return true;
			}
			else
			{
				Node* cur = _root;
				Node* parent = nullptr;
				while (cur)
				{
					if (cur->_kv.first > kv.first)
					{
						parent = cur;
						cur = cur->_left;
					}
					else if (cur->_kv.first < kv.first)
					{
						parent = cur;
						cur = cur->_right;
					}
					else
					{
						return false;
					}
				}
				cur = new Node(kv);
				if (kv.first > parent->_kv.first)
				{
					parent->_right = cur;
				}
				else
				{
					parent->_left = cur;
				}
				cur->_parent = parent;

				// 当父节点parent的颜色为红色时,需要调整
				while (parent && parent->_col == RED)
				{
					// 因为父节点parent->_col == RED,那么说明parent一定有父节点
					Node* grandfather = parent->_parent;
					if (parent == grandfather->_left)
					{
						Node* uncle = grandfather->_right;
						// case 1: 当父节点为红,且叔叔不为空且为红
						// Solution : 变色
						if (uncle && uncle->_col == RED)
						{
							parent->_col = uncle->_col = BLACK;
							grandfather->_col = RED;
							if (grandfather == _root)
								grandfather->_col = BLACK;
							// 继续向上判断,如果依旧符合case 1,继续变色
							cur = grandfather;
							parent = cur->_parent;
							continue;
						}
						// case 2: 父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c在同一条直线上
						// Solution: 单旋, 在这里就是对grandfather右单旋
						else if (parent->_left == cur && ((!uncle) || uncle->_col == BLACK))
						{
			//     g             p
			//   p   u  --->   c   g
		    // c                     u
							right_rotate(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
							// 旋转完,更新完颜色,调整就结束
							break;
						}
						// case 3:父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c不在同一条直线上
						// Solution: 双旋,在这里就是先对p进行左单旋,在对g进行右单旋
						else if (parent->_right == cur && ((!uncle) || uncle->_col == BLACK))
						{
			//    g     先对p进行左单旋       g       在对g进行右单旋        c
			// p     u    --->            c     u        --->          p     g    
			//   c                      p                                       u
							left_rotate(parent);
							right_rotate(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
							// 旋转完,更新完颜色,调整就结束
							break;
						}
						else
						{
							// 非法情况
							assert(false);
						}
					}
					// 当parent是grandfather的右孩子,那么uncle就是grandfather的左孩子
					else
					{
						Node* uncle = grandfather->_left;
						// case 1: 当父节点为红,且叔叔不为空且为红
						// Solution : 变色
						if (uncle && uncle->_col == RED)
						{
							parent->_col = uncle->_col = BLACK;
							grandfather->_col = RED;
							if (grandfather == _root)
								grandfather->_col = BLACK;
							// 继续向上判断,如果依旧符合case 1,继续变色
							cur = grandfather;
							parent = cur->_parent;
							continue;
						}
						// case 2: 父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c在同一条直线上
						// Solution: 单旋, 在这里就是对grandfather左单旋
						else if (parent->_right == cur && ((!uncle) || uncle->_col == BLACK))
						{
					//   g    对g进行左单旋       p
					// u   p      --->         g     c
					//       c               u 
							left_rotate(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
							//旋转并将颜色更新后,就退出调整
							break;
						}
						// case 3:父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c不在同一条直线上
						// Solution: 双旋,在这里就是先对p进行右单旋,在对g进行左单旋
						else if (parent->_left == cur && ((!uncle) || uncle->_col == BLACK))
						{
//    g       先对p进行右单旋        g          在对g进行左单旋          c
// u     p      --->             u     c          --->            g      p
//     c                                  p                    u                            

							right_rotate(parent);
							left_rotate(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
							break;
						}
						else
						{
							// 非法情况,断死
							assert(false);
						}
					}
				}
                _root->_col = BLACK;
				return true;
			}
		}

		void level_order()
		{
			_level_order(_root);
		}

		bool is_balance_tree()
		{
			if (_root->_col != BLACK)
            {
                std::cout << "根节点是红色的,异常" < qu;
				qu.push(root);
				while (!qu.empty())
				{
					Node* front = qu.front();
					qu.pop();
					if (front)
					{
						qu.push(front->_left);
						qu.push(front->_right);
					}
					if (!front)
						std::cout << "N ";
					else
						std::cout << front->_kv.first << " ";
				}
				std::cout << std::endl;
			}
		}

		void left_rotate(Node* parent)
		{
			Node* cur = parent;
			Node* cur_right = cur->_right;
			Node* cur_right_left = cur_right->_left;
			Node* cur_parent = cur->_parent;

			cur->_right = cur_right_left;
			if (cur_right_left)
				cur_right_left->_parent = cur;

			cur_right->_left = cur;
			cur->_parent = cur_right;

			if (!cur_parent)
			{
				cur_right->_parent = nullptr;
				_root = cur_right;
			}
			else
			{
				if (cur_parent->_left == cur)
				{
					cur_parent->_left = cur_right;
				}
				else
				{
					cur_parent->_right = cur_right;
				}
				cur_right->_parent = cur_parent;
			}
		}

		void right_rotate(Node* parent)
		{
			Node* cur = parent;
			Node* cur_left = cur->_left;
			Node* cur_left_right = cur_left->_right;
			Node* cur_parent = cur->_parent;

			cur->_left = cur_left_right;
			if (cur_left_right)
				cur_left_right->_parent = cur;

			cur_left->_right = cur;
			cur->_parent = cur_left;

			if (!cur_parent)
			{
				cur_left->_parent = nullptr;
				_root = cur_left;
			}
			else
			{
				if (cur_parent->_kv.first > cur_left->_kv.first)
				{
					cur_parent->_left = cur_left;
				}
				else
				{
					cur_parent->_right = cur_left;
				}
				cur_left->_parent = cur_parent;
			}
		}

		bool _is_balance_tree(Node* root)
		{
			if (!root)
				return true;
			else
			{
				int basic_value = _get_black_node_num(root);
				return _is_check_rb_tree(root, 0, basic_value);
			}
		}

		bool _is_check_rb_tree(Node* root, int black_num, int basic_value)
		{
			// basic_value: 红黑树的一条路径中的黑色节点个数，在这里作为基本值
			if (root == nullptr)
			{
				if (black_num != basic_value)
				{
					std::cout << "路径中的黑色节点个数不相等,异常" << std::endl;
					return false;
				}
				else
					return true;
			}
			else
			{
				if (root->_col == BLACK)
					++black_num;
				// 如果一个节点是红色的,那么该节点一定不是根,因此一定有父亲
				// 如果这个节点的父亲也是红色的,那么就说明出现异常
				if (root->_col == RED && root->_parent->_col == RED)
				{
					std::cout << "child: " << root->_kv.first << "parent: " << root->_parent->_kv.first << "出现了连续的红色节点,异常" << std::endl;
					return false;
				}
				return _is_check_rb_tree(root->_left, black_num, basic_value)
					&& _is_check_rb_tree(root->_right, black_num, basic_value);
			}
		}

		int _get_black_node_num(Node* root)
		{
			if (root == nullptr)
				return 0;
			else
			{
				int ret = 0;
				while (root)
				{
					if (root->_col == BLACK)
						++ret;
					root = root->_left;
				}
				return ret;
			}
		}

		int _get_rb_tree_high(Node* root)
		{
			if (root == nullptr)
				return 0;
			else
			{
				int left_high = _get_rb_tree_high(root->_left);
				int right_high = _get_rb_tree_high(root->_right);
				return left_high > right_high ? ++left_high : ++right_high;
			}
		}

	private:
		Node* _root;
	};
}

4.3. map和set的封装

可以看到，我们下面的map和set的封装都用了一个仿函数，原因是因为

map底层用的红黑树的第二个模板参数是一个pair

set底层用的红黑树的第二个模板参数是一个key

第一个模板参数：为了拿到K的类型，因为find、erase这些接口函数的参数都是K

第二个模板参数决定了红黑树的节点存放的数据类型 一种是K，一种是KV

但是此时红黑树不知道你传过来的第二个模板参数具体是什么，因此我们需要在上一层也就是set/map这一层将第二个模板参数是什么告诉给红黑树。

那怎么告诉呢？在这里我们用一个仿函数：

map_key_of_t/set_key_of_t的作用就是，如果你是set，那么我就去取出key，如果你是map那么我就去取出pair的first

4.3.1. map的封装

//map的封装
namespace Xq
{
  template
  class map
  {
    struct map_key_of_t
    {
      const K& operator()(const std::pair& kv)
      {
        return kv.first;
      }
    };
   public:
   //当去取一个类模板类型的时候，需要加typename，因为编译器无法区别静态变量和类型，
   //需要加typename告诉编译器这里是类型
   typedef typename Xq::_rb_tree_iterator,std::pair&,std::pair*> iterator;
    
    iterator begin()
    {
      return _tree.begin();
    }

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

    // 返回插入的键值对的second的引用
    V& operator[](const K& key)
    {
      std::pair ret = _tree.insert(std::make_pair(key,V()));
      return ret.first->second;
    }

    std::pair insert(const std::pair& kv)
    {
      return _tree.insert(kv);
    }
  private: 
    Xq::rb_tree,map_key_of_t> _tree;
  };
}

4.3.2. set的封装

#include "rb_tree.h"

namespace Xq
{
  template
  class set
  {
  public:
    typedef typename Xq::_rb_tree_iterator iterator;
    struct set_key_of_t
    {
      const K& operator()(const K& key)
      {
        return key;
      }
    };

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

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

    std::pair insert(const K& key)
    {
      return _tree.insert(key);
    }

  private:
    Xq::rb_tree _tree;
  };
}

//map和set的底层数据结构红黑树

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace Xq
{
	enum color
	{
		RED,
		BLACK
	};

	template
	struct rb_tree_node
	{
		rb_tree_node* _left;
		rb_tree_node* _right;
		rb_tree_node* _parent;
		T _data;
		color _col;

		rb_tree_node(const T& data = T())
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _data(data)
			, _col(RED)
		{}
	};

	template
	struct _rb_tree_iterator
	{
		typedef typename Xq::_rb_tree_iterator Self;
		typedef typename Xq::rb_tree_node Node;
		Node* _node;
		_rb_tree_iterator(Node* node) :_node(node){}

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

		Ptr operator->()
		{
			return &(operator*());
		}

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

		Self& operator++()
		{
			if (_node->_right)
			{
				// 如果当前节点的右子树不为空,那么下一个节点的位置就是右子树的最左节点
				Node* left_node = _node->_right;
				while (left_node->_left)
				{
					left_node = left_node->_left;
				}
				_node = left_node;
			}
			else
			{
				//如果当前节点的右子树为空,找孩子是父亲的左孩子的那个祖先
				//也就是说当该节点是其父节点的右孩子,则说明它和它的父亲都被访问过了,继续向上走
				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && parent->_right == cur)
				{
					cur = parent;
					parent = cur->_parent;
				}
				_node = parent;
			}

			return *this;
		}

		Self& operator--()
		{
			// 依据右根左的思想
			// 如果当前节点的左子树不为空,那么下一个迭代器的位置就是
			// 左子树的最右节点
			if (_node->_left)
			{
				Node* right_node = _node->_left;
				while (right_node->_right)
				{
					right_node = right_node->_right;
				}
				_node = right_node;
			}
			//如果左子树为空,那么就要找当前孩子是父亲的右孩子的那个祖先
			else
			{
				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && parent->_left == cur)
				{
					cur = parent;
					parent = parent->_parent;
				}
				_node = parent;
			}
			return *this;
		}
	};

	template
	class rb_tree
	{
	private:
		typedef typename Xq::rb_tree_node Node;
		typedef typename Xq::_rb_tree_iterator iterator;
		typedef typename Xq::_rb_tree_iterator const_iterator;
	public:
		rb_tree(Node* root = nullptr) :_root(root){}

		~rb_tree()
		{
			_destroy(_root);
		}

		iterator begin()
		{
			//中序遍历---> begin就是最左节点
			Node* cur = _root;
			while (cur && cur->_left)
			{
				cur = cur->_left;
			}
			return iterator(cur);
		}

		iterator end()
		{
			// end()是最后一个节点的下一个位置的迭代器
			return iterator(nullptr);
		}

		bool find(const T& data)
		{
			key_of_t kot;
			Node* cur = _root;
			while (cur)
			{
				if (kot(cur->_data) > kot(data))
				{
					cur = cur->_left;
				}
				else if (kot(cur->_data) < kot(data))
				{
					cur = cur->_right;
				}
				else
				{
					return true;
				}
			}
			return false;
		}


		std::pair insert(const T& data)
		{
			if (!_root)
			{
				_root = new Node(data);
				_root->_col = BLACK;
				return std::make_pair(iterator(_root), true);
			}
			else
			{
				Node* cur = _root;
				Node* parent = nullptr;
				key_of_t kot;
				while (cur)
				{
					if (kot(cur->_data) > kot(data))
					{
						parent = cur;
						cur = cur->_left;
					}
					else if (kot(cur->_data)< kot(data))
					{
						parent = cur;
						cur = cur->_right;
					}
					else
					{
						//如果插入的键已经存在,则返回一个已存在该键值对的迭代器 
						return std::make_pair(iterator(cur), false);
					}
				}
				cur = new Node(data);
				//由于下面的旋转可能会更改cur,因此提前保存一下
				Node* newnode = cur;
				if (kot(data) > kot(parent->_data))
				{
					parent->_right = cur;
				}
				else
				{
					parent->_left = cur;
				}
				cur->_parent = parent;

				// 当父节点parent的颜色为红色时,需要调整
				while (parent && parent->_col == RED)
				{
					// 因为父节点parent->_col == RED,那么说明parent一定有父节点
					Node* grandfather = parent->_parent;
					if (parent == grandfather->_left)
					{
						Node* uncle = grandfather->_right;
						// case 1: 当父节点为红,且叔叔不为空且为红
						// Solution : 变色
						if (uncle && uncle->_col == RED)
						{
							parent->_col = uncle->_col = BLACK;
							grandfather->_col = RED;
							if (grandfather == _root)
								grandfather->_col = BLACK;
							// 继续向上判断,如果依旧符合case 1,继续变色
							cur = grandfather;
							parent = cur->_parent;
							continue;
						}
						// case 2: 父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c在同一条直线上
						// Solution: 单旋, 在这里就是对grandfather右单旋
						else if (parent->_left == cur && ((!uncle) || uncle->_col == BLACK))
						{
							right_rotate(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
							// 旋转完,更新完颜色,调整就结束
							break;
						}
						// case 3:父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c不在同一条直线上
						// Solution: 双旋,在这里就是先对p进行左单旋,在对g进行右单旋
						else if (parent->_right == cur && ((!uncle) || uncle->_col == BLACK))
						{
							left_rotate(parent);
							right_rotate(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
							// 旋转完,更新完颜色,调整就结束
							break;
						}
						else
						{
							// 非法情况
							assert(false);
						}
					}
					// 当parent是grandfather的右孩子,那么uncle就是grandfather的左孩子
					else
					{
						Node* uncle = grandfather->_left;
						// case 1: 当父节点为红,且叔叔不为空且为红
						// Solution : 变色
						if (uncle && uncle->_col == RED)
						{
							parent->_col = uncle->_col = BLACK;
							grandfather->_col = RED;
							if (grandfather == _root)
								grandfather->_col = BLACK;
							// 继续向上判断,如果依旧符合case 1,继续变色
							cur = grandfather;
							parent = cur->_parent;
							continue;
						}
						// case 2: 父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c在同一条直线上
						// Solution: 单旋, 在这里就是对grandfather左单旋
						else if (parent->_right == cur && ((!uncle) || uncle->_col == BLACK))
						{
							left_rotate(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
							//旋转并将颜色更新后,就退出调整
							break;
						}
						// case 3:父节点为红,且叔叔为空或者不为空且为黑,并且g、p、c不在同一条直线上
						// Solution: 双旋,在这里就是先对p进行右单旋,在对g进行左单旋
						else if (parent->_left == cur && ((!uncle) || uncle->_col == BLACK))
						{
							right_rotate(parent);
							left_rotate(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
							break;
						}
						else
						{
							// 非法情况,断死
							assert(false);
						}
					}
				}
				_root->_col = BLACK;
				return std::make_pair(iterator(newnode), true);
			}
		}

	private:

		void left_rotate(Node* parent)
		{
			Node* cur = parent;
			Node* cur_right = cur->_right;
			Node* cur_right_left = cur_right->_left;
			Node* cur_parent = cur->_parent;

			cur->_right = cur_right_left;
			if (cur_right_left)
				cur_right_left->_parent = cur;

			cur_right->_left = cur;
			cur->_parent = cur_right;

			if (!cur_parent)
			{
				cur_right->_parent = nullptr;
				_root = cur_right;
			}
			else
			{
				if (cur_parent->_left == cur)
				{
					cur_parent->_left = cur_right;
				}
				else
				{
					cur_parent->_right = cur_right;
				}
				cur_right->_parent = cur_parent;
			}
		}

		void right_rotate(Node* parent)
		{
			key_of_t kot;
			Node* cur = parent;
			Node* cur_left = cur->_left;
			Node* cur_left_right = cur_left->_right;
			Node* cur_parent = cur->_parent;

			cur->_left = cur_left_right;
			if (cur_left_right)
				cur_left_right->_parent = cur;

			cur_left->_right = cur;
			cur->_parent = cur_left;

			if (!cur_parent)
			{
				cur_left->_parent = nullptr;
				_root = cur_left;
			}
			else
			{
				if (kot(cur_parent->_data) > kot(cur_left->_data))
				{
					cur_parent->_left = cur_left;
				}
				else
				{
					cur_parent->_right = cur_left;
				}
				cur_left->_parent = cur_parent;
			}
		}

		void _destroy(Node*& root)
		{
			if (root == nullptr)
				return;
			else
			{
				_destroy(root->_left);
				_destroy(root->_right);
				delete root;
				root = nullptr;
			}
		}

	private:
		Node* _root;
	};
}