C++进阶——STL源码之红黑树（_Rb_tree）

STL源码之红黑树

红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组；红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。

红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能；它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。

红黑树的性质

1. 每个节点非红即黑；
2. 根节点是黑的；
3. 每个叶节点（叶节点即树尾端NULL指针或NULL节点）都是黑的；
4. 如图所示，如果一个节点是红的，那么它的两儿子都是黑的；
5. 对于任意节点而言，其到叶子点树NULL指针的每条路径都包含相同数目的黑节点。

_Rb_tree的结构图

_Rb_tree的结点结构

_Rb_tree_node的实现如下，几个实现也很简单，在_Rb_tree_node中定义了结点数据域，在基类_Rb_tree_node_base中分别定义了left、right、parent，另外还有一个表示颜色的标记常量。

另外在_Rb_tree_node_base实现了获取最大值与最小值的方法，根据红黑树的性质，获取最大值只需要在右子树上一直搜索，最小值在左子树上一直搜索。

1. template<typename _Val>

2. struct _Rb_tree_node : public _Rb_tree_node_base

3. {

4. typedef _Rb_tree_node<_Val>* _Link_type;

6. #if __cplusplus < 201103L

7. _Val _M_value_field;

9. _Val*

10. _M_valptr()

11. { return std::__addressof(_M_value_field); }

13. const _Val*

14. _M_valptr() const

15. { return std::__addressof(_M_value_field); }

16. #else

17. __gnu_cxx::__aligned_buffer<_Val> _M_storage;

19. _Val*

20. _M_valptr()

21. { return _M_storage._M_ptr(); }

23. const _Val*

24. _M_valptr() const

25. { return _M_storage._M_ptr(); }

26. #endif

27. };

_Rb_tree_node_base的实现如下：

1. enum _Rb_tree_color { _S_red = false, _S_black = true };

3. struct _Rb_tree_node_base

4. {

5. typedef _Rb_tree_node_base* _Base_ptr;

6. typedef const _Rb_tree_node_base* _Const_Base_ptr;

8. _Rb_tree_color _M_color;

9. _Base_ptr _M_parent;

10. _Base_ptr _M_left;

11. _Base_ptr _M_right;

13. static _Base_ptr

14. _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT

15. {

16. while (__x->_M_left != 0) __x = __x->_M_left;

17. return __x;

18. }

20. static _Const_Base_ptr

21. _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT

22. {

23. while (__x->_M_left != 0) __x = __x->_M_left;

24. return __x;

25. }

27. static _Base_ptr

28. _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT

29. {

30. while (__x->_M_right != 0) __x = __x->_M_right;

31. return __x;

32. }

34. static _Const_Base_ptr

35. _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT

36. {

37. while (__x->_M_right != 0) __x = __x->_M_right;

38. return __x;

39. }

40. };

_Rb_tree的迭代器

_Rb_tree的迭代器首先包含了实现萃取机制的一些typedef，当然实现了一些操作符重载，主要来看下++ 和 -- 的重载。

1. template<typename _Tp>

2. struct _Rb_tree_iterator

