「C++」红黑树的插入(手撕红黑树系列)

最新推荐文章于 2024-10-31 09:04:32 发布
最新推荐文章于 2024-10-31 09:04:32 发布
阅读量203 收藏 5
点赞数 5
分类专栏： C++ 文章标签： c++ java 开发语言 数据结构 b树 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CaTianRi/article/details/134543216
版权
在这里插入图片描述

💻文章目录

📄前言

作为一名程序员相信你一定有所听闻红黑树的大名，像是手撕红黑树这样的名梗已经几乎传遍了程序员之间，如果你还不会“手撕”红黑树，那么本文将会教会你如何“手撕”红黑树。

红黑树

概念

红黑树，顾名思义是只有红色和黑色两种颜色的树，由 Rudolf Bayer 在1972年发明的。红黑树是一种高效的查找树，可以在 O ( l o g 2 n ) O(log_2n) O(log2​n)的时间复杂度下进行查找、插入和删除，C++中的map和set的底层也是利用红黑树所构成，在深入学习红黑树前，先让我们学习一下它的特性吧。

红黑树的特性：

  1. 根节点为黑
    t2. 最长路径的长度不超过最短路径的长度的两倍
  2. 每条路径的黑色节点之和都相同
  3. 不能存在连续的红色节点
  4. 只存在红色或黑色的节点
  5. 中序遍历是有序的

红黑树的样例：
在这里插入图片描述在这里插入图片描述

从图例我们可以看出每条路径的黑色节点个数都是相同的并且没有连续的红色节点，只要满足这两条特性，红黑树的最长路径节点个数不会超过最短节点个数的两倍，从而维护了树的平衡。

红黑树的结构

红黑树节点的定义

在进入插入操作前，得先定义好树的节点。因为树的插入需要用到父节点、甚至祖父节点，所以为了方便插入，二叉树的节点新增了父节点的指针。

enum Color	//颜色的定义
{
    RED,	//0
    BLACK	//1
};

template <class _Value>
struct RBTreeNode		//红黑树节点的定义
{
    RBTreeNode<_Value>* _left;	//节点的左孩子
    RBTreeNode<_Value>* _right;	//节点的右孩子
    RBTreeNode<_Value>* _parent;	//节点的双亲
    Color _col;		//节点的颜色
    _Value _data;			//节点的数值

    RBTreeNode(const _Value& data = _Value())	//节点的构造函数
        :_left(nullptr)
        ,_right(nullptr)
        ,_parent(nullptr)
        ,_data(data)
        ,_col(RED)	//默认设节点为红色
    {}
};

红黑树的定义

C++的红黑树在实现上为了同时让map和set复用，增加了一个keyofvalue的模板参数，用来解析需要比较的数值，如果不打算实现set和map可以不用写。

template<class _Key, class _Value, class _KeyOfValue>	
/*如果愿意还可以加上一个compare参数，来比较数值*/
class RBTree
{
public:
    typedef RBTreeNode<_Value> Node;
    /*这里暂时先把insert的返回值设为Node*，迭代器后面介绍时再补充*/
    Node* insert(const _Value data)		
    {
    	if(_root == nullptr)			//节点为空则新建
	    {
	        _root = new Node(data);
	        _root->_col = BLACK;		//红黑书性质规定根节点必须为黑
	        return _root;
	    }
	    
	    _KeyOfValue kot;		//用来解析数据的伪函数
	    Node* cur = _root;
	    Node* parent = nullptr;		
	    while(cur)			/*二叉树搜索树的经典搜索过程*/
	    {
	    	//工作原理：是data是pair类型则返回data.first,正常内置类型直接返回data
	        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 cur;
	    }
	
	    cur = new Node(data);
	    Node* ret = cur;
	    cur->_parent = parent;		/*链接父节点*/
	    /*父节点链接子节点*/
	    if(kot(cur->_data) < kot(parent->_data))
	        parent->_left = cur;
	    else 
	        parent->_right = cur;	
	        
		/***************检查红黑树是否违反性质**************/
    }
}

