map、set（底层结构）——C++

编程语言 2023-05-05 03:59:47 阅读次数: 0

文章目录

4. 底层结构

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

4.1 AVL 树

高度平衡二叉搜索树，是以人名命名的

4.1.1 AVL树的概念

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

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

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)（非必须）
    平衡因子 = 右子树高度-左子树高度

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

平衡因子需要三叉链
但是旋转的时候也会变复杂

4.1.2AVL树节点的定义

t

emplate<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)
{
    
    }
};

4.1.3 AVL树的插入

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

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子

更新平衡因子的规则：
1.新增在右，parent->bf++;新增在左，parent->bf–
 
2.更新后，parent->bf == 1 or -1,说明parent插入前的平衡因子是0，说明左右子树高度相等，插入后有一边高，parent高度变了，需要继续往上更新
 
3.更新后，parent->bf == 0，说明parent插入前的平衡因子是1或-1，说明左右子树一边高一边低，插入后两边一样高，插入填上了矮的那边，parent所在子树高度不变，不需要继续往上更新
 
4.更新后，parent->bf == 2 or -2，说明parent插入前的平衡因子是1或-1，已经到达平衡临界值，插入后变成2或-2，打破平衡，parent所在子树需要旋转处理
 
5.更新后，parent->>2 or <-2的值，不可能，如果存在，说明插入前的就不是AVL数，需要去检查之前操作的问题

//插入
cur = new Node(kv);
//链接
if (parent->_kv.first < kv.first)
{
    
    
//插入的值大就插入右边
parent->_right = cur;
}
else
{
    
    
//插入的值小就插入左边
parent->_left = cur;
}
//三叉链还要考虑parent
cur->_parent = parent;


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

if (parent->_bf == 0)
{
    
    
break;
}
else if (abs(parent->_bf) == 1)
{
    
    
                                //往上更新
parent = parent->_parent;
cur = cur->_parent;
}
else if (abs(parent->_bf) == 2)
{
    
    
// 说明parent所在子树已经不平衡了，需要旋转处理
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);
}

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

return true;
}

 
 

4.1.4 AVL树的旋转

原则：

  1. 旋转成平衡树
  2. 保持搜索树的规则
 else if (abs(parent->_bf) == 2)
{
    
    
// 说明parent所在子树已经不平衡了，需要旋转处理
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);
}

break;
}

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

1. 新节点插入较高左子树的左侧—左左：右单旋

a、b、c是h >= 0的平衡树
左边高，往右边旋转
只有parent和subL的平衡因子受影响——全变为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 (_root == parent)
{
    
    
_root = subL;
subL->_parent = nullptr;
}
else
{
    
    
if (ppNode->_left == parent)
{
    
    
ppNode->_left = subL;
}
else
{
    
    
ppNode->_right = subL;
}

subL->_parent = ppNode;
}

subL->_bf = parent->_bf = 0;
}
  1. 新节点插入较高右子树的右侧—右右：左单旋

parent是整棵树的根
parent是子树的根
要动六个指针
只有parent和subR的平衡因子受影响——全变为0

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 (_root == parent)
{
    
    
_root = subR;
subR->_parent = nullptr;
}
else
{
    
    
if (ppNode->_left == parent)
{
    
    
ppNode->_left = subR;
}
else
{
    
    
ppNode->_right = subR;
}

subR->_parent = ppNode;
}

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

单旋（1、2）：a、b、c是高度为h的AVL子树，h>=0; 旋转的价值和意义：

  • 平衡 降高度（高度恢复到插入之前的样子）
  • 新节点插入较高左子树的右侧—左右：先左单旋再右单旋

3. 新节点插入较高左子树的右侧—左右：先左单旋再右单旋

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

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