3. {

4. typedef _Tp value_type;

5. typedef _Tp& reference;

6. typedef _Tp* pointer;

8. typedef bidirectional_iterator_tag iterator_category;

9. typedef ptrdiff_t difference_type;

11. typedef _Rb_tree_iterator<_Tp> _Self;

12. typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;

13. typedef _Rb_tree_node<_Tp>* _Link_type;

15. _Rb_tree_iterator() _GLIBCXX_NOEXCEPT

16. : _M_node() { }

18. explicit

19. _Rb_tree_iterator(_Link_type __x) _GLIBCXX_NOEXCEPT

20. : _M_node(__x) { }

22. reference

23. operator*() const _GLIBCXX_NOEXCEPT

24. { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

26. pointer

27. operator->() const _GLIBCXX_NOEXCEPT

28. { return static_cast<_Link_type> (_M_node)->_M_valptr(); }

30. _Self&

31. operator++() _GLIBCXX_NOEXCEPT

32. {

33. _M_node = _Rb_tree_increment(_M_node);

34. return *this;

35. }

37. _Self

38. operator++(int) _GLIBCXX_NOEXCEPT

39. {

40. _Self __tmp = *this;

41. _M_node = _Rb_tree_increment(_M_node);

42. return __tmp;

43. }

45. _Self&

46. operator--() _GLIBCXX_NOEXCEPT

47. {

48. _M_node = _Rb_tree_decrement(_M_node);

49. return *this;

50. }

52. _Self

53. operator--(int) _GLIBCXX_NOEXCEPT

54. {

55. _Self __tmp = *this;

56. _M_node = _Rb_tree_decrement(_M_node);

57. return __tmp;

58. }

60. bool

61. operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT

62. { return _M_node == __x._M_node; }

64. bool

65. operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT

66. { return _M_node != __x._M_node; }

68. _Base_ptr _M_node;

69. };

前++的重载

1. _Self&

2. operator++() _GLIBCXX_NOEXCEPT

3. {

4. _M_node = _Rb_tree_increment(_M_node);

5. return *this;

6. }

前++的实现是通过_Rb_tree_increment（libstdc++-v3\src\c++98\tree.cc）来完成，其实现如下：

1. _Rb_tree_node_base*

2. _Rb_tree_increment(_Rb_tree_node_base* __x) throw ()

3. {

4. return local_Rb_tree_increment(__x);

5. }

1. static _Rb_tree_node_base*

2. local_Rb_tree_increment(_Rb_tree_node_base* __x) throw ()

3. {

4. /*

5. 如果当前结点有右子节点，那么右子树的最左结点就是++所需的结点

6. */

7. if (__x->_M_right != 0)

8. {

9. __x = __x->_M_right;

10. while (__x->_M_left != 0)

11. __x = __x->_M_left;

12. }

13. else

14. {

15. /*

16. 1. 如果当前结点是左子树结点，那么++的结果就是当前结点的父结点

17. 2. 如果当前结点是右子树结点，那么++的结果就是父结点的父结点

18. */

19. _Rb_tree_node_base* __y = __x->_M_parent;

20. while (__x == __y->_M_right)

21. {

22. __x = __y;

23. __y = __y->_M_parent;

24. }

25. if (__x->_M_right != __y)

26. __x = __y;

27. }

28. return __x;

29. }

前--的重载

1. _Self&

2. operator--() _GLIBCXX_NOEXCEPT

3. {

4. _M_node = _Rb_tree_decrement(_M_node);

5. return *this;

6. }

_Rb_tree_decrement的实现：

1. _Rb_tree_node_base*

2. _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ()

3. {

4. return local_Rb_tree_decrement(__x);

5. }

1. static _Rb_tree_node_base*

2. local_Rb_tree_decrement(_Rb_tree_node_base* __x) throw ()

3. {

4. /*

5. 从上面的结构图，我们知道，header是红色，并且parent为root，而root的parent为header

6. */

7. if (__x->_M_color == _S_red

8. && __x->_M_parent->_M_parent == __x)

9. __x = __x->_M_right;

10. else if (__x->_M_left != 0)

11. {/*左子树的最大值*/

12. _Rb_tree_node_base* __y = __x->_M_left;

13. while (__y->_M_right != 0)

14. __y = __y->_M_right;

15. __x = __y;

16. }

17. else

18. {

19. _Rb_tree_node_base* __y = __x->_M_parent;

20. while (__x == __y->_M_left)

21. {

22. __x = __y;

23. __y = __y->_M_parent;

24. }

25. __x = __y;

26. }

27. return __x;

28. }

_Rb_tree的成员构成

通过上述的类结构图可知，_Rb_tree 的具体实现是在 _Rb_tree_impl中，主要定义了三个成员变量：

•  _Key_compare        _M_key_compare;
•  _Rb_tree_node_base     _M_header;
•  size_type         _M_node_count; 

_Rb_tree_impl还负责红黑树的初始化操作与内存管理。

1. template<typename _Key_compare,

2. bool _Is_pod_comparator = __is_pod(_Key_compare)>

3. struct _Rb_tree_impl : public _Node_allocator

4. {

5. _Key_compare _M_key_compare;

6. _Rb_tree_node_base _M_header;

7. size_type _M_node_count; // Keeps track of size of tree.

9. _Rb_tree_impl()

10. : _Node_allocator(), _M_key_compare(), _M_header(),

11. _M_node_count(0)

12. { _M_initialize(); }

14. _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)

15. : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),

