左倾红黑树C++实现

已于 2024-10-25 21:45:01 修改
阅读量172 收藏
点赞数 2
文章标签： c++ 算法 数据结构
于 2024-02-13 22:45:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/naturerun/article/details/136110273
版权

橘皮书算法(第四版)中译本有对该数据结构的详细讨论 csdn上也有很多相关文章

实现如下

#include <iostream>
#include <stack>
#include <utility>
#include <algorithm>
#include <list>
#include <random>
#include <vector>
using namespace std;

enum class Color { RED, BLACK };
enum class node_type { Node3, Node4 };
template <typename T>
struct LeftLeaningRBTreeNode
{
    T data;
    Color color;
    LeftLeaningRBTreeNode* left = nullptr;
    LeftLeaningRBTreeNode* right = nullptr;
    LeftLeaningRBTreeNode(const T& data, Color color) :data(data), color(color) {}
};

template <typename T>
void flipColor(LeftLeaningRBTreeNode<T>* cur)
{
	if (cur->color == Color::BLACK)
	{
		cur->color = Color::RED;
	}
	else
	{
		cur->color = Color::BLACK;
	}
}

template <typename T>
LeftLeaningRBTreeNode<T>* RotateLR(LeftLeaningRBTreeNode<T>* ptr)
{
	LeftLeaningRBTreeNode<T>* p = ptr->left;
	LeftLeaningRBTreeNode<T>* q = p->right;
	p->right = q->left;
	q->left = p;
	ptr->left = q->right;
	q->right = ptr;
	return q;
}

template <typename T>
LeftLeaningRBTreeNode<T>* RotateRL(LeftLeaningRBTreeNode<T>* ptr)
{
	LeftLeaningRBTreeNode<T>* p = ptr->right;
	LeftLeaningRBTreeNode<T>* q = p->left;
	p->left = q->right;
	q->right = p;
	ptr->right = q->left;
	q->left = ptr;
	return q;
}

template <typename T>
LeftLeaningRBTreeNode<T>* RotateR(LeftLeaningRBTreeNode<T>* ptr)
{
	LeftLeaningRBTreeNode<T>* p = ptr->left;
	ptr->left = p->right;
	p->right = ptr;
	return p;
}

template <typename T>
LeftLeaningRBTreeNode<T>* RotateL(LeftLeaningRBTreeNode<T>* ptr)
{
	LeftLeaningRBTreeNode<T>* p = ptr->right;
	ptr->right = p->left;
	p->left = ptr;
	return p;
}

template <typename T>
void R1R2CombineFor4Node(LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* R1, LeftLeaningRBTreeNode<T>* R2)
{
	flipColor(mid);
	flipColor(right);
	flipColor(left);
	flipColor(R1);
	flipColor(R2);
	RotateL(mid);
}

template <typename T>
void R2BorrowFromR1For4Node(LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R1, LeftLeaningRBTreeNode<T>*R1_left_child)
{
	flipColor(R1);
	flipColor(R1_left_child);
	mid->left = RotateR(left);
	R1->right = RotateL(left);
}

template <typename T>
void R1BorrowFromR2For4Node(LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T> *R1)
{
	flipColor(left);
	flipColor(R1);
	mid->left = RotateRL(left);
}

template <typename T>
void R3R4CombineFor4Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>*R3, LeftLeaningRBTreeNode<T>* R4)
{
	flipColor(right);
	flipColor(R3);
	flipColor(R4);
}

template <typename T>
void R3BorrowFromR4For4Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R3)
{
	flipColor(right);
	flipColor(R3);
	mid->right = RotateRL(right);
}

template <typename T>
void R4BorrowFromR3For4Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R3, LeftLeaningRBTreeNode<T>* R3_left_child)
{
	flipColor(R3);
	flipColor(R3_left_child);
	mid->right = RotateR(right);
	R3->right = RotateL(right);
}

template <typename T>
void R2R3CombineFor4Node(LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* R2, LeftLeaningRBTreeNode<T>* R3)
{
	flipColor(right);
	flipColor(R2);
	flipColor(R3);
	RotateL(mid);
	right->left = RotateR(mid);
}

template <typename T>
void R2BorrowFromR3For4Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R3, LeftLeaningRBTreeNode<T>* R3_left_child, LeftLeaningRBTreeNode<T>*left)
{
	flipColor(left->right);
	flipColor(R3_left_child);
	right->left = RotateR(R3);
	mid->right = RotateR(right);
	RotateL(mid);
	R3_left_child->left = RotateR(mid);
}

template <typename T>
void R3BorrowFromR2For4Node(LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R2, LeftLeaningRBTreeNode<T>* right)
{
	flipColor(mid);
	flipColor(R2->left);
	RotateLR(mid);
	R2->right = RotateL(mid);
	right->left = RotateL(mid);
}
template <typename T>
void R1R2CombineFor3Node(LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* R1, LeftLeaningRBTreeNode<T>* R2)
{
	flipColor(left);
	flipColor(R1);
	flipColor(R2);
}

template <typename T>
void R2R3CombineFor3Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* R3, LeftLeaningRBTreeNode<T>* R2)
{
	flipColor(left);
	flipColor(R2);
	flipColor(R3);
	RotateR(right);
}

template <typename T>
void R2BorrowFromR1For3Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* R1, LeftLeaningRBTreeNode<T>*R1_left_child)
{
	flipColor(R1);
	flipColor(R1_left_child);
	right->left = RotateR(left);
	R1->right = RotateL(left);
}

template <typename T>
void R1BorrowFromR2For3Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* left, LeftLeaningRBTreeNode<T>* R1)
{
	flipColor(left);
	flipColor(R1);
	right->left = RotateRL(left);
}

template <typename T>
void R3BorrowFromR2For3Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* R2_left_child, LeftLeaningRBTreeNode<T>* R2)
{
	flipColor(right);
	flipColor(R2_left_child);
	RotateLR(right);
	R2->right = RotateL(right);
}

template <typename T>
void R2BorrowFromR3For3Node(LeftLeaningRBTreeNode<T>* right, LeftLeaningRBTreeNode<T>* R2, LeftLeaningRBTreeNode<T>* R3_left_child)
{
	flipColor(R2);
	flipColor(R3_left_child);
	RotateRL(right);
	R3_left_child->left = RotateR(right);
}

template <typename T>
void R2BorrowFromR1For2Node(LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R1, LeftLeaningRBTreeNode<T>* R1_left_child)
{
	flipColor(mid);
	flipColor(R1_left_child);
	RotateR(mid);
	R1->right = RotateL(mid);
}

template <typename T>
void R1BorrowFromR2For2Node(LeftLeaningRBTreeNode<T>* mid, LeftLeaningRBTreeNode<T>* R1, LeftLeaningRBTreeNode<T>* R2_left_child)
{
	flipColor(R1);
	flipColor(R2_left_child);
	RotateRL(mid);
}

enum class Down_Node_Index { R1, R2, R3, R4 };

template <typename T>
struct StackNode
{
	LeftLeaningRBTreeNode<T>* cur;
	LeftLeaningRBTreeNode<T>** upper;
	Down_Node_Index link_point;
	StackNode(LeftLeaningRBTreeNode<T>* c, LeftLeaningRBTreeNode<T>** u, Down_Node_Index l) :cur(c), upper(u), link_point(l) {}
};