红黑树的调整

红黑树的每次插入都需要检查其性质是否遭到了破坏，因为节点默认颜色为红色，所以当父节点为黑色时，则不需要调整。如果父节点为红色，违反了红黑树的性质，根据红黑树的情况，共有六种情况需要讨论，其中需要利用到祖父节点，根据父节点在祖父节点的左孩子/右孩子，又将6种情况划分为两类。

为了方便讨论，这里把当前节点作为cur，cur的父节点为p，cur的祖父节点为g，p的兄弟节点为u

  • 父节点是祖父节点的左孩子

    • 情况一：cur为红，p为红，g为黑，u存在且为红

      这种情况下，需要把p节点和u节点设为黑色，如果g节点为根节点则退出调整，否则将g节点设为红色，并把g赋值给cur，继续向上调整。
      在这里插入图片描述

      if(uncle && uncle->_col == RED)
{
	parent->_col = uncle->_col = BLACK;
	grandParent->_col = RED;
	
	cur = grandParent;
	parent = cur->_parent;
}

    • 情况二：cur为红，p为红，g为黑，u不存在/存在且为黑，并且cur为p的左孩子

      这种情况下，需要对p节点进行右旋操作，并将p节点改为黑，cur和g节点改为红。
      在这里插入图片描述

      if(uncle && uncle->_col == BLACK)
{
     parent->_col = uncle->_col = BLACK;
     grandParent->_col = RED;
     
     cur = grandParent;
     parent = cur->_parent;
}

    • 情况三：cur为红，p为红，g为黑，u不存在/存在且为黑，并且cur为p的左孩子
      在这种情况下，需要对双旋操作，先对p节点进行左旋，使得树变得极端左倾，然后再对g节点进行右倾恢复平衡，最后将g改为红，p改为黑。

      在这里插入图片描述

      else {
	RotateL(parent);
 	RotateR(grandParent);
 	grandParent->_col = RED;
 	cur->_col = BLACK;
}

  • 父节点是祖父节点的右孩子

    • 情况四：cur为红，p为红，g为黑，u存在且为红
      与情况一的处理一样
      在这里插入图片描述

      if(uncle && uncle->_col == BLACK)
{
		parent->_col = uncle->_col = BLACK;
		grandParent->_col = RED;
		cur = grandParent;
		parent = cur->_parent;
}

    • 情况五：cur为红，p为红，g为黑，u不存在/存在且为黑, 并且cur为p的左孩子
      这种情况下，需要对g节点进行左旋操作，并把p节点改黑、g节点改红。
      在这里插入图片描述

      if(cur == parent->_right)
{
	RotateL(grandParent);
	parent->_col = BLACK;
	grandParent->_col = RED;
}

    • 情况六：cur为红，p为红，g为黑，u不存在/存在且为黑, 并且cur为p的右孩子
      这种情况下，需要对p节点进行右旋，使树变得极端右倾，然后对g节点进行左旋，最后将g节点改红、cur节点改黑。
      在这里插入图片描述

    else 
{
	RotateR(parent);
	RotateL(grandParent);
	grandParent->_col = RED;
	cur->_col = BLACK;
}

红黑树的迭代器

做完了树的插入，接下来就是红黑树的迭代器了。因为红黑树是平衡树，所以它的最小节点在树的最左侧，最大节点在树的最右侧，为此我们可以使用一个头节点，让其左右孩子指向最大最小节点，父节点指向跟节点。

在这里插入图片描述

迭代器的声明

template <class T, class Ref, class Ptr>	//Ref、Ptr用于const_iterator
struct _TreeIterator
{
    typedef RBTreeNode<T> Node;
    typedef _TreeIterator<T, Ref, Ptr> self;
    Node* _node;

	self& operator--();
	self& operator++();
}

