[STL数据结构] AVL底层 与 红黑树

Posted 一个正直的男孩

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[STL数据结构] AVL底层 与 红黑树相关的知识，希望对你有一定的参考价值。

之前的搜索二叉树大家明显可以看出它的缺点，搜索二叉树的效率为logN，插入节点有序的时候效率退化为O(N)



文章目录

平衡二叉树

解决这一问题用一个平衡因子来控制左右子树的高度差不超过1，使二叉树避免单支，保持平衡，避免单支


平衡英子

右子树-左子树的高度差


AVL树节点定义：

templete<class K,class V>
struct AVLTreeNode

	AVLTreeNode<K,V> * _left;
	AVLTreeNode<K,V> * _right;
	AVLTreeNode<K,V> * _parent;
	pair<K,V> _val;
	
	int _bf;//平衡英子
		
	AVLTreeNode(const pair<K,V> & kv)//构造函数
	:_left(nullptr)
	,right(nullptr)
	,_parent(nullptr)
	,_bf(0)
	,_val(kv)

AVL树

class  AVL

	typedef AVLTreeNode<K,V>  Node;
public:
		//………………
private:	
	Node *_root;

AVL树插入

  1. 判断插入
  2. 更新平衡英子
  3. 旋转
    1. 左旋
    2. 右旋
    3. 双旋

更新平衡英子

  1. 插入左边–，右边++
  2. 一直向上更新父亲节点(如果为2或者-2发生旋转停止更新，1，-1停止更新)

如图所示：


旋转

  1. 左旋

节点插入在C时平衡英子已不满足了，那当前树根节点高度差一定相差1，用肉眼看，把30插入60左边就平衡了，但插入b就丢失了，但b刚好可以当30的右子树(搜索二叉左<根>右)，那么树久保持平衡了

  1. 右旋

  2. 双旋


代码


bool inster(const pair<K,V> & kv)

	//没有节点的时候
	if(_root==nullptr)
	
		_root=new Node(kv);
	
	
	//1.判断插入
	Node * parent=nullptr;
	Node * cur=_root;
	while(cur)
	
		if(cur->_val.first>kv.first)
		
			parent=cur;
			cur=cur->left;
		
		else if(cur->_val.first<kv.first)
		
			parent=cur;
			cur=cur->right;
		
		else
		
			return false;
		
	
	
	
	//插入节点
	Node * present = new Node(kv);
	if(parent->_val.first > kv.first)
	
		parent->left=present;
		present->_parent=parent;
	
	else
	
		parent->right=present;
		present->_parent=parent;
	
	
	//更新平衡英子
	while(parent)
	
		if(present==parent->right)
		
			parent->_bf++;
		
		else
		
			parent->_bf--;
		
		
		//parent为0的时候不需要在更新
		if(	parent->_bf==0)
		
			break;
		
		else if(parent->_bf ==2 || parent->_bf ==-2)
		
			//旋转
			if(parent->_bf==-2 && present->bf==-1)//右旋
			
				RotateR(parent);
			
			else if(parent->_bf==2 && present->bf==1)//左旋
			
				RotateL(parent);
			
			else if(parent->_bf==2 &&present->_bf==-1)//双旋 右 ，左
			
			  	RotateRL(parent);
			
			else if(parent->_bf==-2 && present->_bf==1)//双旋 左右
			
				RotateLR(parent);
			
			break;
		
		
		
	
		


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

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

		Node* ppNode = parent->_parent;

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

		if (parent == _root)
		
			_root = subL;
			subL->_parent = nullptr;
		
		else
		
			if (ppNode->_left == parent)
				ppNode->_left = subL;
			else
				ppNode->_right = subL;

			subL->_parent = ppNode;
		

		parent->_bf = subL->_bf = 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 (parent == _root)
		
			_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;
	

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

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

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

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

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

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

总结

其实就是把平衡因子为2的节点变为根，那么原来根要放哪里呢？那就要看平衡因子2的节点是根的左节点还是右节点了，如果是左节点，那么就可以把平衡因子为2节点的右子树给根的左子树（原来的根指向的是平衡因子为2的节点），再把根变为平衡因子为2节点的右子树（根比平衡因子为2的节点大）



红黑树

AVL用平衡英子旋转来避免了单支的效率低的情况，但是旋转的效率也很高，那么就衍生出来红黑树，他减少了二叉树旋转的次数，所以红黑树是近似平衡。

红黑树的规则

  1. 每个节点不是黑色就是红色
  2. 根节点必须是黑色
  3. 一个红色节点的子节点一定是黑色的
  4. 每条路径中的黑色节点都相等
  5. 叶子节点都为黑(叶子==空)（不重要）
  6. 最长路径不超过最短路径的俩倍

如图所示：

问：

上述二叉树有多少路径？

答：

14条 ，一条完整的路径是从根到空


问：

如何控制最长路径不超过最短路径的俩倍？

答：

这个是由规则推出来的，1. 节点不是黑的就是红的 2.根一定是黑的 3.红节点的子节点一定是黑的 4. 每条路径黑色节点个数一定相同 ，最短路径就是全黑，最长路径一定是一黑一红
如图所示：


问：

那最长节点超过最短节点的2倍咋办？

答：

emmmm,这是一个蠢问题，当然是旋转了呀哈哈