template <typename T>
class LeftLeaningRBTree
{
public:
	friend int main();
	bool deleteMax();
	bool deleteMin();
	bool deleteAnyKey(const T &key);
	bool insert(const T& key);
private:
    LeftLeaningRBTreeNode<T>* root = nullptr;
	void linkWithUpper(LeftLeaningRBTreeNode<T>* cur, LeftLeaningRBTreeNode<T>** upper);
	void linkWithUpperForDelete(LeftLeaningRBTreeNode<T>* cur, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack);
	void linkWithUpperForFixUp(LeftLeaningRBTreeNode<T>* cur, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack);
	void eliminate4Node(stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool,bool>>>& work_stack);
	bool remove(const T& key, node_type &flag, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, LeftLeaningRBTreeNode<T>* &parent, LeftLeaningRBTreeNode<T>**& link_point);
	LeftLeaningRBTreeNode<T>* deleteMinMaintain(LeftLeaningRBTreeNode<T>*& parent, LeftLeaningRBTreeNode<T>*& q, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, node_type& type_flag, bool link_or_set_sub_tree_root);
	LeftLeaningRBTreeNode<T>* deleteMaxMaintain(LeftLeaningRBTreeNode<T>*& parent, LeftLeaningRBTreeNode<T>*& q, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, node_type& type_flag, bool link_or_set_sub_tree_root);
	void link_with_upper_for_insert(LeftLeaningRBTreeNode<T>* Node2Father, LeftLeaningRBTreeNode<T>* Node2LowestLevel, LeftLeaningRBTreeNode<T>* cur);
	void decideLinkOrSet(bool first_cycle, bool link_or_set_sub_tree_root, LeftLeaningRBTreeNode<T>*& root_after_process, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, LeftLeaningRBTreeNode<T>* r);
	void decideLinkOrSetForLeaf(LeftLeaningRBTreeNode<T>* _q, bool link_or_set_sub_tree_root, LeftLeaningRBTreeNode<T>*& root_after_process, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, LeftLeaningRBTreeNode<T>* r);
};

template <typename T>
bool is3Node(LeftLeaningRBTreeNode<T>* cur)
{
	return cur->left != nullptr && cur->left->color == Color::RED;
}

template <typename T>
bool is4Node(LeftLeaningRBTreeNode<T>* cur)
{
	return cur->left != nullptr && cur->left->color == Color::RED && cur->right != nullptr && cur->right->color == Color::RED;
}


template <typename T>
void LeftLeaningRBTree<T>::linkWithUpperForFixUp(LeftLeaningRBTreeNode<T>* cur, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack)
{
	if (work_stack.empty())
	{
		root = cur;
	}
	else
	{
		if (work_stack.top().second.first)
		{
			work_stack.top().first->left = cur;
		}
		else
		{
			work_stack.top().first->right = cur;
		}
	}
}

template <typename T>
void LeftLeaningRBTree<T>::linkWithUpper(LeftLeaningRBTreeNode<T>* cur, LeftLeaningRBTreeNode<T>** upper)
{
	if (upper == nullptr)
	{
		root = cur;
	}
	else
	{
		*upper = cur;
	}
}


template <typename T>
void LeftLeaningRBTree<T>::linkWithUpperForDelete(LeftLeaningRBTreeNode<T>* cur, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack)
{
	if (work_stack.empty())
	{
		root = cur;
	}
	else
	{
		if (work_stack.top().second.first)
			work_stack.top().first->left = cur;
		else
			work_stack.top().first->right = cur;
	}
}


template <typename T>
void LeftLeaningRBTree<T>::link_with_upper_for_insert(LeftLeaningRBTreeNode<T>* Node2Father, LeftLeaningRBTreeNode<T>* Node2LowestLevel, LeftLeaningRBTreeNode<T>* cur)
{
	if (Node2Father == nullptr)
	{
		root = cur;
	}
	else
	{
		if (Node2Father->left == Node2LowestLevel)
		{
			Node2Father->left = cur;
		}
		else
		{
			Node2Father->right = cur;
		}
	}
}

template <typename T>
bool LeftLeaningRBTree<T>::insert(const T& key)
{
	if (root == nullptr)
	{
		root = new LeftLeaningRBTreeNode<T>(key, Color::BLACK);
		return true;
	}

	LeftLeaningRBTreeNode<T>* run = root;
	LeftLeaningRBTreeNode<T>* Node2LowestLevel = nullptr;
	LeftLeaningRBTreeNode<T>* Node2Father = nullptr;
	list<StackNode<T>> work_stack;

	do
	{
		if (run->data == key)
			return false;

		bool less = key < run->data;

		if (is3Node(run) == false)
		{
			if (work_stack.empty() == false)
			{
				if (work_stack.back().link_point == Down_Node_Index::R3)
					Node2Father = work_stack.back().cur;
				else
					Node2Father = work_stack.back().cur->left;
			}
			else
			{
				Node2Father = Node2LowestLevel;
			}
			Node2LowestLevel = run;
			work_stack.clear();
			if (less)
				run = run->left;
			else
				run = run->right;
		}      
		else
		{
			if (less)
			{
				if (run->left->data == key)
					return false;
				if (key < run->left->data)
				{
					work_stack.push_back(StackNode<T>(run, &run->left->left, Down_Node_Index::R1));
					run = run->left->left;
				}
				else
				{
					work_stack.push_back(StackNode<T>(run, &run->left->right, Down_Node_Index::R2));
					run = run->left->right;
				}
			}
			else
			{
				work_stack.push_back(StackNode<T>(run, &run->right, Down_Node_Index::R3));
				run = run->right;
			}
		}

	} while (run!= nullptr);

	if (Node2LowestLevel != nullptr && work_stack.empty())
	{
		if (key < Node2LowestLevel->data)
		{
			Node2LowestLevel->left = new LeftLeaningRBTreeNode<T>(key, Color::RED);
		}
		else
		{
			LeftLeaningRBTreeNode<T> * temp = Node2LowestLevel->right = new LeftLeaningRBTreeNode<T>(key, Color::RED);
			flipColor(Node2LowestLevel);
			flipColor(temp);
			RotateL(Node2LowestLevel);
			link_with_upper_for_insert(Node2Father, Node2LowestLevel, temp);
		}
	}
	else
	{
		StackNode<T> t = work_stack.back();
		work_stack.pop_back();
		*(t.upper) = new LeftLeaningRBTreeNode<T>(key, Color::RED);
		LeftLeaningRBTreeNode<T>* p = nullptr;
		LeftLeaningRBTreeNode<T>* original = nullptr;
		original = t.cur;
		if (t.link_point == Down_Node_Index::R1)
		{
			flipColor(original);
			flipColor(original->left);
			p = RotateR(original);
		}
		else if (t.link_point == Down_Node_Index::R2)
		{
			flipColor(original);
			p = RotateLR(original);
			flipColor(p);
		}
		else
		{
			p = original;
		}
		//注意 和上层链接是否有必要
		while (work_stack.empty() == false)
		{
			LeftLeaningRBTreeNode<T>* q = work_stack.back().cur;
			Down_Node_Index d = work_stack.back().link_point;
			*(work_stack.back().upper) = p;
			work_stack.pop_back();

			original = q;
			flipColor(p->left);
			flipColor(p->right);
			flipColor(p);
			if (d == Down_Node_Index::R1 || d == Down_Node_Index::R2)
			{
				if (d == Down_Node_Index::R1)
				{
					p = RotateR(q);
				}
				else
				{
					RotateLR(q);
				}
				flipColor(p);
				flipColor(q);
			}
			else
			{
				p = q;
			}
		}

		flipColor(p->left);
		flipColor(p->right);
		if (Node2LowestLevel != nullptr)
		{
			flipColor(p);
			if (original == Node2LowestLevel->right)
			{
				Node2LowestLevel->right = p;
				flipColor(p);
				flipColor(Node2LowestLevel);
				RotateL(Node2LowestLevel);
				link_with_upper_for_insert(Node2Father, Node2LowestLevel, p);
			}
			else
			{
				Node2LowestLevel->left = p;
			}
		}
		else
		{
			root = p;
		}
	}
	return true;
}

