淺析紅黑樹原理以及實現

        bool Insert(const K& key, const V& val)
	{
		//_Insert(_root, x, y);
		if (_root == NULL)
		{
			_root = new Node(key, val);
			_root->_col = BLACK;
		}

		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key == key)
			{
				return true;
			}
		}

		if (parent->_key > key)
		{
			parent->_left = new Node(key, val);
			parent->_left->_parent = parent;
			cur = parent->_left;
		}
		else
		{
			parent->_right = new Node(key, val);
			parent->_right->_parent = parent;
			cur = parent->_right;
		}
	
		//目前父親節點，插入節點，叔叔節點已經就緒.
		while(parent && parent->_col == RED)
		{
			Node* parentparent = parent->_parent;
			Node* uncle = NULL;

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

			else
				uncle = parentparent->_left;

			if(uncle && uncle->_col == RED)
			{
				parentparent->_col = RED;
				parent->_col = BLACK;
				uncle->_col = BLACK;

				cur = parentparent;
				parent = cur->_parent;

			}
			else if (uncle == NULL || uncle->_col == BLACK)
			{
				if (parentparent->_left == parent)
				{
					if (parent->_left == cur)
					{
						RotateR(parentparent);
						parent->_col = BLACK;
					}
					else
					{
						RotateLR(parentparent);
						cur->_col = BLACK;
					}
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(parentparent);
						parent->_col = BLACK;
					}
					else
					{
						RotateRL(parentparent);
						cur->_col = BLACK;
					}
				}
				parentparent->_col = RED;
				if (parentparent == _root)
				{
					_root = parent;
				}
			
			}
			else
			{
				assert(false);
			}
			if (_root->_col == RED)
			{
				_root->_col = BLACK;
			}
		}
		return false;
	}

我們要刪除del這個時候，直接刪除del成本太高了，然後我們尋找一個邊緣節點跟他交換，然後再刪除它.所以呢，這樣刪除的成本是

最小的. 刪除分三個情況： 

1.del的左為空.

2.del的右為空.

3.del的左右都不為空.

前兩種很容易思考，第三種左右都不為空的情況才需要我們的邊緣替換法.所以我這裡附上搜索二叉樹的刪除的程式碼. 紅黑樹刪除的代

碼暫時我還沒有解決所以這裡之後搜尋二叉樹的刪除程式碼. 我們可以想著思考思考說不定就寫完了.

程式碼實現：

	bool Remove(const K& key)
	{
		if (_root == NULL)
		{
			return false;
		}
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{		
			if (cur->key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->key == key)
			{
				break;
			}
		}

		Node* del = cur;
		if (cur->_left == NULL) //左為空
		{
			if (parent == NULL)
			{
				_root = cur->_right;
				if (_root)
					_root->_parent = NULL;
			}
			else
			{
				if (parent->_left == cur)
					parent->_left = cur->_right;
				
				else			
					parent->_right = cur->_right;
			
				if (cur->_right)
					cur->_right->_parent = parent;
			}
		}
		else if (cur->_right == NULL)//右為空
		{
			if (parent == NULL)
			{
				_root = cur->_left;
				if (_root)
					_root->_parent = NULL;
			}
			else
			{
				if (parent->_left == cur)
					parent->_left = cur->_left;
				else
					parent->_right = cur->_left;

				if (cur->_left)
					cur->_left->_parent = parent;
			}	
		}

		else //左右都不為空
		{
			if (parent == NULL || cur == parent->_left) //如果cur在左邊.
			{
				del = cur->_right;

				while (del->_left)
				{
					del = del->_left;
				}

				del->_parent->_left = del->_right;;
			}
			else //cur在parent的右邊.
			{
				del = cur->_left;

				while (del->_right)
				{
					del = del->_right;
				}

				del->_parent->_right = del->_left;
			}
			cur->key = del->key;
			cur->val = del->val;
		}

		delete del;
	}

編寫一個檢驗該二叉樹是否為紅黑樹的程式：

這裡首先解決一個最棘手的問題，如何判斷一個路徑上面的黑節點相同？ 我們很容易想到，可以先遍歷一條路徑找到一個基準值，然

後和其他路徑做比較，程式碼實現就是每次走到葉子結點的時候，比較該條路徑的黑色節點節點個數是否和基準值相等？ 如果不相等

那麼返回false. 所以我們引數裡面需要一個m（傳遞黑色節點基準值）和n(記錄該條路徑上面的黑色節點個數). 

那麼我們來瞧瞧程式碼實現：

        bool ISRBtree()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		size_t n = 0;
		size_t m = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				n++;
			}
			cur = cur->_left;
		}
		return _ISRBtree(_root, m, n);
	}

	bool _ISRBtree(Node* root, size_t m, size_t n)
	{
		if (root == NULL)
		{
			if (m == n)
				return true;
			else
				return false;
		}


		if (root->_col == BLACK)
		{
			m++;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			return false;
		}

		return _ISRBtree(root->_left, m, n) && _ISRBtree(root->_right, m, n);

	}

