C++ RBTree

置顶 EffectiveC++

已于 2024-05-21 16:54:39 修改

阅读量1k

点赞数 30

文章标签： c++ 开发语言算法 RBTree 红黑树

于 2024-05-21 16:53:30 首次发布

本文链接：https://blog.csdn.net/m0_74922218/article/details/139093992

版权

1. pparent->_left == parent

1.1 uncle && uncle->_col = RED

1.2 !(uncle && uncle->_col == RED)

1.2.1 parent->_left == cur

1.2.2 parent->_right== cur

2. pparent->_right== parent

概念

一种搜索二叉树，确保没有一条路径会大于最小路径的两倍

性质

每个节点不是黑就是红
根节点是黑
红色节点的孩子都为黑色
每个节点的往下的每条路径的黑色节点数目相同
叶子节点（NIL）为nullptr节点都是黑色

节点的定义

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)
		, _col(RED)
	{}
};

树的结构

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> node;
public:
private:
	node* _root = nullptr;
};

Insert

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new node(kv);
		_root->_col = BLACK;
		return true;
	}

	node* cur = _root;
	node* parent = cur;
	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);
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;
	//改颜色，旋转
}

操作

先插入节点
默认插入的颜色为红色
父亲为红色就要改变
按照uncle是否为红色讨论

注意

父亲不能为空
父亲对于爷爷的左右会影响旋转的方向

while (parent && parent->_col == RED)
{
	node* pparent = parent->_parent;
	if (pparent->_left == parent)
	{
		node* uncle = pparent->_right;
		if (uncle && uncle->_col == RED)
		{
			//①
		}
		else
		{
			if (parent->_left == cur)
			{
				//②
			}
			else
			{
				//③
			}
			break;
		}
	}
	else
	{
		node* uncle = pparent->_left;
		if (uncle && uncle->_col == RED)
		{
			//④
		}
		else
		{
			if (parent->_right == cur)
			{
				//⑤
			}
			else
			{
				//⑥
			}
			break;
		}
	}
	_root->_col = BLACK;
}

1. pparent->_left == parent

1.1 uncle && uncle->_col = RED

只有在uncle为红的情况下，从跟开始的路径的黑色节点数才会增加1

①处代码

parent->_col = BLACK;
uncle->_col = BLACK;
pparent->_col = RED;

cur = pparent;
parent = pparent->_parent;

解释

肯定是parent变黑，而不是新插入的节点；如果是插入的节点变黑，那么整个路径都不对了，每次插入就一定要调整，所以开始就初始化为红色；其实也不难理解，父亲是红色，cur(newnode)也是红色，但是pparent一定是黑色，如果这时候有uncle且为红色，那么把爷爷的黑色给给parent和uncle，自己变成红色；那么此时，对于爷爷的后代节点的路径黑色节点的数目不变，若pparent就是_root那么爷爷再变成黑色（放到最后处理）

1.2 !(uncle && uncle->_col == RED)

1.2.1 parent->_left == cur

旋转解释及注意事项

②处代码

rotateR(pparent);

//cur->_col = RED;
parent->_col = BLACK;
pparent->_col = RED; //这个之前一定是黑

简单来说就是，旋转之后parent位置颜色变成黑色，cur 和 pparent 变成红色，pparent在旋转之前一定是黑色，因为parent是红色

1.2.2 parent->_right== cur

和AVLTree的旋转一模一样

③处代码

rotateL(parent);
rotateR(pparent);

cur->_col = BLACK;//这竟然写错了
pparent->_col = RED;

2. pparent->_right== parent

2和1可以没什么区别

else部分代码

else
{
	node* uncle = pparent->_left;
	if (uncle && uncle->_col == RED)
	{
		uncle->_col = BLACK;
		parent->_col = BLACK;
		pparent->_col = RED;
	}
	else
	{
		if (parent->_right == cur)
		{
			rotateL(pparent);

			parent->_col = BLACK;
			pparent->_col = RED;
		}
		else
		{
			rotateR(parent);
			rotateL(pparent);

			cur->_col = BLACK;
			pparent->_col = RED;
		}
		break;
	}
}

rotateR

void rotateR(node* parent)
{
	node* subL = parent->_left;
	node* subLR = subL->_right;

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

	node* pparent = parent->_parent;

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

	if (parent == _root) //其实就是pparent为空，所以下面不用担心空指针解引用
	{
		_root = subL;
	}
	else
	{
		if (pparent->_left == parent)
		{
			pparent->_left = subL;
		}
		else
		{
			pparent->_right = subL;
		}
	}
	subL->_parent == pparent;
}

rotateL

void rotateL(node* parent)
{
	node* subR = parent->_right;
	node* subRL = subR->_left;

	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;

	node* pparent = parent->_parent;

	subR->_left = parent;
	parent->_parent = subR;

	if (parent == _root)
	{
		_root = subR;
	}
	else
	{
		if (pparent->_left == parent)
		{
			pparent->_left = subR;
		}
		else
		{
			pparent->_right = subR;
		}
	}
	subR->_parent = pparent;
}
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

左右旋详解

void InOrder()

public:
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << "->" << root->_col << endl;
		_InOrder(root->_right);
	}

bool isbalance()

public:
	bool isbalance()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		return _isbalance(_root, 0, 0);
	}
private:
	bool _isbalance(node* root, int numofblack, int prev)
	{
		if (root == nullptr)
		{
			if (prev == 0)
			{
				prev = numofblack;
			}
			else
			{
				if (prev != numofblack)
				{
					return false;
				}
			}
			return true;
		}

		if (root->_col == BLACK) //nullprt在上面就被刷掉了
			numofblack++;

		if (root->_parent && root->_parent->_col == RED && root->_col == RED)
		{
			return false;
		}
		//中序效率是不是有点低，但是从numofblack++来看好像只能这样
		return _isbalance(root->_left, numofblack, prev) && _isbalance(root->_right, numofblack, prev);
	}

思路