template <typename T>
void findMinValueAndSwap(LeftLeaningRBTreeNode<T>* cur, const T &key)
{
	LeftLeaningRBTreeNode<T>* run = cur->right;
	while (run->left != nullptr)
	{
		run = run->left;
	}
	cur->data = run->data;
	run->data = key;
}

template <typename T>
void findMaxValueAndSwap(LeftLeaningRBTreeNode<T>* cur, const T& key)
{
	LeftLeaningRBTreeNode<T>* run = cur->left;
	while (run->right != nullptr)
	{
		run = run->right;
	}
	cur->data = run->data;
	run->data = key;
}

template <typename T>
bool LeftLeaningRBTree<T>::deleteAnyKey(const T& key)
{
	if (root == nullptr)
		return false;
	node_type flag;
	stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>> work_stack;
	LeftLeaningRBTreeNode<T>* parent = nullptr;
	LeftLeaningRBTreeNode<T>** link_point = nullptr;

	if (is3Node(root) == false)
	{
		if (root->left == nullptr)
		{
			if (root->data == key)
			{
				delete root;
				root = nullptr;
				return true;
			}
			return false;
		}

		bool l = is3Node(root->left);
		bool r = is3Node(root->right);  
		bool less = key < root->data;
		bool equal = key == root->data;
		bool lessEqual = less || equal;

		
		if (r && !lessEqual)
		{
			flag = node_type::Node3;
			parent = root->right;
			work_stack.push(make_pair(root, make_pair(false, false)));  
			link_point = &root->right;
		}
		else if (l && less) 
		{
			flag = node_type::Node3;
			parent = root->left;
			work_stack.push(make_pair(root, make_pair(true, false))); 
			link_point = &root->left;
		}

		if (l == false)
		{
			if (r == false)
			{
				flipColor(root->left);
				flipColor(root->right);
				flag = node_type::Node4;
				parent = root;
			}
			else
			{
				if (lessEqual)
				{
					parent = root;
					root = root->right->left;
					flag = node_type::Node3;
					work_stack.push(make_pair(root, make_pair(true, false)));
					link_point = &root->left;
					R1BorrowFromR2For2Node(parent, parent->left, root);
				}
			}
		}
		else
		{
			if (r == false)
			{
				if (!less)
				{
					parent = root->left;
					R2BorrowFromR1For2Node(root, parent, parent->left);
					root = parent;
					parent = parent->right;
					work_stack.push(make_pair(root, make_pair(false, false)));
					flag = node_type::Node3;
					link_point = &root->right;
				}
			}
			else
			{
				if (equal)
				{
					parent = root->left;
					LeftLeaningRBTreeNode<T>* temp = root;
					root = RotateRL(root);
					root->left = RotateR(temp);
					flipColor(temp);
					flipColor(root);
					flag = node_type::Node4;
					work_stack.push(make_pair(root, make_pair(true, false)));
					link_point = &root->left;
				}
			}
		}
	}
	else
	{
	     flag = node_type::Node3;
	     parent = root;
	}
	return remove(key, flag, work_stack, parent, link_point);
}