16. _M_node_count(0)

17. { _M_initialize(); }

19. #if __cplusplus >= 201103L

20. _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)

21. : _Node_allocator(std::move(__a)), _M_key_compare(__comp),

22. _M_header(), _M_node_count(0)

23. { _M_initialize(); }

24. #endif

26. private:

27. void

28. _M_initialize()

29. {

30. this->_M_header._M_color = _S_red;

31. this->_M_header._M_parent = 0;

32. this->_M_header._M_left = &this->_M_header;

33. this->_M_header._M_right = &this->_M_header;

34. }

35. };

_Rb_tree的内存管理

通过获取_M_impl的构造器来完成节点的创建和销毁，这里和我们之前看到的是一致的，内存分配和构造是分开的，在_M_create_node中，先通过构造器去分配，然后通过construct来构造。

1. _Node_allocator&

2. _M_get_Node_allocator() _GLIBCXX_NOEXCEPT

3. { return *static_cast<_Node_allocator*>(&this->_M_impl); }

5. const _Node_allocator&

6. _M_get_Node_allocator() const _GLIBCXX_NOEXCEPT

7. { return *static_cast<const _Node_allocator*>(&this->_M_impl); }

9. allocator_type

10. get_allocator() const _GLIBCXX_NOEXCEPT

11. { return allocator_type(_M_get_Node_allocator()); }

13. protected:

14. _Link_type

15. _M_get_node()

16. { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }

18. void

19. _M_put_node(_Link_type __p) _GLIBCXX_NOEXCEPT

20. { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }

22. #if __cplusplus < 201103L

23. _Link_type

24. _M_create_node(const value_type& __x)

25. {

26. _Link_type __tmp = _M_get_node();

27. __try

28. { get_allocator().construct(__tmp->_M_valptr(), __x); }

29. __catch(...)

30. {

31. _M_put_node(__tmp);

32. __throw_exception_again;

33. }

34. return __tmp;

35. }

37. void

38. _M_destroy_node(_Link_type __p)

39. {

40. get_allocator().destroy(__p->_M_valptr());

41. _M_put_node(__p);

42. }

43. #else

44. template<typename... _Args>

45. _Link_type

46. _M_create_node(_Args&&... __args)

47. {

48. _Link_type __tmp = _M_get_node();

49. __try

50. {

51. ::new(__tmp) _Rb_tree_node<_Val>;

52. _Alloc_traits::construct(_M_get_Node_allocator(),

53. __tmp->_M_valptr(),

54. std::forward<_Args>(__args)...);

55. }

56. __catch(...)

57. {

58. _M_put_node(__tmp);

59. __throw_exception_again;

60. }

61. return __tmp;

62. }

64. void

65. _M_destroy_node(_Link_type __p) noexcept

66. {

67. _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());

68. __p->~_Rb_tree_node<_Val>();

69. _M_put_node(__p);

70. }

71. #endif

73. _Link_type

74. _M_clone_node(_Const_Link_type __x)

75. {

76. _Link_type __tmp = _M_create_node(*__x->_M_valptr());

77. __tmp->_M_color = __x->_M_color;

78. __tmp->_M_left = 0;

79. __tmp->_M_right = 0;

80. return __tmp;

81. }