红黑树的实现

  1. 插入的节点是红是黑
  2. 如何旋转 （与平衡二叉一致）

答 1：

插入最好是红色节点，如果是黑色节点插入，那么规则4就不满足了（每条路径的黑色节点个数相同），红色只需判断父亲的颜色，黑色不更改，红色则需要做对应的处理
如图所示:


处理
处理的方法之万物看叔叔

  1. 如果父亲为红色，叔叔为红的话，父亲叔叔变黑，并向上更新
  2. 如果父亲为红，叔叔为黑或不存在的话，进行旋转，父亲为黑，祖父为变红

如图所示：

旋转也是有单旋或者双旋，其实只需要判定 parent 在grendfatehr那边，且new_node在parent的那边（p在g左，n在p左单旋 ， n在p右双旋）


红黑树节点

template<class K,class V>
struct RBTNode

    RBTNode<K,V> *_left;
    RBTNode<K,V> *_right;
    RBTNode<K,V> *_parent;
    pair<K,V> _val;
    Color _col;

    RBTNode(const pair<K,V>& kv)//构造函数
    :_left(nullptr)
    ,_right(nullptr)
    ,_parent(nullptr)
    ,_val(kv)
    ,_col(RED)
    
;

红黑树的插入接口

其余接口与平衡二叉一致不实现

template<class K,class V>
class RBT

    typedef RBTNode<K,V> Node;

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

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

        Node* ppNode = parent->_parent;

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

        if (parent == _root)
        
            _root = subL;
            subL->_parent = nullptr;
        
        else
        
            if (ppNode->_left == parent)
                ppNode->_left = subL;
            else
                ppNode->_right = subL;

            subL->_parent = ppNode;
        
    

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

            subR->_parent = ppNode;
        
    
public:
    bool insert(const pair<K,V> &kv)
    
        if(_root== nullptr)//没有节点的时候
        
            Node * new_node=new Node(kv);
            _root=new_node;
            _root->_col=BLACK;
            return true;
        

        //寻找插入的节点位置
        Node *cur=_root;
        Node *parent=nullptr;
        while(cur)
        
            if(cur->_val.first > kv.first)
            
                parent=cur;
                cur=cur->_left;
            
            else if(cur->_val.first < kv.first)
            
                parent=cur;
                cur=cur->_right;
            
            else
            
                return false;
            
        

        //插入节点
        Node * new_node =new Node(kv);
        if(parent->_val.first > kv.first)//比节点小左边
        
            parent->_left=new_node;
            new_node->_parent=parent;
        
        else//节点大右边
        
            parent->_right=new_node;
            new_node->_parent=parent;
        


        //判断父亲节点颜色并对其进行更改
        while(parent && parent->_col== RED)
        
            Node * grandfather=parent->_parent;
            Node * uncle;

                if(grandfather->_left == parent)
                
                    uncle=grandfather->_right;

                    if(uncle!= nullptr && uncle->_col ==RED)//为红色的情况
                    
                        uncle->_col=parent->_col=BLACK;
                        grandfather->_col=RED;
                        new_node=grandfather;
                        parent=new_node->_parent;
                    
                    else //为黑色或空 且可能是双旋
                    
                        if((uncle== nullptr || uncle->_col==BLACK) && parent->_left==new_node)//单旋
                        
                            RotateR(grandfather);
                            grandfather->_col= RED;
                            parent->_col=BLACK;
                        
                        else//双旋
                        
                            RotateL(parent);
                            RotateR(grandfather);
                            new_node->_col=BLACK;
                            grandfather->_col=parent->_col=RED;
                        
                        //旋转后没有新增节点
                        // 所以这条路径的黑色节点没边则不需要在向上更新
                        return true;
                    
                
                else
                
                    uncle=grandfather->_left;
                    if(uncle!= nullptr && uncle->_col ==RED)//为红色的情况
                    
                        uncle->_col=parent->_col=BLACK;
                        grandfather->_col=RED;
                        new_node=grandfather;
                        parent=new_node->_parent;
                    
                    else //为黑色或空 且可能是双旋
                    
                        if((uncle== nullptr || uncle->_col==BLACK )&& parent->_right==new_node)//单旋
                        
                            RotateL(grandfather);
                            grandfather->_col= RED;
                            parent->_col=BLACK;
                        
                        else
                        
                            RotateR(parent);
                            RotateL(grandfather);
                            new_node->_col=BLACK;
                            grandfather->_col=parent->_col=RED;
                        

                        //旋转后没有新增节点
                        // 所以这条路径的黑色节点没边则不需要在向上更新
                        return true;
                    
                
        


        //根节点一定是黑色
        _root->_col=BLACK;
    
private:
    Node * _root=nullptr;
;

结尾

二叉搜索树的底层就到此为止了，那么现在map与set的底层是红黑树，毕竟旋转次数较少，虽然查找会差一点，但是数据越多其实没差别

以上是关于[STL数据结构] AVL底层 与 红黑树的主要内容，如果未能解决你的问题，请参考以下文章

10.STL简单红黑树的实现

徒手写的AVL竟然比STL中的红黑树效率更高？✨

红黑树B(+)树跳表AVL等数据结构，应用场景及分析，以及一些英文缩写

红黑树插入删除详细步骤动画演示与AVL树的区别

AVL树红黑树以及B树介绍

红黑树与AVL树