template <typename T>
bool LeftLeaningRBTree<T>::remove(const T& key, node_type& flag, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, LeftLeaningRBTreeNode<T>* &parent, LeftLeaningRBTreeNode<T>** &link_point)
{
	bool remove_sucess;
	while (true)
	{
		Down_Node_Index down_node_index;
		LeftLeaningRBTreeNode<T>* q = nullptr;
		LeftLeaningRBTreeNode<T>* second_level = nullptr;
		if (flag == node_type::Node4)
		{		
			if (key < parent->data)
			{
				second_level = parent->left;
				if (key < second_level->data)
				{
					q = second_level->left;
					down_node_index = Down_Node_Index::R1;
				}
				else if (key > second_level->data)
				{
					q = second_level->right;
					down_node_index = Down_Node_Index::R2;
				}
				else
				{
					if (second_level->left != nullptr)
					{
						bool l;
						if ((l = is3Node(second_level->left)) || is3Node(second_level->right))
						{
							work_stack.push(make_pair(parent, make_pair(true, true)));
							flag = node_type::Node3;
							if (l)
							{
								work_stack.push(make_pair(second_level, make_pair(true, false)));
								parent = second_level->left;
								q = parent->right;
								findMaxValueAndSwap(second_level, key);
								second_level->left = deleteMaxMaintain(parent, q, work_stack, flag, false);
							}
							else
							{
								parent = second_level->right;
							}
						}
						else
						{
							LeftLeaningRBTreeNode<T>* c = parent->right;
							if (is3Node(c->left) == false)
							{
								work_stack.push(make_pair(c, make_pair(true, false)));
								flag = node_type::Node4;
								linkWithUpper(c, link_point);
								R2R3CombineFor4Node(parent, c, second_level->right, c->left);
							}
							else
							{
								work_stack.push(make_pair(c->left->left, make_pair(true, true)));
								flag = node_type::Node3;
								linkWithUpper(c->left->left, link_point);
								R2BorrowFromR3For4Node(c, parent, c->left, c->left->left, second_level);
							}
						}

						if (l == false)
						{
							work_stack.push(make_pair(second_level, make_pair(false, false)));
							q = parent->left->left;
							findMinValueAndSwap(second_level, key);
							second_level->right = deleteMinMaintain(parent, q, work_stack, flag, false);
						}
					}
					else
					{
						delete parent->left;
						parent->left = nullptr;
						flipColor(parent->right);
						flipColor(parent);
						parent = RotateL(parent);
						linkWithUpper(parent, link_point);
					}
					remove_sucess = true;
					break;
				}
			}
			else if (key > parent->data)
			{
				second_level = parent->right;
				if (key < second_level->data)
				{
					q = second_level->left;
					down_node_index = Down_Node_Index::R3;
				}
				else if (key > second_level->data)
				{
					q = second_level->right;
					down_node_index = Down_Node_Index::R4;
				}
				else
				{
					if (second_level->left != nullptr)
					{
						LeftLeaningRBTreeNode<T>* b = parent->left;
						if (is3Node(second_level->left))
						{
							work_stack.push(make_pair(parent, make_pair(false, true)));
							work_stack.push(make_pair(second_level, make_pair(true, false)));
							flag = node_type::Node3;
							parent = second_level->left;
							q = parent->right;
							findMaxValueAndSwap(second_level, key);
							second_level->left = deleteMaxMaintain(parent, q, work_stack, flag, false);
						}
						else if (is3Node(second_level->right))
						{
							work_stack.push(make_pair(parent, make_pair(false, true)));
							work_stack.push(make_pair(second_level, make_pair(false, false)));
							flag = node_type::Node3;
							parent = second_level->right;
							q = parent->left->left;
							findMinValueAndSwap(second_level, key);
							second_level->right = deleteMinMaintain(parent, q, work_stack, flag, false);
						}
						else
						{
							if (is3Node(b->right) == false)
							{
								work_stack.push(make_pair(second_level, make_pair(true, false)));
								work_stack.push(make_pair(b, make_pair(false, false)));
								flag = node_type::Node4;
								linkWithUpper(second_level, link_point);
								findMaxValueAndSwap(second_level, key);
								R2R3CombineFor4Node(parent, second_level, b->right, second_level->left);
								q = parent->right->right;
								deleteMaxMaintain(parent, q, work_stack, flag, true);
							}
							else
							{
								work_stack.push(make_pair(b->right, make_pair(false, true)));
								work_stack.push(make_pair(second_level, make_pair(true, false)));
								flag = node_type::Node3;
								linkWithUpper(b->right, link_point);
								findMaxValueAndSwap(second_level, key);
								R3BorrowFromR2For4Node(parent, b->right, second_level);
								parent = second_level->left;
								q = parent->right;
								second_level->left = deleteMaxMaintain(parent, q, work_stack, flag, false);
							}
						}
					}
					else
					{
						delete parent->right;
						parent->right = nullptr;
					}
					remove_sucess = true;
					break;
				}
			}
			else
			{
				second_level = parent->right;
				if (second_level->left != nullptr)
				{
					LeftLeaningRBTreeNode<T>* b = parent->left;
					if (is3Node(b->right))
					{
						work_stack.push(make_pair(parent, make_pair(true, true)));
						work_stack.push(make_pair(b, make_pair(false, false)));
						flag = node_type::Node3;
						findMaxValueAndSwap(parent, key);
						parent = b->right;
						q = parent->right;
						deleteMaxMaintain(parent, q, work_stack, flag, true);
					}
					else if (is3Node(second_level->left))
					{
						work_stack.push(make_pair(parent, make_pair(false, true)));
						work_stack.push(make_pair(second_level, make_pair(true, false)));
						flag = node_type::Node3;
						findMinValueAndSwap(parent, key);
						parent = second_level->left;
						q = parent->left->left;
						deleteMinMaintain(parent, q, work_stack, flag, true);
					}
					else
					{
						if (is3Node(second_level->right) == false)
						{
							work_stack.push(make_pair(parent, make_pair(false, false)));
							flag = node_type::Node4;
							R3R4CombineFor4Node(second_level, second_level->left, second_level->right);
							findMinValueAndSwap(parent, key);
							b = parent;
							parent = second_level;
							q = parent->left->left;
							b->right = deleteMinMaintain(parent, q, work_stack, flag, false);
						}
						else
						{
							if (is3Node(b->left) == false)
							{
								work_stack.push(make_pair(second_level, make_pair(true, false)));
								work_stack.push(make_pair(parent, make_pair(true, false)));
								flag = node_type::Node4;
								linkWithUpper(second_level, link_point);
								R1R2CombineFor4Node(parent, b, second_level, b->left, b->right);
								findMaxValueAndSwap(parent, key);
								second_level = parent;
								parent = b;
								q = parent->right->right;
								second_level->left = deleteMaxMaintain(parent, q, work_stack, flag, false);
							}
							else
							{
								second_level = b->left;
								work_stack.push(make_pair(parent, make_pair(true, true)));
								work_stack.push(make_pair(second_level, make_pair(false, false)));
								flag = node_type::Node3;
								R2BorrowFromR1For4Node(b, parent, second_level, second_level->left);
								findMaxValueAndSwap(parent, key);
								parent = second_level->right;
								q = parent->right;
								deleteMaxMaintain(parent, q, work_stack, flag, true);
							}
						}
					}
				}
				else
				{
					second_level = parent->left;
					q = parent->right;
					delete parent;
					flipColor(q);
					q->left = second_level;
					linkWithUpper(q, link_point);
				}
				remove_sucess = true;
				break;
			}

			if (q == nullptr)  // 更新flag work_stack parent link_point  //注意second_level和q
			{
				work_stack.push(make_pair(parent, make_pair(second_level == parent->left ? true : false, true)));
				remove_sucess = false;
				break;

			}
			else if(is3Node(q) == false)
			{
				if (down_node_index == Down_Node_Index::R2 || down_node_index == Down_Node_Index::R1)
				{
					if (down_node_index == Down_Node_Index::R2 ? is3Node(second_level->left) == false : is3Node(second_level->right) == false)
					{
						LeftLeaningRBTreeNode<T>* t = parent->right;
						if (down_node_index == Down_Node_Index::R2)
						     R1R2CombineFor4Node(parent, second_level, t, second_level->left, q);
						else
							R1R2CombineFor4Node(parent, second_level, parent->right, q, second_level->right);
						linkWithUpper(t, link_point);
						work_stack.push(make_pair(t, make_pair(true, false)));
						work_stack.push(make_pair(parent, make_pair(true, false)));
						link_point = &parent->left;
						parent = second_level;
						flag = node_type::Node4;
					}
					else
					{
						work_stack.push(make_pair(parent, make_pair(true, true)));
						if (down_node_index == Down_Node_Index::R2)
						{
							work_stack.push(make_pair(second_level->left, make_pair(false, false)));
							R2BorrowFromR1For4Node(second_level, parent, second_level->left, second_level->left->left);
							link_point = &parent->left->right;
							parent = q;
						}
						else
						{
							work_stack.push(make_pair(second_level->right->left, make_pair(true, false)));
							R1BorrowFromR2For4Node(second_level, parent, q);
							link_point = &parent->left->left;
							parent = second_level;
						}
						flag = node_type::Node3;
					}
				}
				else
				{
					if (down_node_index == Down_Node_Index::R3 ? is3Node(second_level->right) == false : is3Node(second_level->left) == false)
					{
						if (down_node_index == Down_Node_Index::R3)
						    R3R4CombineFor4Node(second_level, q, second_level->right);
						else
							R3R4CombineFor4Node(second_level, second_level->left, q);
						work_stack.push(make_pair(parent, make_pair(false, false)));
						link_point = &parent->right;
						parent = second_level;
						flag = node_type::Node4;
					}
					else
					{
						work_stack.push(make_pair(parent, make_pair(false, true)));
						if (down_node_index == Down_Node_Index::R3)
						{
							work_stack.push(make_pair(second_level->right->left, make_pair(true, false)));
							R3BorrowFromR4For4Node(second_level, parent, q);
							link_point = &parent->right->left;
							parent = second_level;
						}
						else
						{
							work_stack.push(make_pair(second_level->left, make_pair(false, false)));
							R4BorrowFromR3For4Node(second_level, parent, second_level->left, second_level->left->left);
							link_point = &parent->right->right;
							parent = q;
						}
						flag = node_type::Node3;
					}
				}
				continue;
			}
			else
			{
				if (down_node_index == Down_Node_Index::R1)
				{
					work_stack.push(make_pair(parent, make_pair(true, true)));
					work_stack.push(make_pair(second_level, make_pair(true, false)));
					link_point = &second_level->left;
				}
				else if (down_node_index == Down_Node_Index::R2)
				{
					work_stack.push(make_pair(parent, make_pair(true, true)));
					work_stack.push(make_pair(second_level, make_pair(false, false)));
					link_point = &second_level->right;
				}
				else if (down_node_index == Down_Node_Index::R3)
				{
					work_stack.push(make_pair(parent, make_pair(false, true)));
					work_stack.push(make_pair(second_level, make_pair(true, false)));
					link_point = &second_level->left;
				}
				else
				{
					work_stack.push(make_pair(parent, make_pair(false, true)));
					work_stack.push(make_pair(second_level, make_pair(false, false)));
					link_point = &second_level->right;
				}
			}		
		}
		else
		{
		    if (key == parent->data)
		    {
				if (parent->right != nullptr)
				{
					second_level = parent->left;
					if (is3Node(second_level->right))
					{
						work_stack.push(make_pair(parent, make_pair(true, false)));
						work_stack.push(make_pair(second_level, make_pair(false, false)));
						flag = node_type::Node3;
						findMaxValueAndSwap(parent, key);
						parent = second_level->right;
						q = parent->right;
						deleteMaxMaintain(parent, q, work_stack, flag, true);
					}
					else if (is3Node(parent->right))
					{
						work_stack.push(make_pair(parent, make_pair(false, false)));
						flag = node_type::Node3;
						findMinValueAndSwap(parent, key);
						second_level = parent;
						parent = parent->right;
						q = parent->left->left;
						second_level->right = deleteMinMaintain(parent, q, work_stack, flag, false);
					}
					else
					{
						if (is3Node(second_level->left) == false)
						{
							work_stack.push(make_pair(parent, make_pair(true, false)));
							flag = node_type::Node4;
							findMaxValueAndSwap(parent, key);
							R1R2CombineFor3Node(second_level, second_level->left, second_level->right);
							LeftLeaningRBTreeNode<T>* temp = parent;
							parent = second_level;
							q = parent->right->right;
							temp->left = deleteMaxMaintain(parent, q, work_stack, flag, false);
						}
						else
						{
							work_stack.push(make_pair(parent, make_pair(true, false)));
							q = second_level->left;
							work_stack.push(make_pair(q, make_pair(false, false)));
							flag = node_type::Node3;
							findMaxValueAndSwap(parent, key);
							R2BorrowFromR1For3Node(parent, second_level, q, q->left);
							parent = q->right;
							q = parent->right;
							deleteMaxMaintain(parent, q, work_stack, flag, true);
						}
					}
				}
				else
				{
					second_level = parent->left;
					delete parent;
					flipColor(second_level);
					linkWithUpper(second_level, link_point);
				}
				remove_sucess = true;
				break;
			}

			second_level = parent->left;
			if (key < parent->data)
			{
				if (key < second_level->data)
				{
					q = second_level->left;
					down_node_index = Down_Node_Index::R1;
				}
				else if (key > second_level->data)
				{
					q = second_level->right;
					down_node_index = Down_Node_Index::R2;
				}
				else
				{
					if (second_level->left != nullptr)
					{
						if (is3Node(second_level->left))
						{
							work_stack.push(make_pair(parent, make_pair(true, false)));          
							work_stack.push(make_pair(second_level, make_pair(true, false)));
							flag = node_type::Node3;
							findMaxValueAndSwap(second_level, key);
							parent = second_level->left;
							q = parent->right;
							second_level->left = deleteMaxMaintain(parent, q, work_stack, flag, false);
						}
						else
						{
							findMinValueAndSwap(second_level, key);
							if (is3Node(second_level->right))
							{
								work_stack.push(make_pair(parent, make_pair(true, false)));
								work_stack.push(make_pair(second_level, make_pair(false, false)));
								flag = node_type::Node3;
								parent = second_level->right;
							}
							else
							{
								if (is3Node(parent->right) == false)
								{
									work_stack.push(make_pair(second_level, make_pair(false, false)));
									flag = node_type::Node4;
									linkWithUpper(second_level, link_point);  //当前
									R2R3CombineFor3Node(parent, second_level, parent->right, second_level->right);
								}
								else
								{
									LeftLeaningRBTreeNode<T>* temp = parent->right->left;
									work_stack.push(make_pair(temp, make_pair(true, false)));
									work_stack.push(make_pair(second_level, make_pair(false, false)));
									flag = node_type::Node3;
									linkWithUpper(temp, link_point);
									R2BorrowFromR3For3Node(parent, second_level->right, temp);
								}
							}
							q = parent->left->left;
							second_level->right = deleteMinMaintain(parent, q, work_stack, flag, false);
						}				
					}
					else
					{
						delete second_level;
						parent->left = nullptr;
					}
					remove_sucess = true;
					break;
				}
			}
			else
			{
				q = parent->right;
				down_node_index = Down_Node_Index::R3;
			}

			if (q == nullptr)
			{
				remove_sucess = false;
				break;
			}
			else if (is3Node(q) == false)
			{
				if (down_node_index == Down_Node_Index::R2 ? is3Node(second_level->left) == false : (down_node_index == Down_Node_Index::R1 ? is3Node(second_level->right) == false : is3Node(second_level->right) == true))
				{
					if (down_node_index == Down_Node_Index::R2 || down_node_index == Down_Node_Index::R1)
					{
						if (down_node_index == Down_Node_Index::R2)
						    R1R2CombineFor3Node(second_level, second_level->left, q);    //r1
						else
							R1R2CombineFor3Node(second_level, q, second_level->right);   //r4
						work_stack.push(make_pair(parent, make_pair(true, false)));
						link_point = &parent->left;
						parent = second_level;
						flag = node_type::Node4;
					}
					else
					{
						linkWithUpper(second_level->right, link_point);
						work_stack.push(make_pair(second_level->right, make_pair(false, false)));   //r7
						link_point = &second_level->right->right;
						R3BorrowFromR2For3Node(parent, second_level->right->left, second_level->right);
						parent = q;
						flag = node_type::Node3;
					}
				}
				else
				{
					if (down_node_index == Down_Node_Index::R2 ? is3Node(parent->right) == false : (down_node_index == Down_Node_Index::R3 ? true : false))
					{
						if (down_node_index == Down_Node_Index::R2)
						{
							R2R3CombineFor3Node(parent, second_level, parent->right, q);     //*r2
						}
						else
						{
							R2R3CombineFor3Node(parent, second_level, q, second_level->right);   //*r6
						}
						linkWithUpper(second_level, link_point);
						work_stack.push(make_pair(second_level, make_pair(false, false)));
						link_point = &second_level->right;
						flag = node_type::Node4;
					}
					else  //3 5
					{
						work_stack.push(make_pair(parent, make_pair(true, false)));
						if (down_node_index == Down_Node_Index::R2)
						{
							R2BorrowFromR1For3Node(parent, second_level, second_level->left, second_level->left->left);
							work_stack.push(make_pair(parent->left, make_pair(false, false)));     //r3
							link_point = &parent->left->right;
							parent = q;
						}
						else
						{
							R1BorrowFromR2For3Node(parent, second_level, q);
							work_stack.push(make_pair(parent->left, make_pair(true, false)));   //r5
							link_point = &parent->left->left;
							parent = second_level;
						}
						flag = node_type::Node3;
					}
				}
				continue;
			}
			else
			{
				if (down_node_index == Down_Node_Index::R1)
				{
					work_stack.push(make_pair(parent, make_pair(true, false)));
					work_stack.push(make_pair(second_level, make_pair(true, false)));
					link_point = &second_level->left;
				}
				else if (down_node_index == Down_Node_Index::R2)
				{
					work_stack.push(make_pair(parent, make_pair(true, false)));
					work_stack.push(make_pair(second_level, make_pair(false, false)));
					link_point = &second_level->right;
				}
				else
				{
					work_stack.push(make_pair(parent, make_pair(false, false)));
					link_point = &parent->right;
				}
			}
		}
		flag = node_type::Node3;
		parent = q;
	}
	eliminate4Node(work_stack);
	return remove_sucess;
}