subLR->_bf = 0;
if (bf == 1)
{
    
    
parent->_bf = 0;
subL->_bf = -1;
}
else if (bf == -1)
{
    
    
// 错的
/*parent->_bf = 0;
subL->_bf = 1;*/

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

4. 新节点插入较高右子树的左侧—右左：先右单旋再左单旋

参考右左双旋。

void RotateRL(Node* parent)
{
    
    
Node* subR = parent->_right;
Node* subRL = subR->_left;

int bf = subRL->_bf;

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

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

双旋（3、4）：a、b、c、d高度位h或者h-1的AVL树 三种插入情况：

  1. b插入新增，引发双旋
  2. c插入新增，引发双旋
  3. a、b 、c、d是空树，60是新增（用图片举例），引发双旋

双旋过程不变，平衡因子的更新需要分别处理

总结： 假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR 当pSubR的平衡因子为1时，执行左单旋 当pSubR的平衡因子为-1时，执行右左双旋
  2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL 当pSubL的平衡因子为-1是，执行右单旋 当pSubL的平衡因子为1时，执行左右双旋
    旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新

4.1.5 AVL树的验证

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

  1. 验证其为二叉搜索树 如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
  2. 验证其为平衡树 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子) 节点的平衡因子是否计算正确

public: bool IsBalance() { return _IsBalance(_root); } private: bool
_IsBalance(Node* root) { // 空树也是AVL树

if (root == nullptr) { return true; }

int leftHT = Height(root->_left); int rightHT = Height(root->_right);
int diff = rightHT - leftHT;//差值

if (diff != root->_bf) { cout << root->_kv.first << “平衡因子异常” << endl;
return false; }

return abs(diff) < 2 && _IsBalance(root->_left) &&
_IsBalance(root->_right);//自己判断完之后再去判断左子树和右子树 }

//求高度 int Height(Node* root) { if (root == nullptr) return 0;

return max(Height(root->_left), Height(root->_right)) + 1; }

  1. 验证用例
    常规场景1
    {16, 3, 7, 11, 9, 26, 18, 14, 15}
    特殊场景2
    {4, 2, 6, 1, 3, 5, 15, 7, 16, 14}
void TestAVLTree1()
{
    
    
int a[] = {
    
     4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };  // 测试双旋平衡因子调节
//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
AVLTree<int, int> t1;
for (auto e : a)
{
    
    
t1.Insert(make_pair(e, e));
}

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


//给随机值测试用例
void TestAVLTree2()
{
    
    
size_t N = 10000;
srand(time(0));
AVLTree<int, int> t1;
for (size_t i = 0; i < N; ++i)
{
    
    
int x = rand();
t1.Insert(make_pair(x, i));
/*bool ret = t1.IsBalance();
if (ret == false)
{
int u = 1;
}
else
{
cout << "Insert:" << x << " IsBalance:" <<ret<< endl;
}*/
}
cout << "IsBalance:" << t1.IsBalance() << endl;
}

4.1.6AVL树的性能

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

 
 

4.2 红黑树

AVL树：要求左右高度差不超过1（严格平衡）
红黑树：最长路径不超过最短路径的2倍（不严格——近似平衡）
效果：相对而言，插入同样数据，AVL树旋转更多，红黑树旋转更少

4.2.1 红黑树的概念

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

4.2.2 红黑树的性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 解读：书中没有连续的红色结点，（可以有连续的黑结点）
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 解读：每条路径的黑色节点数量相等
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)NIL结点

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点
个数的两倍？

极限最短：全黑
极限最长：一黑一红……

路径不是算到叶子，完整的路径是要算到空结点

4.2.4 红黑树结构

为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点

4.2.3 红黑树节点的定义

// 节点的颜色
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)
{
    
    }
};

4.2.5 红黑树的插入操作

新结点插入，是什么颜色？
默认给红色。——违反规则3比违反规则4好一点
新插入的结点的父亲是红的话一定要将其变黑

处理规则：
1.变色
2.旋转

红黑树的关键是叔叔！
u存在且为红，变色继续往上处理
u不存在或存在且为黑，旋转+变色（单旋+双旋）

  1. 按照二叉搜索的树规则插入新节点
  2. 检测新节点插入后，红黑树的性质是否造到破坏

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

情况一: cur为红，p为红，g为黑，u存在且为红
cur和p均为红，违反了性质三，此处能否将p直接改为黑？
解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑
p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
p为g的右孩子，cur为p的右孩子，则进行左单旋转
p、g变色–p变黑，g变红

情况三: cur为红，p为红，g为黑，u不存在/u存在且为黑
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，
p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
则转换成了情况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);
cur->_col = RED;//新插入的结点默认为红色

if (parent->_kv.first < kv.first)
{
    
    
parent->_right = cur;
}
else
{
    
    
parent->_left = cur;
}

cur->_parent = parent;
  
   //parent存在且颜色为红色，继续处理

while (parent && parent->_col == RED)
{
    
    
Node* grandfater = parent->_parent;
assert(grandfater);
assert(grandfater->_col == BLACK);

                        // 关键看叔叔
if (parent == grandfater->_left)
{
    
    
Node* uncle = grandfater->_right;
// 情况一 : uncle存在且为红，变色+继续往上处理
if (uncle && uncle->_col == RED)
{
    
    
parent->_col = uncle->_col = BLACK;
grandfater->_col = RED;
// 继续往上处理
cur = grandfater;
parent = cur->_parent;
}// 情况二+三：uncle不存在 + 存在且为黑
else
{
    
    
// 情况二：右单旋+变色
//     g 
//   p   u
// c
if (cur == parent->_left)
{
    
    
RotateR(grandfater);
parent->_col = BLACK;
grandfater->_col = RED;
}
else
{
    
    
// 情况三：左右单旋+变色
//     g 
//   p   u
//     c
RotateL(parent);
RotateR(grandfater);
cur->_col = BLACK;
grandfater->_col = RED;
}

break;
}
}
else // (parent == grandfater->_right)
{
    
    
Node* uncle = grandfater->_left;
// 情况一
if (uncle && uncle->_col == RED)
{
    
    
parent->_col = uncle->_col = BLACK;
grandfater->_col = RED;
// 继续往上处理
cur = grandfater;
parent = cur->_parent;
}
else
{
    
    
// 情况二：左单旋+变色
//     g 
//   u   p
//         c
if (cur == parent->_right)
{
    
    
RotateL(grandfater);
parent->_col = BLACK;
grandfater->_col = RED;
}
else
{
    
    
// 情况三：右左单旋+变色
//     g 
//   u   p
//     c
RotateR(parent);
RotateL(grandfater);
cur->_col = BLACK;
grandfater->_col = RED;
}

break;
}
}

}