演示結果：

總結

紅黑樹是一個非常重要的資料結構，現在生活當中的使用我們就能看的出來，可能我們並不需要它的底層構造但是我們要學習一個語

言. 最快的途徑就是大師寫出來的程式碼，手頭都是資料我們要學習別人的巧妙的地方. 多看原始碼多多構造經典的演算法，或者容器. 

嘗試自己編寫程式碼，理解那個框架, 這樣對我們的進步都是非常有用的.紅黑樹目前我就總結這麼多，哪裡有不足歡迎大家來指出來

，我會虛心改正.

所有程式碼實現：

#include<iostream>
#include<Windows.h>
#include<assert.h>
using namespace std;

enum colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	K _key;
	K _val;

	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	colour _col;

	RBTreeNode(const K& key, const V& val)
		:_key(key)
		, _val(val)
		, _left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _col(RED)
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	RBTree()
		:_root(NULL)
	{}

	bool Insert(const K& key, const V& val)
	{
		//_Insert(_root, x, y);
		if (_root == NULL)
		{
			_root = new Node(key, val);
			_root->_col = BLACK;
		}

		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key == key)
			{
				return true;
			}
		}

		if (parent->_key > key)
		{
			parent->_left = new Node(key, val);
			parent->_left->_parent = parent;
			cur = parent->_left;
		}
		else
		{
			parent->_right = new Node(key, val);
			parent->_right->_parent = parent;
			cur = parent->_right;
		}
	
		//目前父親節點，插入節點，叔叔節點已經就緒.
		while(parent && parent->_col == RED)
		{
			Node* parentparent = parent->_parent;
			Node* uncle = NULL;

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

			else
				uncle = parentparent->_left;

			if(uncle && uncle->_col == RED)
			{
				parentparent->_col = RED;
				parent->_col = BLACK;
				uncle->_col = BLACK;

				cur = parentparent;
				parent = cur->_parent;

			}
			else if (uncle == NULL || uncle->_col == BLACK)
			{
				if (parentparent->_left == parent)
				{
					if (parent->_left == cur)
					{
						RotateR(parentparent);
						parent->_col = BLACK;
					}
					else
					{
						RotateLR(parentparent);
						cur->_col = BLACK;
					}
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(parentparent);
						parent->_col = BLACK;
					}
					else
					{
						RotateRL(parentparent);
						cur->_col = BLACK;
					}
				}
				parentparent->_col = RED;
				if (parentparent == _root)
				{
					_root = parent;
				}
			
			}
			else
			{
				assert(false);
			}
			if (_root->_col == RED)
			{
				_root->_col = BLACK;
			}
		}
		return false;
	}

	bool ISRBtree()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		size_t n = 0;
		size_t m = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				n++;
			}
			cur = cur->_left;
		}
		return _ISRBtree(_root, m, n);
	}

	void print()
	{
		_print(_root);
	}

protected:

	void _print(Node* root)
	{
		if (root == NULL)
			return;

		_print(root->_left);
		cout << root->_val << " ";
		_print(root->_right);
	}

	bool _ISRBtree(Node* root, size_t m, size_t n)
	{
		if (root == NULL)
		{
			if (m == n)
				return true;
			else
				return false;
		}


		if (root->_col == BLACK)
		{
			m++;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			return false;
		}

		return _ISRBtree(root->_left, m, n) && _ISRBtree(root->_right, m, n);

	}

	void RotateLR(Node*& parent)
	{

		RotateL(parent->_left);

		RotateR(parent);
	}

	void RotateRL(Node*& parent)
	{
		RotateR(parent->_right);
		RotateL(parent);
	}

	void RotateR(Node*& parent)
	{
		Node* subL = parent->_left;
		Node* subLR = NULL;
		if (subL)
			subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (ppNode == NULL)
		{
			_root = subL;
			_root->_parent = NULL;
		}
		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 = NULL;
		if (subR)
			subRL = subR->_left;

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

		Node* ppNode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (ppNode == NULL)
		{
			_root = subR;
			_root->_parent = NULL;
		}
		else
		{
			if (ppNode->_left == parent)
				ppNode->_left = subR;
			else
				ppNode->_right = subR;
			subR->_parent = ppNode;
		}
	}


private:
	Node* _root;
};



void Test()
{
	RBTree<int, int> T;
	//8 9 2 4 1 6 3 5
	T.Insert(8, 8);
	T.Insert(9, 9);
	T.Insert(2, 2);
	T.Insert(4, 4);
	T.Insert(1, 1);
	T.Insert(6, 6);
	T.Insert(3, 3);
	T.Insert(5, 5);

	cout << "該二叉樹是否為紅黑樹??" << T.ISRBtree() << endl;
	T.print();
	system("pause");

 }