template <typename T>
void LeftLeaningRBTree<T>::eliminate4Node(stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack)
{
	while (true)
	{
		while (work_stack.empty() == false)
		{
			if (work_stack.top().second.second)
				break;
			work_stack.pop();
		}

		if (work_stack.empty())
			break;
		LeftLeaningRBTreeNode<T>* q = work_stack.top().first;
		work_stack.pop();
		while (true)
		{
			flipColor(q->left);
			flipColor(q->right);
			if (work_stack.empty())
				break;
			flipColor(q);
			LeftLeaningRBTreeNode<T>* parent = work_stack.top().first;
			bool link_d = work_stack.top().second.first;
			work_stack.pop();
			if (parent->color == Color::BLACK)
			{
				if (link_d == false)
				{
					if (parent->left->color == Color::RED)
					{
						q = parent;
					}
					else
					{
						flipColor(parent);
						flipColor(q);
						RotateL(parent);
						linkWithUpperForFixUp(q, work_stack);
						break;
					}
				}
				else
				{
					break;
				}
			}
			else
			{
				LeftLeaningRBTreeNode<T>* pp = work_stack.top().first;
				bool is4_Node = work_stack.top().second.second;
				work_stack.pop();
				if (is4_Node)
				{
					q = pp;
				}
				else
				{
					if (link_d == false)
					{
						flipColor(pp);
						flipColor(q);
						RotateLR(pp);
						linkWithUpperForFixUp(q, work_stack);
					}
					else
					{
						flipColor(pp);
						flipColor(parent);
						RotateR(pp);
						linkWithUpperForFixUp(parent, work_stack);
						q = parent;
					}
				}
			}
		}
	}
}