_root->_col = BLACK;
return true;
}

4.2.6 红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质
public:
 bool IsBalance()
{
    
    
if (_root == nullptr)
{
    
    
return true;
}

if (_root->_col == RED)
{
    
    
cout << "根节点不是黑色" << endl;
return false;
}

// 黑色节点数量基准值
int benchmark = 0;
/*Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
++benchmark;

cur = cur->_left;
}*/

return PrevCheck(_root, 0, benchmark);
}

private:
bool PrevCheck(Node* root, int blackNum, int& benchmark)
{
    
    
if (root == nullptr)
{
    
    
//cout << blackNum << endl;
//return;
if (benchmark == 0)
{
    
    
benchmark = blackNum;
return true;
}

if (blackNum != benchmark)
{
    
    
cout << "某条黑色节点的数量不相等" << endl;
return false;
}
else
{
    
    
return true;
}
}

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

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

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

递归中，blackNum记录根结点——当前结点路径上黑色结点数量
前序递归遍历即可

4.2.8 红黑树与AVL树的比较

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

4.3 红黑树模拟实现STL中的map与set

4.3.1 红黑树的迭代器

T是一个泛型，没有具体类型
增加一个参数 KeyOfT 是一个仿函数——方便比较大小
作用：将value中的key提取出来

begin\end

  • begin返回中序第一个
  • end返回最后一个结点的下一个
template<class K, class T, class KeyOfT>
struct RBTree
{
    
    
typedef RBTreeNode<T> Node;
public:
typedef __RBTreeIterator<T, T&, T*> iterator;

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

return iterator(left);
}

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

operator+±-

++
中序：左子树 根 右子树
右子树不为空，++就是找右子树中序第一个（最左结点）
右子树为空，++找孩子不是父亲右的那个祖先

--
中序反过来：右子树 根 左子树
左子树不为空,–访问左子树中的最右结点
左子树为空，–找孩子不是父亲左的那个祖先

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)
{
    
    }

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

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

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

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

Self& operator++()
{
    
    
if (_node->_right)
{
    
    
// 下一个就是右子树的最左节点
Node* left = _node->_right;
while (left->_left)
{
    
    
left = left->_left;
}

_node = left;
}
else
{
    
    
// 找祖先里面孩子不是祖先的右的那个
Node* parent = _node->_parent;
Node* cur = _node;
while (parent && cur == parent->_right)
{
    
    
cur = cur->_parent;
parent = parent->_parent;
}

_node = parent;
}

return *this;
}

Self& operator--()
{
    
    
if (_node->_left)
{
    
    
// 下一个是左子树的最右节点
Node* right = _node->_left;
while (right->_right)
{
    
    
right = right->_right;
}

_node = right;
}
else
{
    
    
// 孩子不是父亲的左的那个祖先
Node* parent = _node->_parent;
Node* cur = _node;
while (parent && cur == parent->_left)
{
    
    
cur = cur->_parent;
parent = parent->_parent;
}

_node = parent;
}

return *this;
}
};

4.3.2改造红黑树