_Rb_tree的元素操作

在看源码之前先看下以下几个接口：

1. _Link_type

2. _M_begin() _GLIBCXX_NOEXCEPT

3. { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

5. _Const_Link_type

6. _M_begin() const _GLIBCXX_NOEXCEPT

7. {

8. return static_cast<_Const_Link_type>

9. (this->_M_impl._M_header._M_parent);

10. }

12. _Link_type

13. _M_end() _GLIBCXX_NOEXCEPT

14. { return static_cast<_Link_type>(&this->_M_impl._M_header); }

16. _Const_Link_type

17. _M_end() const _GLIBCXX_NOEXCEPT

18. { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }

_M_insert_equal的元素插入操作

1. template<typename _Key, typename _Val, typename _KeyOfValue,

2. typename _Compare, typename _Alloc>

3. #if __cplusplus >= 201103L

4. template<typename _Arg>

5. #endif

6. typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator

7. _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

8. #if __cplusplus >= 201103L

9. _M_insert_equal(_Arg&& __v)

10. #else

11. _M_insert_equal(const _Val& __v)

12. #endif

13. {

14. pair<_Base_ptr, _Base_ptr> __res

15. = _M_get_insert_equal_pos(_KeyOfValue()(__v));

16. return _M_insert_(__res.first, __res.second, _GLIBCXX_FORWARD(_Arg, __v));

17. }

上述代码中调用了_M_get_insert_equal_pos，其中的实现是从根节点开始，往下寻找适当的插入点：

1. template<typename _Key, typename _Val, typename _KeyOfValue,

2. typename _Compare, typename _Alloc>

3. pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,

4. _Compare, _Alloc>::_Base_ptr,

5. typename _Rb_tree<_Key, _Val, _KeyOfValue,

6. _Compare, _Alloc>::_Base_ptr>

7. _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

8. _M_get_insert_equal_pos(const key_type& __k)

9. {

10. typedef pair<_Base_ptr, _Base_ptr> _Res;

11. _Link_type __x = _M_begin();

12. _Link_type __y = _M_end();

13. while (__x != 0)//寻找合适的插入点

14. {

15. __y = __x;

16. __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?

17. _S_left(__x) : _S_right(__x);//遇大往左，遇小往右

18. }

19. return _Res(__x, __y);//x为插入点，y为插入点的父结点

20. }

_M_insert_unique的元素插入操作

1. template<typename _Key, typename _Val, typename _KeyOfValue,

2. typename _Compare, typename _Alloc>

3. #if __cplusplus >= 201103L

4. template<typename _Arg>

5. #endif

6. pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,

7. _Compare, _Alloc>::iterator, bool>

8. _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

9. #if __cplusplus >= 201103L

10. _M_insert_unique(_Arg&& __v)

11. #else

12. _M_insert_unique(const _Val& __v)

13. #endif

14. {

15. typedef pair<iterator, bool> _Res;

16. pair<_Base_ptr, _Base_ptr> __res

17. = _M_get_insert_unique_pos(_KeyOfValue()(__v));

19. if (__res.second)

20. return _Res(_M_insert_(__res.first, __res.second,

21. _GLIBCXX_FORWARD(_Arg, __v)),

22. true);

24. return _Res(iterator(static_cast<_Link_type>(__res.first)), false);

25. }

看下_M_get_insert_unique_pos的主要实现：

1. 插入新值，不允许重复，若重复插入无效
2. 返回值是个pair：第一个元素是rb-tree迭代器指向新增结点；第二个表示成功与否

1. template<typename _Key, typename _Val, typename _KeyOfValue,

2. typename _Compare, typename _Alloc>

3. pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,

4. _Compare, _Alloc>::_Base_ptr,

5. typename _Rb_tree<_Key, _Val, _KeyOfValue,

6. _Compare, _Alloc>::_Base_ptr>

7. _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

8. _M_get_insert_unique_pos(const key_type& __k)

9. {

10. typedef pair<_Base_ptr, _Base_ptr> _Res;

11. _Link_type __x = _M_begin();

12. _Link_type __y = _M_end();

13. bool __comp = true;

14. while (__x != 0)//从根节点开始，寻找合适的插入点

15. {

16. __y = __x;

17. __comp = _M_impl._M_key_compare(__k, _S_key(__x));

18. __x = __comp ? _S_left(__x) : _S_right(__x);

19. }

20. iterator __j = iterator(__y);//指向插入点的父结点

21. if (__comp)//comp为true，说明插在左侧

22. {

23. if (__j == begin())//插入结点的父结点为最左侧结点

24. return _Res(__x, __y);

25. else

26. --__j;

27. }

28. //新键值不与既有结点重复，于是执行安插

29. if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))