template <typename T>
void LeftLeaningRBTree<T>::decideLinkOrSet(bool first_cycle, bool link_or_set_sub_tree_root, LeftLeaningRBTreeNode<T>* &root_after_process, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, LeftLeaningRBTreeNode<T>* r)
{
	if (first_cycle && link_or_set_sub_tree_root == false)
	{
		root_after_process = r;
	}
	else
	{
		linkWithUpperForDelete(r, work_stack);
	}
}

template <typename T>
void LeftLeaningRBTree<T>::decideLinkOrSetForLeaf(LeftLeaningRBTreeNode<T>* _q, bool link_or_set_sub_tree_root, LeftLeaningRBTreeNode<T>*& root_after_process, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, LeftLeaningRBTreeNode<T>* r)
{
	if (_q == nullptr && link_or_set_sub_tree_root == false)
	{
		root_after_process = r;
	}
	else
	{
		linkWithUpperForDelete(r, work_stack);
	}
}

template <typename T>
LeftLeaningRBTreeNode<T>* LeftLeaningRBTree<T>::deleteMinMaintain(LeftLeaningRBTreeNode<T>* &parent, LeftLeaningRBTreeNode<T>* &q, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>&work_stack, node_type &type_flag, bool link_or_set_sub_tree_root)
{
	LeftLeaningRBTreeNode<T>* root_after_process = parent;
	LeftLeaningRBTreeNode<T>* _q = q;
	bool first_cycle = true;
	while (q != nullptr)
	{
		if (is3Node(q) == false)
		{
			LeftLeaningRBTreeNode<T>* m = parent->left;
			LeftLeaningRBTreeNode<T>* p = m->right;
			if (type_flag == node_type::Node3)
			{
				work_stack.push(make_pair(parent, make_pair(true, false)));
				if (is3Node(p) == false)
				{
					R1R2CombineFor3Node(m, q, p);
					type_flag = node_type::Node4;

				}
				else
				{
					R1BorrowFromR2For3Node(parent, m, q);
					work_stack.push(make_pair(parent->left, make_pair(true, false)));
				}
			}
			else
			{
				if (is3Node(p) == false)
				{
					LeftLeaningRBTreeNode<T>* right = parent->right;
					decideLinkOrSet(first_cycle, link_or_set_sub_tree_root, root_after_process, work_stack, right);						
					work_stack.push(make_pair(right, make_pair(true, false)));
					work_stack.push(make_pair(parent, make_pair(true, false)));
					R1R2CombineFor4Node(parent, m, right, q, p);
				}
				else
				{
					work_stack.push(make_pair(parent, make_pair(true, true)));
					work_stack.push(make_pair(p->left, make_pair(true, false)));
					R1BorrowFromR2For4Node(m, parent, q);
					type_flag = node_type::Node3;
				}
			}
			parent = m;
			q = q->left;
		}
		else
		{
			if (type_flag == node_type::Node3)
				work_stack.push(make_pair(parent, make_pair(true, false)));
			else
			{
				type_flag = node_type::Node3;
				work_stack.push(make_pair(parent, make_pair(true, true)));
			}
			work_stack.push(make_pair(parent->left, make_pair(true, false)));
			parent = q;
			q = q->left->left;
		}
		first_cycle = false;
	}

	delete parent->left;
	parent->left = nullptr;
	if (type_flag == node_type::Node4)
	{
		flipColor(parent->right);
		flipColor(parent);
		parent = RotateL(parent);
		decideLinkOrSetForLeaf(_q, link_or_set_sub_tree_root, root_after_process, work_stack, parent);
	}

	return root_after_process;
}

template <typename T>
bool LeftLeaningRBTree<T>::deleteMin()
{
	if (root == nullptr)
		return false;

	LeftLeaningRBTreeNode<T>* parent = nullptr;
	LeftLeaningRBTreeNode<T>* q = nullptr;
	stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>> work_stack;
	node_type type_flag;

	bool l;
	if ((l = is3Node(root)) == false)
	{
		if (root->left == nullptr)
		{
			delete root;
			root = nullptr;
			return true;
		}
	}

	bool r;
	if (l == false && ((r = is3Node(root->left)) || is3Node(root->right)))
	{
		if (r)
		{
			parent = root->left;
			q = parent->left->left;
		}
		else
		{
			q = root->left;
			parent = root->right->left;
			R1BorrowFromR2For2Node(root, q, parent);
			swap(parent, root);
			q = q->left;
		}
		work_stack.push(make_pair(root, make_pair(true, false)));
		type_flag = node_type::Node3;
	}
	else
	{
		if (l)
		{
			type_flag = node_type::Node3;
		}
		else
		{
			flipColor(root->left);
			flipColor(root->right);
			type_flag = node_type::Node4;
		}
		parent = root;
		q = root->left->left;
	}

	deleteMinMaintain(parent, q, work_stack, type_flag, true);
	eliminate4Node(work_stack);
	return true;
}

template <typename T>
LeftLeaningRBTreeNode<T>* LeftLeaningRBTree<T>::deleteMaxMaintain(LeftLeaningRBTreeNode<T>*& parent, LeftLeaningRBTreeNode<T>*& q, stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>>& work_stack, node_type& type_flag, bool link_or_set_sub_tree_root)
{
	LeftLeaningRBTreeNode<T>* root_after_process = parent;
	LeftLeaningRBTreeNode<T>* _q = q;
	bool first_cycle = true;
	while (q != nullptr)   //q parent stack flag
	{
		if (is3Node(q) == false)
		{
			LeftLeaningRBTreeNode<T>* l = nullptr;
			LeftLeaningRBTreeNode<T>* r = nullptr;
			if (type_flag == node_type::Node3)
			{
				l = parent->left;
				r = l->right;
			}
			else
			{
				l = parent->right;
				r = l->left;
			}

			if (is3Node(r) == false)
			{
				if (type_flag == node_type::Node3)
				{
					decideLinkOrSet(first_cycle, link_or_set_sub_tree_root, root_after_process, work_stack, l);
					R2R3CombineFor3Node(parent, l, q, r);
					work_stack.push(make_pair(l, make_pair(false, false)));
					type_flag = node_type::Node4;
				}
				else
				{
					work_stack.push(make_pair(parent, make_pair(false, false)));
					R3R4CombineFor4Node(l, r, q);
					parent = l;
				}
				q = q->right;
				first_cycle = false;
				continue;
			}

			if (type_flag == node_type::Node3)
			{
				decideLinkOrSet(first_cycle, link_or_set_sub_tree_root, root_after_process, work_stack, r);
				R3BorrowFromR2For3Node(parent, r->left, r);
			}
			else
			{
				work_stack.push(make_pair(parent, make_pair(false, true)));
				R4BorrowFromR3For4Node(l, parent, r, r->left);
				type_flag = node_type::Node3;
			}
			work_stack.push(make_pair(r, make_pair(false, false)));
		}
		else
		{
			if (type_flag == node_type::Node4)
			{
				work_stack.push(make_pair(parent, make_pair(false, true)));
				work_stack.push(make_pair(parent->right, make_pair(false, false)));    可能有错
				type_flag = node_type::Node3;
			}
			else
			{
				work_stack.push(make_pair(parent, make_pair(false, false)));
			}
		}
		first_cycle = false;
		parent = q;
		q = q->right;
	}

	if (type_flag == node_type::Node3)  //parent是3-Node
	{
		q = parent;
		parent = parent->left;
		delete q;
		parent->color = Color::BLACK;
		decideLinkOrSetForLeaf(_q, link_or_set_sub_tree_root, root_after_process, work_stack, parent);
	}
	else    //parent是4-Node
	{
		delete parent->right;
		parent->right = nullptr;
	}
	return root_after_process;
}