operator( )++

找平衡树的下一个比当前节点大的节点，有两种情况

  • 当前节点存在右节点，则找右节点最左边的节点。
  • 不存在右节点，则返回父节点直到当前节点不是父节点的左节点
self& operator++() /*寻找下一个更大节点*/
{
	if(_node->_right)	
	{
	    Node* cur = _node->_right;
	    while(cur->_left)		/*寻找最左侧节点*/
	        cur = cur->_left;
	
	    _node = cur;
	}
	else 
	{
	    Node* cur = _node;		
	    Node* parent = cur->_parent;		
	    while(parent && cur == parent->_right)
	    {		/*右子树不存在，继续向上调整*/
	        cur = parent;
	        parent = parent->_parent;
	    }
	    _node = parent;
	}
	
	return *this;
}

opeartor–( )

寻找上一节点也分两种情况。

  • 当前节点左孩子存在，则找到左孩子的最右侧节点。
  • 当前节点不存在左孩子，则向上寻找直到当前节点不再是父节点的左孩子
self& operator--()
{
    Node* cur = _node;
    if(cur->_col == RED && cur->_parent->_parent == cur)
    {				//当前节点为头节点
        cur = cur->_right;
    }
    if(cur->_left)
    {		//左子树存在，在左子树寻找最大节点
        cur = cur->_left;
        while(cur->_right)
            cur = cur->_right;
    }
    else
    {		//向上调整
        Node* parent = cur->_parent;
        while(parent && cur == parent->_left)
        {
            cur = parent;
            parent = parent->_parent;
        }
        cur = parent;
    }
    _node = cur;

    return *this;
}

完整代码

template <class T, class Ref, class Ptr>
struct _TreeIterator		//迭代器
{
    typedef RBTreeNode<T> Node;
    typedef _TreeIterator<T, Ref, Ptr> self;
    typedef _TreeIterator<T, T&, T*> iterator;  
    Node* _node;

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

    _TreeIterator(const iterator& _it) //构造函数，方便以后实现set中的inset函数中的pair拷贝
        :_node(_it._node)
    {
    }
    
    Ref operator*()const
    {
        return _node->_data;
    }

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

    self& operator--()
    {
        Node* cur = _node;
        if(cur->_col == RED && cur->_parent->_parent == cur)
        {			
            cur = cur->_right;
        }
        if(cur->_left)
        {
            cur = cur->_left;
            while(cur->_right)
                cur = cur->_right;
        }
        else
        {
            Node* parent = cur->_parent;
            while(parent && cur == parent->_left)
            {
                cur = parent;
                parent = parent->_parent;
            }
            cur = parent;
        }
        _node = cur;

        return *this;
    }

    self&& operator--(int)
    {
        self tem = *this;
        Node* cur = _node;
        if(cur->_col == RED && cur->_parent->_parent == cur)
        {
            cur = cur->_right;
        }
        if(cur->_left)
        {
            cur = cur->_left;
            while(cur->_right)
                cur = cur->_right;
        }
        else
        {
            Node* parent = cur->_parent;
            while(parent && cur == parent->_left)
            {
                cur = parent;
                parent = parent->_parent;
            }
            cur = parent;
        }
        _node = cur;

        return tem;
    }