#pragma once

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)
	{
    
    }
};

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)
	{
    
    }

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

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

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

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

	Self& operator++()
	{
    
    
		if (_node->_right)
		{
    
    
			// 下一个就是右子树的最左节点
			Node* left = _node->_right;
			while (left->_left)
			{
    
    
				left = left->_left;
			}

			_node = left;
		}
		else
		{
    
    
			// 找祖先里面孩子不是祖先的右的那个
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_right)
			{
    
    
				cur = cur->_parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
    
    
		if (_node->_left)
		{
    
    
			// 下一个是左子树的最右节点
			Node* right = _node->_left;
			while (right->_right)
			{
    
    
				right = right->_right;
			}

			_node = right;
		}
		else
		{
    
    
			// 孩子不是父亲的左的那个祖先
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_left)
			{
    
    
				cur = cur->_parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}
};

template<class K, class T, class KeyOfT>
struct RBTree
{
    
    
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;

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

		return iterator(left);
	}

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

	pair<iterator, bool> Insert(const T& data)
	{
    
    
		KeyOfT kot;

		if (_root == nullptr)
		{
    
    
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}

		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;
		cur->_col = RED;

		if (kot(parent->_data) < kot(data))
		{
    
    
			parent->_right = cur;
		}
		else
		{
    
    
			parent->_left = cur;
		}

		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
    
    
			Node* grandfater = parent->_parent;
			assert(grandfater);
			assert(grandfater->_col == BLACK);
			// 关键看叔叔
			if (parent == grandfater->_left)
			{
    
    
				Node* uncle = grandfater->_right;
				// 情况一 : uncle存在且为红，变色+继续往上处理
				if (uncle && uncle->_col == RED)
				{
    
    
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					// 继续往上处理
					cur = grandfater;
					parent = cur->_parent;
				}// 情况二+三：uncle不存在 + 存在且为黑
				else
				{
    
    
					// 情况二：右单旋+变色
					//     g 
					//   p   u
					// c
					if (cur == parent->_left)
					{
    
    
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else
					{
    
    
						// 情况三：左右单旋+变色
						//     g 
						//   p   u
						//     c
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}

					break;
				}
			}
			else // (parent == grandfater->_right)
			{
    
    
				Node* uncle = grandfater->_left;
				// 情况一
				if (uncle && uncle->_col == RED)
				{
    
    
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					// 继续往上处理
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
    
    
					// 情况二：左单旋+变色
					//     g 
					//   u   p
					//         c
					if (cur == parent->_right)
					{
    
    
						RotateL(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else
					{
    
    
						// 情况三：右左单旋+变色
						//     g 
						//   u   p
						//     c
						RotateR(parent);
						RotateL(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}

					break;
				}
			}

		}

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

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

	bool IsBalance()
	{
    
    
		if (_root == nullptr)
		{
    
    
			return true;
		}

		if (_root->_col == RED)
		{
    
    
			cout << "根节点不是黑色" << endl;
			return false;
		}

		// 黑色节点数量基准值
		int benchmark = 0;


		return PrevCheck(_root, 0, benchmark);
	}

private:

	bool PrevCheck(Node* root, int blackNum, int& benchmark)
	{
    
    
		if (root == nullptr)
		{
    
    
			//cout << blackNum << endl;
			//return;
			if (benchmark == 0)
			{
    
    
				benchmark = blackNum;
				return true;
			}

			if (blackNum != benchmark)
			{
    
    
				cout << "某条黑色节点的数量不相等" << endl;
				return false;
			}
			else
			{
    
    
				return true;
			}
		}

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

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

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

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

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_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 (_root == parent)
		{
    
    
			_root = subR;
			subR->_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 (_root == parent)
		{
    
    
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
    
    
			if (ppNode->_left == parent)
			{
    
    
				ppNode->_left = subL;
			}
			else
			{
    
    
				ppNode->_right = subL;
			}

			subL->_parent = ppNode;
		}

	}

private:
	Node* _root = nullptr;
};

4.3.3 map的模拟实现

#pragma once

#include "RBTree.h"

namespace haha
{
    
    
template<class K, class V>
class map
{
    
    
 //作用：将value中的key提取出来

struct MapKeyOfT
{
    
    
const K& operator()(const pair<K, V>& kv)
{
    
    
return kv.first;
}
};
public:
typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;

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

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

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

V& operator[](const K& key)
{
    
    
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
private:
RBTree<K, pair<K, V>, MapKeyOfT> _t;
};

void test_map()
{
    
    
string arr[] = {
    
     "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

map<string, int> countMap;
for (auto& str : arr)
{
    
    
// 1、str不在countMap中，插入pair(str, int()),然后在对返回次数++
// 2、str在countMap中，返回value(次数)的引用，次数++;
countMap[str]++;
}

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

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

4.3.4 set的模拟实现

#pragma once

#include "RBTree.h"

namespace haha
{
    
    
template<class K>
class set
{
    
    
struct SetKeyOfT
{
    
    
const K& operator()(const K& key)
{
    
    
return key;
}
};
public:
typedef typename RBTree<K, K, SetKeyOfT>::iterator 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_set()
{
    
    
set<int> s;

set<int>::iterator it = s.begin();
while (it != s.end())
{
    
    
cout << *it << " ";
++it;
}
cout << endl;

s.insert(3);
s.insert(2);
s.insert(1);
s.insert(5);
s.insert(3);
s.insert(6);
s.insert(4);
s.insert(9);
s.insert(7);


it = s.begin();
while (it != s.end())
{
    
    
cout << *it << " ";
++it;
}
cout << endl;
}
}

猜你喜欢

转载自blog.csdn.net/Ll_R_lL/article/details/127893646
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022