template <typename T>
bool LeftLeaningRBTree<T>::deleteMax()
{
	if (root == nullptr)
		return false;

	LeftLeaningRBTreeNode<T>* parent = nullptr;
	LeftLeaningRBTreeNode<T>* q = nullptr;
	stack<pair<LeftLeaningRBTreeNode<T>*, pair<bool, bool>>> work_stack;
	node_type type_flag;
	if (is3Node(root) == false)
	{
		if (root->left == nullptr)
		{
			delete root;
			root = nullptr;
			return true;
		}

		bool r = is3Node(root->right);
		if (r || is3Node(root->left))
		{
			parent = root->right;
			if (r == false)
			{
				q = root->left;
				R2BorrowFromR1For2Node(root, q, q->left);
				root = q;
			}				
			q = parent->right;
			type_flag = node_type::Node3;
			work_stack.push(make_pair(root, make_pair(false, false)));
		}
		else
		{
			flipColor(root->left);
			flipColor(root->right);
			parent = root;
			q = root->right->right;
			type_flag = node_type::Node4;
		}
	}
	else
	{
		parent = root;
		q = root->right;
		type_flag = node_type::Node3;
	}
	deleteMaxMaintain(parent, q, work_stack, type_flag, true);
	eliminate4Node(work_stack);
	return true;
}

template <typename T>
bool checkLeftLeaningRBTreeProperty(LeftLeaningRBTreeNode<T>* root)
{
	if (root == nullptr)
		return true;
	if (root->color != Color::BLACK)
		return false;
	T min;
	T max;
	if (isLeftLeaningRBTree(root, min, max) != -1)
		return true;
	return false;
}

template <typename T>
long long isLeftLeaningRBTree(LeftLeaningRBTreeNode<T>* root, T &min, T &max)  //每次递归调用root一定不为空且颜色为黑色
{
	if (root->right == nullptr)
	{
		if (root->left == nullptr || root->left->color == Color::RED && root->left->left == nullptr && root->left->right == nullptr)
		{
			if (root->left == nullptr)
			{
				min = root->data;
			}
			else
			{
				if (root->left->data >= root->data)
				{
					return -1;
				}
				min = root->left->data;
			}
			max = root->data;
			return 0;
		}
		return -1;
	}
	else
	{
		if (root->left == nullptr || root->right->color == Color::RED)
		{
			return -1;
		}

		if (root->left->color == Color::RED)
		{
			if (root->left->left != nullptr && root->left->left->color == Color::BLACK && root->left->right != nullptr && root->left->right->color == Color::BLACK)
			{
				T left_left_min;
				T left_left_max;
				long long l = isLeftLeaningRBTree(root->left->left, left_left_min, left_left_max);
				if (l == -1)
					return -1;

				if (left_left_max >= root->left->data)
					return -1;

				T left_right_min;
				T left_right_max;
				long long m = isLeftLeaningRBTree(root->left->right, left_right_min, left_right_max);
				if (m == -1 || l != m)
					return -1;
				if (left_right_min <= root->left->data || left_right_max >= root->data)
					return -1;

				T right_min;
				T right_max;
				long long r = isLeftLeaningRBTree(root->right, right_min, right_max);
				if (r == -1 || r != m)
					return -1;

				if (right_min <= root->data)
					return -1;

				min = left_left_min;
				max = right_max;
				return l + 1;
			}
			else
			{
				return -1;
			}
		}
		else
		{
			T left_min;
			T left_max;
			long long l = isLeftLeaningRBTree(root->left, left_min, left_max);
			if (l == -1)
				return -1;
			if (left_max >= root->data)
				return -1;

			T right_min;
			T right_max;
			long long m = isLeftLeaningRBTree(root->right, right_min, right_max);
			if (m == -1 || l != m)
				return -1;
			if (right_min <= root->data)
				return -1;
			min = left_min;
			max = right_max;
			return l + 1;
		}
	}
}
int main()
{
	const int N = 10000;
	vector<int> seq(N);
	for (int i = 0; i < N; i++)
	{
		seq[i] = i + 1;
	}
	shuffle(seq.begin(), seq.end(), default_random_engine());
	LeftLeaningRBTree<int> obj;
	for (size_t i = 0; i < seq.size(); ++i)
	{
		cout << "插入" << seq[i] << endl;
		if (obj.insert(seq[i]))
		{
			cout << "插入成功!" << endl;
			if (checkLeftLeaningRBTreeProperty(obj.root))
			{
				cout << "当前树是左倾红黑树" << endl;
			}
			else
			{
				cout << "ERROR:当前树不是左倾红黑树!" << endl;
				exit(-1);
			}
		}
		else
		{
			cout << "插入失败!" << endl;
			exit(-1);
		}
	}

	/*
	for (size_t i = 0; i < seq.size(); ++i)
	{
		cout << "删除" << seq[i] << endl;
		if (obj.deleteAnyKey(seq[i]))
		{
			cout << "删除成功!" << endl;
			if (checkLeftLeaningRBTreeProperty(obj.root))
			{
				cout << "当前树是左倾红黑树" << endl;
			}
			else
			{
				cout << "ERROR:当前树不是左倾红黑树!" << endl;
				exit(-1);
			}
		}
		else
		{
			cout << "删除失败!" << endl;
			exit(-1);
		}
	}*/

	/*for (size_t i = 1; i <= N; ++i)
	{
		cout << "删除最小值" << i << endl;
		if (obj.deleteMin())
		{
			cout << "删除成功!" << endl;
			if (checkLeftLeaningRBTreeProperty(obj.root))
			{
				cout << "当前树是左倾红黑树" << endl;
			}
			else
			{
				cout << "ERROR:当前树不是左倾红黑树!" << endl;
				exit(-1);
			}
		}
		else
		{
			cout << "删除失败!" << endl;
			exit(-1);
		}
	}*/

	for (size_t i = N; i >= 1; --i)
	{
		cout << "删除最大值" << i << endl;
		if (obj.deleteMax())
		{
			cout << "删除成功!" << endl;
			if (checkLeftLeaningRBTreeProperty(obj.root))
			{
				cout << "当前树是左倾红黑树" << endl;
			}
			else
			{
				cout << "ERROR:当前树不是左倾红黑树!" << endl;
				exit(-1);
			}
		}
		else
		{
			cout << "删除失败!" << endl;
			exit(-1);
		}
	}
    return 0;
}