    self& operator++()
    {
        if(_node->_right)
        {
            Node* cur = _node->_right;
            while(cur->_left)
                cur = cur->_left;

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

        return *this;
    }

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

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

template<class K, class T, class KeyOfT>	//可是选择加上 class compare
class RBTree
{
public:
	typedef RBTreeNode<T> Node;
    typedef _TreeIterator<T, T&, T*> iterator;
    typedef _TreeIterator<T, const T&, const T*> const_iterator;		
	RBTree()
	{		//提前开好头节点
		_root = new Node;
		_root->_left = _root;
		_root->_right = _root;
	}

    const_iterator begin() const 
    {
        return const_iterator(LeftMost());
    }

    const_iterator end() const 
    {
        return const_iterator(_root);
    }

    iterator begin()
    {
        return iterator(LeftMost());
    }

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

    std::pair<iterator, bool> Insert(const T& data);		//上文insert返回值设为了Node*，但实际应该是这个

    // 检测红黑树中是否存在值为data的节点，存在返回该节点的地址，否则返回nullptr
    iterator Find(const K& data);
    const_iterator Find(const K& data) const;
    
    // 获取红黑树最左侧节点
	Node* LeftMost()const;

    // 中序遍历
    void InOrder() 
    {
        _InOrder(GetRoot());
        std::cout << std::endl;
    }
    
    // 获取红黑树最右侧节点
	Node* RightMost()const;
    
    // 检测红黑树是否为有效的红黑树，注意：其内部主要依靠_IsValidRBTRee函数检测
	bool IsValidRBTRee();
private:
	bool _IsValidRBTRee(Node* pRoot, size_t blackCount, const size_t pathBlack);
    // 左单旋
	void RotateL(Node* pParent);
    // 右单旋
	void RotateR(Node* pParent);
    // 为了操作树简单起见：获取根节点
	Node*& GetRoot() const { return _root->_parent; }
    
    void _InOrder(Node* root);

    void rebalance(Node*& cur, Node*& parent)		//红黑树的平衡调整
    {
        while (parent != _root && parent->_col == RED)
        {
            Node* grandParent = parent->_parent;
            if(parent == grandParent->_left)
            {
                Node* uncle = grandParent->_right;
                if(uncle && uncle->_col == RED)
                {
                     parent->_col = uncle->_col = BLACK;
                     grandParent->_col = RED;

                     cur = grandParent;
                     parent = cur->_parent;
                }
                else 
                {
                    if(cur == parent->_left)
                    {   //右旋
                        RotateR(grandParent);
                        parent->_col = BLACK;
                        grandParent->_col = RED;
                    }
                    else 
                    {   //双旋
                       RotateL(parent);
                       RotateR(grandParent);
                       grandParent->_col = RED;
                       cur->_col = BLACK;
                    }
                    break;
                }
            }
            else 
            {
                Node* uncle = grandParent->_left;

                if(uncle && uncle->_col == BLACK)
                {
                     parent->_col = uncle->_col = BLACK;
                     grandParent->_col = RED;
                     cur = grandParent;
                     parent = cur->_parent;
                }
                else 
                {
                    if(cur == parent->_right)
                    {
                        RotateL(grandParent);
                        parent->_col = BLACK;
                        grandParent->_col = RED;
                    }
                    else 
                    {
                       RotateR(parent);
                       RotateL(grandParent);
                       grandParent->_col = RED;
                       cur->_col = BLACK;
                    }
                    break;
                }
            }
        }
        GetRoot()->_col = BLACK;
    }
private:
	Node* _root = nullptr;
    KeyOfT kot;
};


template <class K, class T, class KeyOfT>
typename RBTree<K, T, KeyOfT>::const_iterator RBTree<K, T, KeyOfT>::Find(const K& data) const
{
    Node* cur = GetRoot();
    while(cur)
    {
        if(kot(cur->_data) < data)
        {
            cur = cur->_right;
        }
        else if(kot(cur->_data) > data)
        {
            cur = cur->_left;
        }
        else 
        {
            return cur;
        }
    }

    return nullptr;
}

template <class K, class T, class KeyOfT>
typename RBTree<K, T, KeyOfT>::iterator RBTree<K, T, KeyOfT>::Find(const K& data) 
{
    Node* cur = GetRoot();
    while(cur)
    {
        if(kot(cur->_data) < data)
        {
            cur = cur->_right;
        }
        else if(kot(cur->_data) > data)
        {
            cur = cur->_left;
        }
        else 
        {
            return cur;
        }
    }

    return nullptr;
}

template <class K, class T, class KeyOfT>
void RBTree<K, T, KeyOfT>::_InOrder(Node* root)	//中序遍历
{
    if(!root)   
        return;

    _InOrder(root->_left);
    std::cout << root->_data << " ";
    _InOrder(root->_right);
}


template <class K, class T, class KeyOfT>
typename RBTree<K, T, KeyOfT>::Node* RBTree<K, T, KeyOfT>::LeftMost()const	//最左节点
{
    return _root->_left;
}

template <class K, class T, class KeyOfT>
typename RBTree<K, T, KeyOfT>::Node* RBTree<K, T, KeyOfT>::RightMost()const	//最右节点
{
    return _root->_right;
}


template <class K, class T, class KeyOfT>
bool RBTree<K, T, KeyOfT>::IsValidRBTRee()		//检查树的性质是否被破坏
{
    if(!GetRoot() || GetRoot()->_col == RED)  return false;
    
    size_t pathBlack = 0;
    Node* cur = GetRoot();
    while(cur)
    {
        if(cur->_col == BLACK)
            ++pathBlack;	//计算路径黑色节点的总个数
        cur = cur->_left;
    }
    int blackCount = 0;

    return _IsValidRBTRee(GetRoot(), blackCount, pathBlack);
}

template <class K, class T, class KeyOfT>
bool RBTree<K, T, KeyOfT>::_IsValidRBTRee(Node* pRoot, size_t blackCount, const size_t pathBlack)
{
    if(!pRoot)
    {
        if(blackCount != pathBlack)
        {
            std::cout << "有连续的红色结点" << std::endl;
            return false;
        }
        return true;
    }

    if(pRoot->_col == RED && pRoot->_parent->_col == RED)
    {
        std::cout << "有连续的红色结点" << std::endl;
        return false;
    }

    if(pRoot->_col == BLACK)
        ++blackCount;

    return _IsValidRBTRee(pRoot->_left, blackCount, pathBlack)
        && _IsValidRBTRee(pRoot->_right, blackCount, pathBlack);
}


template <class K, class T, class KeyOfT>   
std::pair<typename RBTree<K, T, KeyOfT>::iterator, bool> RBTree<K, T, KeyOfT>::Insert(const T& data)
{
    if(GetRoot() == nullptr)
    {
        Node* node = new Node(data);
        node->_col = BLACK;
        node->_parent = _root;
        _root->_parent = node;
        _root->_left = _root->_parent;
        _root->_right = _root->_parent;

        return std::make_pair(iterator(GetRoot()), true);
    }

    Node* cur = GetRoot();
    Node* parent = nullptr;
    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 std::make_pair(iterator(cur), false);
    }

    cur = new Node(data);
    Node* ret = cur;		//记录新增的节点，因为在调整后，节点可能会丢失
    cur->_parent = parent;

    if(kot(cur->_data) < kot(parent->_data))
    {
        if (parent == _root->_left)	//更新最小节点
            _root->_left = cur;

        parent->_left = cur;
    }
    else 
    {
        if(parent == _root->_right)	//更新最大节点
            _root->_right = cur;

        parent->_right = cur;
    }

    rebalance(cur, parent);

    return std::make_pair(ret, true);
}

template <class K, class V, class KeyOfT>
void RBTree<K, V, KeyOfT>::RotateL(Node* parent)	//左旋
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    Node* parentParent = parent->_parent;