30. return _Res(__x, __y);

31. return _Res(__j._M_node, 0);

32. }

_M_insert_的插入操作

__x,__p,__v分别为插入点，插入点父结点，以及新值。

1. template<typename _Key, typename _Val, typename _KeyOfValue,

2. typename _Compare, typename _Alloc>

3. #if __cplusplus >= 201103L

4. template<typename _Arg>

5. #endif

6. typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator

7. _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

8. #if __cplusplus >= 201103L

9. _M_insert_(_Base_ptr __x, _Base_ptr __p, _Arg&& __v)

10. #else

11. _M_insert_(_Base_ptr __x, _Base_ptr __p, const _Val& __v)

12. #endif

13. {

14. bool __insert_left = (__x != 0 || __p == _M_end()

15. || _M_impl._M_key_compare(_KeyOfValue()(__v),

16. _S_key(__p)));

18. _Link_type __z = _M_create_node(_GLIBCXX_FORWARD(_Arg, __v));

20. _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,

21. this->_M_impl._M_header);

22. ++_M_impl._M_node_count;

23. return iterator(__z);

24. }

_Rb_tree_insert_and_rebalance这个函数才是实现的重点，在这里会更新插入结点之后的leftmost、rightmost的更新；以及如果不满足红黑树的性质，就进行调整。

在这里需要结合：数据结构与算法——红黑树（Red Black Tree）中的几种插入情况。

1. void

2. _Rb_tree_insert_and_rebalance(const bool __insert_left,

3. _Rb_tree_node_base* __x,

4. _Rb_tree_node_base* __p,

5. _Rb_tree_node_base& __header) throw ()