naturerun
关注
【数据结构】6.5 红黑树（C++）
weixin_52811588的博客
04-12 1063
红黑树是一颗近似平衡的二叉搜索树，它的使用非常广泛，所以在面试中经常是一个经典问题，现在让我们来一起学习吧
红黑树总结&C++代码实现
cat_of_landlord的博客
12-09 422
目录红黑树特性旋转左旋右旋插入算法 学红黑树的时候感觉很有意思,所以自己手打了一棵红黑树,这一篇粗浅写一下对红黑树插入删除过程中调整操作的归纳和理解. 红黑树特性 红黑树是一种保证动态平衡的BST，避免了BST退化成线性表。STL中的红黑树也是继承于BST的。因此红黑树的查找和删除等操作与BST类似。 满足以下条件的BST是红黑树： 每个结点要么红要么黑 根节点为黑色 所有扩充结点的外部节点为空，且视为黑色 若一个结点为红，则他的两个子结点为黑（不允许连续红） 结点到其子孙外部结点的每条简单路径都包含相同
C++ 左倾红黑树
nightwizard2030的博客
07-28 607
红黑树中有一种较为简单的查找插入实现，即这篇博文所提到的左倾红黑树 http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html 所谓左倾红黑树，就是在红黑树原有的规则上再加了一条：红色节点向左倾斜，咋一看，这样会使插入删除的实现更为简单，最开始我是这么想的，毕竟都向左倾了，肯定考虑的情况会少很多，所以打算实现一个完整的插入 查找
红黑树(左倾)C++
臻
03-02 232
红黑树的性质： 1.每个结点的链接要么是红的要么是黑的； 2.根结点的链接是黑的； 3.每个叶结点的左右nullptr指针都是黑的； 4.如果一个父节点链接是红的，那么它的两个儿子的链接都是黑的； 5.对于任意结点而言，其到叶结点树尾端到根节点的每条路径都包含相同数目的黑链接。 #include<iostream> #define RED true #define BLACK fals...
数据结构 - 左倾红黑树（2-3-树推广）/ C++实现
Spike的秃头之路
01-12 291
红黑树的“适度平衡”，由AVL树的“高度平衡”，降低到“任意节点左右子树的高度，相差不超过2倍”，也降低了动态操作时调整的频率。对于一颗动态查找树，如果插入和删除操作比较少，查找操作比较多，采用AVL树比较合适，否则采用红黑树更合适。为了保持AVL树的平衡性，插入和删除操作后，非常频繁地调整全树整体拓扑结构，代价较大。上进一步放宽条件，引入红黑树的结构。
红黑树C++实现
Cross
05-23 827
完整实现了一遍红黑树，程序就当作自己的笔记好了红黑树，顾名思义，就是红黑相间的树，它借由红黑规则实现了二叉树的平衡。红黑规则如下：1.每个节点不是红就是黑2.根总是黑色3.若节点为红色，它的子节点必须为黑色4.从根到叶的每条路径，必须包含相同数目的黑色节点插入和删除节点时都要遵循红黑规则，具体表现如下：1.首先所有新插入的节点都为红色2.若新插入的节点的父节点为红色，则必须对红黑树进行调整（1）旋...
红黑树源码java-leftrb:Leftrb是Python中2-3个平衡二叉搜索树的左倾红黑(LLRB)实现。RobertSedgewick
06-06
所有红黑树都基于在二叉树中实现 2-3 或 2-3-4 树，使用红色链接将内部节点绑定到 3 节点或 4 节点。 搜索、插入和删除操作为 O(log n)，空间要求为 O(n)。 然而，许多传统实现在旋转和删除操作的对称分支上有大量...
红黑树实现源码
07-22
红黑树因其高效性能在许多实际应用中得到采用，如C++标准模板库(STL)中的set和map容器，以及Java的TreeMap和TreeSet类。它们使用红黑树作为底层数据结构，提供快速的查找、插入和删除操作。 5. 红黑树的优势： - ...
LLRB：简化红黑树实现与原理探讨
"LLRB（左倾红黑树）是一种红黑树的变种，由Robert Sedgewick提出，旨在实现平衡搜索树。红黑树作为数据结构在各种编程语言如C++、Java、Python以及BSD Unix等系统中广泛应用。尽管它们在标准教材中有描述，但很多...
深入理解左倾红黑树 | 京东物流技术团队
JDDTechTalk的博客
01-04 937
上文我们已经规定，被红链接引用的节点为红色，被黑色链接引用的节点为黑色，我们在节点中添加colorTrue表示红色，Falseint key;int value;Node left;Node right;/*** 判断节点是否为红色*/} else {
数据结构——左倾红黑树
松仔Log的博客
01-26 1583
左倾红黑树左倾红黑树左倾红黑树和2-3树的等价变换网上的错误定义重要代码左右旋转变色递归变色插入删除 左倾红黑树 左倾红黑二叉查找树的基本思想是用标准的二叉查找树(完全由2-结点构成)和一些额外的信息(替换3-结点)来表示2-3树，其和2-3树是等价的 树中的链接分为两种类型：红链接是用一个2-结点左链接另一个2-结点来表示一个3-结点，黑链接则是2-3树当中的普通链接 红链接均为左连接（或者说红节点在左边也行，链接是节点的内部属性） 没有任何一个结点同时和两条红链接相连 该树是完美黑色链接平衡的，即任意
红黑树的实现原理
weixin_30376163的博客
09-01 320
注:本文所有内容均翻译自维基百科，部分内容为原创。 强烈建议阅读文章末尾的参考资料。 一、概述 红黑树是自平衡的二叉搜索树，是计算机科学中的一种数据结构。 平衡是指所有叶子的深度基本相同(完全相等的情况并不多见,所以只能趋向于相等) 。 二叉搜索树是指,节点最多有两个儿子，且左子树中所有节点都小于右子树。 树中节点有改动时,通过调整节点顺序（旋转）,重新给节点染色,使节点满足某种特...
Java左倾红黑树的完整实现
qq_44968886的博客
02-13 345
左红黑树准备知识 一、定义： 1.红链接均为左连接 2.没有任何一个节点同时和两条红链接相连 3.该树是完美黑色平衡的，即任意空连接到根结点的路径上的黑链接数量相等。 二、颜色表示： 示例代码中说一个节点是红色的，指的是指向该链接的颜色是红色的。 代码说明 实现类让参数K继承了Comparable接口，主要原因是红黑树要维持树的平衡就要依赖于两个键的大小关系，而Comparable接口中的comp...
从2-3树谈到左倾红黑树
达的程序员日记
05-23 641
如果红黑树不好理解，不妨先看看左倾红黑树。从2-3树谈到左倾红黑树，可以更好的理解。
红黑树及实现（c语言）
c_living的博客
07-20 5660
本人看的是《算法》这本书，所以红黑树的理解是一下这样的： 个人认为这样比结点标红黑更好理解。很好下面是红黑树的定义： 1、红黑树其实是2-3结点树的二叉平衡表示形式。 2、红链接均为左连接（左倾红黑树） 3、没有任何结点同时连接着两条红链 4、红黑树是完美平衡的，也就是任何空连接（NULL）到根节点经过的黑色分支数量是相等的 其中2、3都是为了维持是2-3树的二叉平衡形式，4、是为...
红黑树进阶—左倾红黑树（LLBR）介绍
666的独角仙的博客
11-20 3346
红黑树已经有很长的历史，在许多现代编程语言的符号表中都有使用，但是其缺点也很明显，其代码实现过于繁杂。因此出现的红黑树的修改版——左倾红黑树 左倾红黑树的代码实现相比于典型的红黑树来说非常简介，但是国内论坛好像并没有一个对于左倾红黑树相对系统的介绍，因此我找到了左倾红黑树的论文并将其整理翻译，以供学习 由于能力有限，因此翻译的时候难免有不准确的地方，因此这个翻译仅供学习参考 ...
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 332
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++ -Binary Search Tree -2
最新发布
2401_86587256的博客
11-01 710
二叉搜索树，插入删除的递归写法
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1038
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值