    parent->_right = subRL;
    parent->_parent = subR;
	subR->_parent = parentParent;
    subR->_left = parent;
    if(subRL)
        subRL->_parent = parent;

    if(GetRoot() == parent)
    {
        GetRoot() = subR;
    }
    else 
    {
        if(parent == parentParent->_left)
        {
            parentParent->_left = subR;
        }
        else 
        {
            parentParent->_right = subR;
        }
    }
}

template <class K, class V, class KeyOfT>
void RBTree<K, V, KeyOfT>::RotateR(Node* parent)	//右旋
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    Node* parentParent = parent->_parent;

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

    parent->_left = subLR;
    parent->_parent = subL;

    if(subLR)
        subLR->_parent = parent;

    if(parent == GetRoot())
        GetRoot() = subL;
    else
    {
        if(parent == parentParent->_left)
            parentParent->_left = subL;
        else
            parentParent->_right = subL;
    }
}

📓总结

📜博客主页：主页
📫我的专栏：C++
📱我的github：github

cyclesw
关注
专栏目录
手撕红黑树——C++高阶数据结构详解
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 841
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
C++手撕红黑树
分享学习的知识，记录我的技术成长道路
08-07 671
红黑树在表意上就是一棵每个节点带有颜色的二叉搜索树，并通过对节点颜色的控制，使该二叉搜索树达到尽量平衡的状态。红黑树确保没有一条路径比其他路径长两倍。和AVL树不同的是，AVL树是一棵平衡树，而红黑树可能平衡也可能不平衡(因为是尽量平衡的状态)每一次插入都对根节点置为黑操作，因为第一种情况可能导致根节点不是黑。同时对根节点置黑也并不违反三条规定。...
【C++】——红黑树（手撕红黑树，彻底弄懂红黑树）
m0_74092462的博客
07-26 1455
我们之前都学过ALV树，AVL树的本质就是一颗平衡二叉树，它的作用就是查找，插入和删除节点，最坏的时间复杂度都是O(logn)的，同时维护的高度差都是小于等于1的，但是也就是因为这个原因才被红黑树所替代红黑树是一种自平衡的二叉查找树，是一种高效的查找树。它是由 Rudolf Bayer 于1978年发明，在当时被称为平衡二叉 B 树(symmetric binary B-trees)。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的红黑树。
红黑树，插入和删除，基于C++的实现
weixin_52026625的博客
10-25 523
接上篇红黑树，插入和删除，更好的理解 ，在这篇文章中，我不会过多介绍理解部分，因为上篇文章已经说的差不多了。接下来我将基于C++来实现红黑树，同样的，欢迎大家在评论区提出疑问和指出错误！ 首先，我们需要构建红黑树的结点类，这个类里面，要有key值，value值，结点的颜色，还要有指向左右子结点的结点类指针，最后加上指向父结点的结点类指针。我这里，将key值设为int类型，value值设为string类型，结点的颜色用bool类型表示，也就是true表示红色，false表示黑...
C++之红黑树 + 手撕红黑树
JYXCZYH的博客
06-12 865
通过上面的基本性质和要求，我们就已经可以定义出红黑树节点的基本结构了（这里我们采用枚举类型来标识颜色）。
C++ 手撕红黑树（二）：删除操作
zsiming的博客
07-11 610
前情概述：C++ 手撕红黑树（一）：节点的插入当需要删除的节点颜色是黑色时，最基本的情况如下所示： 情况1，兄弟是黑色的，而且有一个红色的右孩子： 情况2，兄弟是黑色的，但是右孩子是黑色的，而左孩子是红色的： 情况三：兄弟的孩子都是黑色的 总结一下： 3. 整棵红黑树的实现 5.测试结果...
C++ 手撕红黑树（一）：插入操作
zsiming的博客
07-11 588
红黑树的出现主要是用来解决AVL树旋转次数过多的问题。AVL树在插入节点或者删除节点的过程中（每层递归完回溯时）都需要检查左子树或者右子树之间的高度差是否小于等于1，如果不平衡(大于1)的话需要旋转或者平衡操作来维持平衡，因此在数据量比较大的时候可能旋转了很多次（接近logn次），效率比较差。而红黑树在插入和删除的时候，最多做两次旋转操作。因此旋转次数比较少。然而，值得注意的是，红黑树是一颗BST树但并不是一颗平衡的树。......
【数据结构】手撕红黑树
学了就忘是正常现象
02-26 9079
红黑树和AVL树一样，因其逻辑复杂，面试时现场要求手撕就是纯纯刁难面试者。但某大厂面试官曾要求某些求职者现场手撕红黑树（我赌5毛，让面试官撕，他也撕不出来，而且你家员工上班手搓红黑树啊？），随后求职遭遇被发到网上吐槽，这便有了“手撕红黑树”的梗，也让红黑树成为了知名度最高的数据结构。（话虽如此，对于红黑树的性质、插入思想等概念还是需要掌握的）
带你手撕红黑树！ c++实现 带源码
qq_51216031的博客
05-12 1035
4、如果对于每个节点，从该节点到其后代节点的简单路径上，均包含相同数目的黑色节点（每条路径的黑色节点数量相等）那么作为另外一条路径的叔叔节点，也必须变为黑色，也增加一个黑色节点，才能保持。3、如果一个节点是红色的，则他的两个孩子是黑色的（不存在连续的红色节点）如此，以祖父节点作为根节点的这棵子树已经保持了黑色节点数量不变。那么，对于祖父作为根节点的这课子树来说，多了一个黑色节点。父节节点变为黑色，父亲节点的路径黑色节点多了一个。而，父节点的父节点，即祖父节点一定存在且为黑色。
28.红黑树_1.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36哈希与映射的概述 37B树有什么用 38B树的概念 39图_邻接矩阵 40图_邻接表 41图_DFS 42图_BFS
红黑树之 原理算法详解
wyx911111的博客
12-13 553
  .手撕红黑树之 原理算法详解