6. {

7. _Rb_tree_node_base *& __root = __header._M_parent;

9. // Initialize fields in new node to insert.

10. __x->_M_parent = __p;

11. __x->_M_left = 0;

12. __x->_M_right = 0;

13. __x->_M_color = _S_red;

15. // Insert.

16. // Make new node child of parent and maintain root, leftmost and

17. // rightmost nodes.

18. // N.B. First node is always inserted left.

19. if (__insert_left)

20. {

21. __p->_M_left = __x; // also makes leftmost = __x when __p == &__header

23. if (__p == &__header)

24. {

25. __header._M_parent = __x;

26. __header._M_right = __x;

27. }

28. else if (__p == __header._M_left)

29. __header._M_left = __x; // maintain leftmost pointing to min node

30. }

31. else

32. {

33. __p->_M_right = __x;

35. if (__p == __header._M_right)

36. __header._M_right = __x; // maintain rightmost pointing to max node

37. }

38. // Rebalance.

39. while (__x != __root

40. && __x->_M_parent->_M_color == _S_red) //父结点为红

41. {

42. _Rb_tree_node_base* const __xpp = __x->_M_parent->_M_parent;//获取祖父结点

44. if (__x->_M_parent == __xpp->_M_left) //父结点为祖父结点的左子结点

45. {

46. _Rb_tree_node_base* const __y = __xpp->_M_right;

47. if (__y && __y->_M_color == _S_red) //对应状况1

48. {

49. __x->_M_parent->_M_color = _S_black;

50. __y->_M_color = _S_black;

51. __xpp->_M_color = _S_red;

52. __x = __xpp;

53. }

54. else

55. {//无伯父结点

56. if (__x == __x->_M_parent->_M_right) //新结点为父结点的右子结点，对应状况2

57. {

58. __x = __x->_M_parent;

59. local_Rb_tree_rotate_left(__x, __root);

60. }

61. __x->_M_parent->_M_color = _S_black;//经过左旋之后，对应状况3，需要再做一次右旋

62. __xpp->_M_color = _S_red;

63. local_Rb_tree_rotate_right(__xpp, __root);

64. }

65. }

66. else

67. {

68. _Rb_tree_node_base* const __y = __xpp->_M_left;

69. if (__y && __y->_M_color == _S_red) //类似于状况1，只不过为祖父结点的右子结点

70. {

71. __x->_M_parent->_M_color = _S_black;

72. __y->_M_color = _S_black;

73. __xpp->_M_color = _S_red;

74. __x = __xpp;

75. }

76. else

77. {

78. if (__x == __x->_M_parent->_M_left) //类似于2，3，只不过是做相反的旋转

79. {

80. __x = __x->_M_parent;

81. local_Rb_tree_rotate_right(__x, __root);

82. }

83. __x->_M_parent->_M_color = _S_black;

84. __xpp->_M_color = _S_red;

85. local_Rb_tree_rotate_left(__xpp, __root);

86. }

87. }

88. }

89. __root->_M_color = _S_black;

90. }

状况1：

此时将当前结点的父结点和叔叔节点涂黑，祖父结点涂红；并把当前结点指向祖父结点，从新的当前结点重新开始计算。

状况2：

当前结点的父结点作为新的当前结点，以新当前结点为支点进行左旋。

状况3：

此时将父结点变为黑色，祖父结点变为红色，祖父结点作为支点进行右旋。

右旋的实现local_Rb_tree_rotate_right：

1. static void

2. local_Rb_tree_rotate_right(_Rb_tree_node_base* const __x,

3. _Rb_tree_node_base*& __root)

4. {

5. _Rb_tree_node_base* const __y = __x->_M_left;

7. __x->_M_left = __y->_M_right;

8. if (__y->_M_right != 0)

9. __y->_M_right->_M_parent = __x;

10. __y->_M_parent = __x->_M_parent;

12. if (__x == __root)

13. __root = __y;

14. else if (__x == __x->_M_parent->_M_right)

15. __x->_M_parent->_M_right = __y;

16. else

17. __x->_M_parent->_M_left = __y;

18. __y->_M_right = __x;

19. __x->_M_parent = __y;

20. }

左旋的实现local_Rb_tree_rotate_left：

1. static void

2. local_Rb_tree_rotate_left(_Rb_tree_node_base* const __x,

3. _Rb_tree_node_base*& __root)

4. {

5. _Rb_tree_node_base* const __y = __x->_M_right;

7. __x->_M_right = __y->_M_left;

8. if (__y->_M_left !=0)

9. __y->_M_left->_M_parent = __x;

10. __y->_M_parent = __x->_M_parent;

12. if (__x == __root)

13. __root = __y;

14. else if (__x == __x->_M_parent->_M_left)

15. __x->_M_parent->_M_left = __y;

16. else

17. __x->_M_parent->_M_right = __y;

18. __y->_M_left = __x;

19. __x->_M_parent = __y;

20. }

以上参考：

• STL源码剖析
• https://www.cnblogs.com/newobjectcc/p/11293689.html
• 【B站最全面的红黑树结构详解】数据结构红黑树，二叉树，HASH，B+树详解，平衡算法详解_哔哩哔哩_bilibili

(1742条消息) C++进阶——STL源码之红黑树（_Rb_tree）__m_get_insert_unique_pos_&动感超人的博客-CSDN博客