红黑树与AVL树解析：数据结构与算法面试重点
"C++面试题库，包含算法与数据结构，重点强调红黑树和AVL树的区别，以及它们在面试中的重要性。" 在C++面试中，数据结构和算法是不可或缺的知识点，其中红黑树和AVL树是二叉平衡树的重要类型。这两者都是为了优化...
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 845
书生浦语大模型实战营第四期：Linux前置基础
第八天: C语言深度探索：指针与函数的奥秘
最新发布
qq_57484399的博客
10-31 576
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
Qt Designer客户端安装和插件集（pyqt5和pyside2）
Good Luck
10-29 624
GitHub - PyQt5/QtDesignerPlugins: Qt Designer PluginsQt Designer Plugins. Contribute to PyQt5/QtDesignerPlugins development by creating an account on GitHub.https://github.com/PyQt5/QtDesignerPlugins https://github.com/PyQt5/QtDesigner/releaseshttps://gith
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1076
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C语言中的数组并非指针：深入理解数组和指针的区别
极客代码
10-29 592
在C语言中，数组和指针是两个非常重要的概念，它们在很多方面有着紧密的联系，但也存在显著的区别。尽管数组名有时可以像指针那样使用，但它们本质上并不是一回事。理解这些差异对于编写正确和高效的代码至关重要。本文将深入探讨数组和指针的区别，并提供一些示例代码。1. 数组与指针的基础概念数组：数组是一系列相同类型数据的集合，它们在内存中连续存储。数组名本身是一个常量，指向数组的起始位置。指针：指针是一个变量，其值为另一个变量的地址。指针可以指向数组中的任何一个元素。2. 数组与指针的相似之处数组名作为指针。
C语言中的野指针以及避免野指针的常用方式
青衫客36的博客
10-29 214
在C语言中，（Dangling Pointer）是指一个指向无效或已释放内存区域的指针。使用野指针会导致不确定的行为，例如程序崩溃、数据损坏，甚至可能带来安全漏洞。freedelete。
C++实现红黑树插入操作详解
在插入操作中，首先执行标准的二叉查找树插入，然后可能需要进行一系列的调整以满足红黑树的性质： 1. **红黑树性质**： - 每个节点要么是红色，要么是黑色。 - 根节点是黑色。 - 所有叶子节点（NIL节点）是黑色...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值