红黑树

最新推荐文章于 2023-09-01 10:20:18 发布
最新推荐文章于 2023-09-01 10:20:18 发布
阅读量108 收藏
点赞数
分类专栏： 算法导论 紫云的程序人生 文章标签： 红黑树 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xunmeng2002/article/details/115467298
版权

GitHub

红黑树是一棵特殊的二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的。

一棵红黑树是满足下面红黑性质的二叉搜索树：

  1. 每个结点或是红色的，或是黑色的
  2. 根节点是黑色的
  3. 每个叶节点（NIL）是黑色的
  4. 如果一个结点是红色的，则它的两个子结点都是黑色的
  5. 对每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

RedBlackTree.h

#pragma once
#include <iostream>

enum class Color : int
{
	Red = 0,
	Black = 1,
};
std::ostream& operator<<(std::ostream& os, const Color& color);

struct RedBlackTreeNode
{
	RedBlackTreeNode(int key, Color color) :Parent(nullptr), Left(nullptr), Right(nullptr), Key(key), Color(color){ }
	RedBlackTreeNode* Parent;
	RedBlackTreeNode* Left;
	RedBlackTreeNode* Right;

	int Key;
	Color Color;
	void Print();
};

class RedBlackTree
{
public:
	RedBlackTree();
	~RedBlackTree();
	void Report();
	void InorderTreeWalk(RedBlackTreeNode* x);
	void PreorderTreeWalk(RedBlackTreeNode* x);
	void PostorderTreeWalk(RedBlackTreeNode* x);

	RedBlackTreeNode* Minimum(RedBlackTreeNode* x);
	RedBlackTreeNode* Maximum(RedBlackTreeNode* x);

	void Insert(RedBlackTreeNode* z);
	void Delete(RedBlackTreeNode* z);



private:
	void LeftRotate(RedBlackTreeNode* x);
	void RightRotate(RedBlackTreeNode* y);
	void InsertFixUp(RedBlackTreeNode* z);
	void DeleteFixUp(RedBlackTreeNode* z);
	void Transplant(RedBlackTreeNode* u, RedBlackTreeNode* v);

	void Release(RedBlackTreeNode* x);

public:
	RedBlackTreeNode* Root;
	RedBlackTreeNode* Nil;
};

void TestRedBlackTree();

RedBlackTree.cpp

#include "RedBlackTree.h"
#include <iostream>
#include <vector>

using namespace std;

ostream& operator<<(ostream& os, const Color& color)
{
	if (color == Color::Red)
	{
		os << "Red";
	}
	else
	{
		os << "Black";
	}
	return os;
}

void RedBlackTreeNode::Print()
{
	cout << "(" << Key << ": " << Color  << ")  ";
}


RedBlackTree::RedBlackTree()
{
	Nil = new RedBlackTreeNode(0, Color::Black);
	Root = Nil;
}
RedBlackTree::~RedBlackTree()
{
	if (Root != nullptr)
	{
		Release(Root);
	}
	Root = nullptr;
	if (Nil != nullptr)
	{
		delete Nil;
	}
	Nil = nullptr;
}

void RedBlackTree::Report()
{
	cout << "PreorderTreeWalk:\t";
	PreorderTreeWalk(Root);
	cout << endl << "InorderTreeWalk:\t";
	InorderTreeWalk(Root);
	cout << endl << "PostorderTreeWalk:\t";
	PostorderTreeWalk(Root);
	cout << endl;
}
void RedBlackTree::InorderTreeWalk(RedBlackTreeNode* x)
{
	if (x != Nil)
	{
		InorderTreeWalk(x->Left);
		x->Print();
		InorderTreeWalk(x->Right);
	}
}
void RedBlackTree::PreorderTreeWalk(RedBlackTreeNode* x)
{
	if (x != Nil)
	{
		x->Print();
		PreorderTreeWalk(x->Left);
		PreorderTreeWalk(x->Right);
	}
}
void RedBlackTree::PostorderTreeWalk(RedBlackTreeNode* x)
{
	if (x != Nil)
	{
		PostorderTreeWalk(x->Left);
		PostorderTreeWalk(x->Right);
		x->Print();
	}
}

RedBlackTreeNode* RedBlackTree::Minimum(RedBlackTreeNode* x)
{
	while (x->Left != nullptr)
	{
		x = x->Left;
	}
	return x;
}
RedBlackTreeNode* RedBlackTree::Maximum(RedBlackTreeNode* x)
{
	while (x->Right != nullptr)
	{
		x = x->Right;
	}
	return x;
}

void RedBlackTree::Insert(RedBlackTreeNode* z)
{
	auto x = Root;
	RedBlackTreeNode* y = Nil;
	while (x != Nil)
	{
		y = x;
		if (z->Key < x->Key)
		{
			x = x->Left;
		}
		else
		{
			x = x->Right;
		}
	}
	z->Parent = y;
	if (y == Nil)
	{
		Root = z;
	}
	else if (z->Key < y->Key)
	{
		y->Left = z;
	}
	else
	{
		y->Right = z;
	}
	z->Left = Nil;
	z->Right = Nil;
	z->Color = Color::Red;
	InsertFixUp(z);
}
void RedBlackTree::Delete(RedBlackTreeNode* z)
{
	RedBlackTreeNode* x = nullptr;
	auto y = z;
	auto y_original_color = y->Color;
	if (z->Left == Nil)
	{
		x = z->Right;
		Transplant(z, z->Right);
	}
	else if (z->Right == Nil)
	{
		x = z->Left;
		Transplant(z, z->Left);
	}
	else
	{
		y = Minimum(z->Right);
		y_original_color = y->Color;
		x = y->Right;
		if (y->Parent != z)
		{
			Transplant(y, y->Right);
			y->Right = z->Right;
			y->Right->Parent = y;
		}
		Transplant(z, y);
		y->Left = z->Left;
		y->Left->Parent = y;
		y->Color = z->Color;
	}
	if (y_original_color == Color::Black)
	{
		DeleteFixUp(x);
	}
}

void RedBlackTree::LeftRotate(RedBlackTreeNode* x)
{
	auto y = x->Right;
	x->Right = y->Left;
	if (y->Left != Nil)
	{
		y->Left->Parent = x;
	}
	y->Parent = x->Parent;
	if (x->Parent == Nil)
	{
		Root = y;
	}
	else if(x == x->Parent->Left)
	{
		x->Parent->Left = y;
	}
	else
	{
		x->Parent->Right = y;
	}
	y->Left = x;
	x->Parent = y;
}
void RedBlackTree::RightRotate(RedBlackTreeNode* y)
{
	auto x = y->Left;
	y->Left = x->Right;
	if (x->Right != Nil)
	{
		x->Right->Parent = y;
	}
	x->Parent = y->Parent;
	if (y->Parent == Nil)
	{
		Root = x;
	}
	else if (y == y->Parent->Left)
	{
		y->Parent->Left = x;
	}
	else
	{
		y->Parent->Right = x;
	}
	x->Right = y;
	y->Parent = x;
}
void RedBlackTree::InsertFixUp(RedBlackTreeNode* z)
{
	while (z->Parent->Color == Color::Red)
	{
		if (z->Parent == z->Parent->Parent->Left)
		{
			auto y = z->Parent->Parent->Right;
			if (y->Color == Color::Red)
			{
				z->Parent->Color = Color::Black;
				y->Color = Color::Black;
				z->Parent->Parent->Color = Color::Red;
				z = z->Parent->Parent;
			}
			else
			{
				if (z == z->Parent->Right)
				{
					z = z->Parent;
					LeftRotate(z);
				}
				z->Parent->Color = Color::Black;
				z->Parent->Parent->Color = Color::Red;
				RightRotate(z->Parent->Parent);
			}
		}
		else
		{
			auto y = z->Parent->Parent->Left;
			if (y->Color == Color::Red)
			{
				z->Parent->Color = Color::Black;
				y->Color = Color::Black;
				z->Parent->Parent->Color = Color::Red;
				z = z->Parent->Parent;
			}
			else
			{
				if (z == z->Parent->Left)
				{
					z = z->Parent;
					RightRotate(z);
				}
				z->Parent->Color = Color::Black;
				z->Parent->Parent->Color = Color::Red;
				LeftRotate(z->Parent->Parent);
			}
		}
	}
	Root->Color = Color::Black;
}
void RedBlackTree::DeleteFixUp(RedBlackTreeNode* x)
{
	while (x != Root && x->Color == Color::Black)
	{
		if (x == x->Parent->Left)
		{
			auto w = x->Parent->Right;
			if (w->Color == Color::Red)					//case 1	=> case 2、3、4
			{
				w->Color = Color::Black;
				x->Parent->Color = Color::Red;
				LeftRotate(x->Parent);
			}
			else // w->Color == Color::Black
			{
				if (w->Left->Color == Color::Black && w->Right->Color == Color::Black)		//case 2
				{
					w->Color = Color::Red;
					x = x->Parent;
				}
				else if (w->Right->Color == Color::Black)		//case 3
				{
					w->Left->Color = Color::Black;
					w->Color = Color::Red;
					RightRotate(w);
				}
				else //w->Right->Color == Color::Red			//case 4
				{
					w->Color = x->Parent->Color;
					x->Parent->Color = Color::Black;
					w->Right->Color = Color::Black;
					LeftRotate(x->Parent);
					x = Root;
				}
			}
		}
		else
		{
			auto w = x->Parent->Left;
			if (w->Color == Color::Red)
			{
				w->Color = Color::Black;
				x->Parent->Color = Color::Red;
				RightRotate(x->Parent);
}
			else // w->Color == Color::Black
			{
				if (w->Left->Color == Color::Black && w->Right->Color == Color::Black)
				{
					w->Color = Color::Red;
					x = x->Parent;
				}
				else if (w->Left->Color == Color::Black)
				{
					w->Right->Color = Color::Black;
					w->Color = Color::Red;
					LeftRotate(w);
				}
				else // w->Left->Color == Color::Red
				{
					w->Color = x->Parent->Color;
					x->Parent->Color = Color::Black;
					w->Left->Color = Color::Black;
					RightRotate(x->Parent);
					x = Root;
				}
			}
		}
	}
	x->Color = Color::Black;
}
void RedBlackTree::Transplant(RedBlackTreeNode* u, RedBlackTreeNode* v)
{
	if (u->Parent == Nil)
	{
		Root = v;
	}
	else if (u == u->Parent->Left)
	{
		u->Parent->Left = v;
	}
	else
	{
		u->Parent->Right = v;
	}
	
	v->Parent = u->Parent;
}

void RedBlackTree::Release(RedBlackTreeNode* x)
{
	if (x != Nil)
	{
		Release(x->Left);
		Release(x->Right);
		delete x;
	}
}

void TestRedBlackTree()
{
	vector<RedBlackTreeNode*> nodes;
	for (auto i = 0; i < 15; i++)
	{
		nodes.push_back(new RedBlackTreeNode(i, Color::Red));
	}

	RedBlackTree* tree = new RedBlackTree();
	for (auto node : nodes)
	{
		tree->Insert(node);
		tree->Report();
	}
	
	for (auto node : nodes)
	{
		tree->Delete(node);
		tree->Report();
	}


}

输出：

PreorderTreeWalk:       (0: Black)
InorderTreeWalk:        (0: Black)
PostorderTreeWalk:      (0: Black)
PreorderTreeWalk:       (0: Black)  (1: Red)
InorderTreeWalk:        (0: Black)  (1: Red)
PostorderTreeWalk:      (1: Red)  (0: Black)
PreorderTreeWalk:       (1: Black)  (0: Red)  (2: Red)
InorderTreeWalk:        (0: Red)  (1: Black)  (2: Red)
PostorderTreeWalk:      (0: Red)  (2: Red)  (1: Black)
PreorderTreeWalk:       (1: Black)  (0: Black)  (2: Black)  (3: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Red)
PostorderTreeWalk:      (0: Black)  (3: Red)  (2: Black)  (1: Black)
PreorderTreeWalk:       (1: Black)  (0: Black)  (3: Black)  (2: Red)  (4: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Red)  (3: Black)  (4: Red)
PostorderTreeWalk:      (0: Black)  (2: Red)  (4: Red)  (3: Black)  (1: Black)
PreorderTreeWalk:       (1: Black)  (0: Black)  (3: Red)  (2: Black)  (4: Black)  (5: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Red)  (4: Black)  (5: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (5: Red)  (4: Black)  (3: Red)  (1: Black)
PreorderTreeWalk:       (1: Black)  (0: Black)  (3: Red)  (2: Black)  (5: Black)  (4: Red)  (6: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Red)  (4: Red)  (5: Black)  (6: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (4: Red)  (6: Red)  (5: Black)  (3: Red)  (1: Black)
PreorderTreeWalk:       (3: Black)  (1: Red)  (0: Black)  (2: Black)  (5: Red)  (4: Black)  (6: Black)  (7: Red)
InorderTreeWalk:        (0: Black)  (1: Red)  (2: Black)  (3: Black)  (4: Black)  (5: Red)  (6: Black)  (7: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Red)  (4: Black)  (7: Red)  (6: Black)  (5: Red)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Red)  (0: Black)  (2: Black)  (5: Red)  (4: Black)  (7: Black)  (6: Red)  (8: Red)
InorderTreeWalk:        (0: Black)  (1: Red)  (2: Black)  (3: Black)  (4: Black)  (5: Red)  (6: Red)  (7: Black)  (8: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Red)  (4: Black)  (6: Red)  (8: Red)  (7: Black)  (5: Red)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Black)  (0: Black)  (2: Black)  (5: Black)  (4: Black)  (7: Red)  (6: Black)  (8: Black)  (9: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Black)  (4: Black)  (5: Black)  (6: Black)  (7: Red)  (8: Black)  (9: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Black)  (4: Black)  (6: Black)  (9: Red)  (8: Black)  (7: Red)  (5: Black)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Black)  (0: Black)  (2: Black)  (5: Black)  (4: Black)  (7: Red)  (6: Black)  (9: Black)  (8: Red)  (10: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Black)  (4: Black)  (5: Black)  (6: Black)  (7: Red)  (8: Red)  (9: Black)  (10: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Black)  (4: Black)  (6: Black)  (8: Red)  (10: Red)  (9: Black)  (7: Red)  (5: Black)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Black)  (0: Black)  (2: Black)  (7: Black)  (5: Red)  (4: Black)  (6: Black)  (9: Red)  (8: Black)  (10: Black)  (11: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Black)  (4: Black)  (5: Red)  (6: Black)  (7: Black)  (8: Black)  (9: Red)  (10: Black)  (11: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Black)  (4: Black)  (6: Black)  (5: Red)  (8: Black)  (11: Red)  (10: Black)  (9: Red)  (7: Black)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Black)  (0: Black)  (2: Black)  (7: Black)  (5: Red)  (4: Black)  (6: Black)  (9: Red)  (8: Black)  (11: Black)  (10: Red)  (12: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Black)  (4: Black)  (5: Red)  (6: Black)  (7: Black)  (8: Black)  (9: Red)  (10: Red)  (11: Black)  (12: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Black)  (4: Black)  (6: Black)  (5: Red)  (8: Black)  (10: Red)  (12: Red)  (11: Black)  (9: Red)  (7: Black)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Black)  (0: Black)  (2: Black)  (7: Red)  (5: Black)  (4: Black)  (6: Black)  (9: Black)  (8: Black)  (11: Red)  (10: Black)  (12: Black)  (13: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Black)  (4: Black)  (5: Black)  (6: Black)  (7: Red)  (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Black)  (13: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Black)  (4: Black)  (6: Black)  (5: Black)  (8: Black)  (10: Black)  (13: Red)  (12: Black)  (11: Red)  (9: Black)  (7: Red)  (3: Black)
PreorderTreeWalk:       (3: Black)  (1: Black)  (0: Black)  (2: Black)  (7: Red)  (5: Black)  (4: Black)  (6: Black)  (9: Black)  (8: Black)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (0: Black)  (1: Black)  (2: Black)  (3: Black)  (4: Black)  (5: Black)  (6: Black)  (7: Red)  (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (0: Black)  (2: Black)  (1: Black)  (4: Black)  (6: Black)  (5: Black)  (8: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)  (7: Red)  (3: Black)
PreorderTreeWalk:       (7: Black)  (3: Black)  (1: Black)  (2: Red)  (5: Red)  (4: Black)  (6: Black)  (9: Black)  (8: Black)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (1: Black)  (2: Red)  (3: Black)  (4: Black)  (5: Red)  (6: Black)  (7: Black)  (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (2: Red)  (1: Black)  (4: Black)  (6: Black)  (5: Red)  (3: Black)  (8: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)  (7: Black)
PreorderTreeWalk:       (7: Black)  (3: Black)  (2: Black)  (5: Red)  (4: Black)  (6: Black)  (9: Black)  (8: Black)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (2: Black)  (3: Black)  (4: Black)  (5: Red)  (6: Black)  (7: Black)  (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (2: Black)  (4: Black)  (6: Black)  (5: Red)  (3: Black)  (8: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)  (7: Black)
PreorderTreeWalk:       (7: Black)  (5: Black)  (3: Black)  (4: Red)  (6: Black)  (9: Black)  (8: Black)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (3: Black)  (4: Red)  (5: Black)  (6: Black)  (7: Black)  (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (4: Red)  (3: Black)  (6: Black)  (5: Black)  (8: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)  (7: Black)
PreorderTreeWalk:       (7: Black)  (5: Black)  (4: Black)  (6: Black)  (9: Black)  (8: Black)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (4: Black)  (5: Black)  (6: Black)  (7: Black)  (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (4: Black)  (6: Black)  (5: Black)  (8: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)  (7: Black)
PreorderTreeWalk:       (9: Black)  (7: Black)  (5: Black)  (6: Red)  (8: Black)  (11: Black)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (5: Black)  (6: Red)  (7: Black)  (8: Black)  (9: Black)  (10: Black)  (11: Black)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (6: Red)  (5: Black)  (8: Black)  (7: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Black)  (9: Black)
PreorderTreeWalk:       (9: Black)  (7: Black)  (6: Black)  (8: Black)  (11: Black)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (6: Black)  (7: Black)  (8: Black)  (9: Black)  (10: Black)  (11: Black)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (6: Black)  (8: Black)  (7: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Black)  (9: Black)
PreorderTreeWalk:       (9: Black)  (7: Black)  (8: Red)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (7: Black)  (8: Red)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (8: Red)  (7: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)
PreorderTreeWalk:       (9: Black)  (8: Black)  (11: Red)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (8: Black)  (9: Black)  (10: Black)  (11: Red)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (8: Black)  (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Red)  (9: Black)
PreorderTreeWalk:       (11: Black)  (9: Black)  (10: Red)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (9: Black)  (10: Red)  (11: Black)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (10: Red)  (9: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Black)
PreorderTreeWalk:       (11: Black)  (10: Black)  (13: Black)  (12: Red)  (14: Red)
InorderTreeWalk:        (10: Black)  (11: Black)  (12: Red)  (13: Black)  (14: Red)
PostorderTreeWalk:      (10: Black)  (12: Red)  (14: Red)  (13: Black)  (11: Black)
PreorderTreeWalk:       (13: Black)  (11: Black)  (12: Red)  (14: Black)
InorderTreeWalk:        (11: Black)  (12: Red)  (13: Black)  (14: Black)
PostorderTreeWalk:      (12: Red)  (11: Black)  (14: Black)  (13: Black)
PreorderTreeWalk:       (13: Black)  (12: Black)  (14: Black)
InorderTreeWalk:        (12: Black)  (13: Black)  (14: Black)
PostorderTreeWalk:      (12: Black)  (14: Black)  (13: Black)
PreorderTreeWalk:       (13: Black)  (14: Red)
InorderTreeWalk:        (13: Black)  (14: Red)
PostorderTreeWalk:      (14: Red)  (13: Black)
PreorderTreeWalk:       (14: Black)
InorderTreeWalk:        (14: Black)
PostorderTreeWalk:      (14: Black)
PreorderTreeWalk:
InorderTreeWalk:
PostorderTreeWalk:

E:\GitHub\IntroductionToAlgorithms\C++\build\Debug\IntroductionToAlgorithms.exe (进程 29540)已退出，代码为 0。
要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
按任意键关闭此窗口. . .

 

梦李寻欢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对红黑树的认识总结
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 19万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++红黑树
~
03-26 6489
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
红黑树527378231
最新发布
06-06
红黑树527378231
C++ 使用OpenSSL
xunmeng2002的专栏
09-04 1万+
最近在研究C++使用OpenSSL，前面的文章介绍了编译OpenSSL源码的过程，这里随便写下加密解密的用法。 MD5： #include &lt;openssl\md5.h&gt; #include &lt;iostream&gt; using namespace std; int md5_encrypt(const void* data, size_t len, unsigned ch...
C++ Unicode、Utf8、GBK编码之间转换
xunmeng2002的专栏
06-09 2692
C++标准库从C++11开始提供了std::codecvt_utf8和std::codecvt_byname两个转换器来完成编码转换，其中std::codecvt_utf8用于 utf8编码与unicode之间的转换，GBK与unicode之间的转换则需要通过std::codecvt_byname 来完成，并需要指定locale_name参数，此参数windows与linux下并不相同。
Ubuntu 安装MysqlConnector
xunmeng2002的专栏
11-14 2054
回到下载首页，能看到跟community相关的有一个 Mysql Community Server，点进去后选好操作系统与版本号，搜了一下，找到了 mysql-community-client-plugins 的下载包：mysql-community-client-plugins_8.0.31-1ubuntu20.04_amd64.deb。一个成功了，一个失败。然而在刚才的下载页面没有找到 mysql-community-client-plugins 的相关下载。编译、链接、运行结果都正确。
矩阵类设计
xunmeng2002的专栏
03-24 1888
用C++类封装了一个矩阵的类，实现了加、减和乘法的运算符重载，同时复习了一遍拷贝、移动等构造函数和赋值运算符的重载。 Matrix.h #pragma once #include <stdio.h> #include <iostream> template<typename T> class Matrix { public: Matrix() { Row = Column = 0; Item = nullptr; } Matrix(int row,
WPF 数据验证
xunmeng2002的专栏
08-29 1644
可以在设置属性时抛出异常，通常WPF会忽略所有在设置属性时抛出的异常，但可以进行配置，从而显示更有帮助的可视化指示。使用装饰层，可添加可视化装饰来指示错误，而不用替换控件背后的控件模板或改变窗口的布局。如果需要执行对两个或更多个绑定值的验证，可以通过 BindingGroup 来实现，将需要校验的多个控件放置于同一个容器中，在容器级别应用验证规则，需要通过事件主动触发验证，通常是子组件失去焦点时。更好的是，因为是在不同类中定义验证，可以很容易的在存储类似数据类型的多个绑定中重用验证。
WPF数据视图
xunmeng2002的专栏
09-01 1509
例如，可将同一个集合绑定到两个不同的列表，并对集合进行过滤以显示不同的记录。我实测下来，绑定自同一个数据源的ItemsControl控件会共享一个View，当对该View进行筛选、排序时，会应用到所有绑定到该数据源的控件。将集合绑定到ItemsControl控件时，会不加通告的在后台创建数据视图——位于数据源和绑定的控件之间。数据视图是进入数据源的窗口，可以跟踪当前项，并且支持各种功能，如排序、过滤、分组。可以看到，可以直接通过数据源来获取视图，这也表明，绑定到同一个数据源的控件会公用一个视图。
C++单元测试
xunmeng2002的专栏
07-16 1428
最近写了一个的C++单元测试工具，在这里分享一下对测试用例（TestCase）的定义。 其中用到的MDB是用C++写的内存数据库，ExpectMDB则是一个仅用set容器实现的简化版的数据库。 测试用例的执行函数是一个返回值为bool类型的无参函数，测试用例执行完后的数据在MDB中，对执行结果的期望数据，通过CSV文件导入到ExpectMDB中，通过check_mdb_tables对两者中每个...
WPF列表样式
xunmeng2002的专栏
08-30 1265
WPF的数据绑定系统自动生成列表项对象，为单个项应用所需的样式不是很容易。如果设置了ItemContainerStyle 属性，当创建列表项时，列表控件会将其向下传递给每个项。对于ListBox控件，每个项有ListBoxItem 对象表示，对于CombBox 控件，则对应是 CombBoxItem。可以使用样式选择器来为不同的子项提供不同的样式，自定义样式选择器需要继承自 StyleSelector 类，需要重写 SelectStyle() 方法。也可以直接将样式设置到ListBox层次。
WPF数据转换
xunmeng2002的专栏
08-30 1238
多重绑定的值转换器需要实现的接口是 IMultiValueConverter，与 IValueConverter 接口比较类似，只是转换函数的第一个参数改成了数组形式。可以看到后面两个StringFormat属性以花括号 {} 开头，完整值是 {}{0:C}，而不是 {0:C}，第一个则只有 {0:C}，这是因为在StringFormat 值以花括号开头时需要 {} 转义序列。该功能更强大，使用该功能可以将任意类型的源数据转换为任意类型的对象表示，然后可以传递到关联的控件。
WPF使用依赖注入
xunmeng2002的专栏
08-22 1207
在使用依赖注入后，我发现在App里面完成一些初始化内容更合适，包括MainWindow也通过容器生成，需要注意的是，记得把App.xaml中的 StartupUri更改为 Startup，并把值改为自定义的启动函数，在启动函数里面调用MainWindow的Show方法。现在依赖注入在.Net里面已经普及，自己常写一些简单的demo倒是无所谓，但偶尔写一点正式的工程，也免不了要使用一下，于是总结了一下在WPF里面使用依赖注入。
openssl编译
xunmeng2002的专栏
09-04 1102
下载openssl源码 https://www.openssl.org/source/ 这里选择的版本是1.1.0i openSSL的编译要用activeperl 下载activeperlhttp://www.activestate.com/activeperl nasm OpenSSL编译需要nasm(http://www.nasm.us), 下载并安装， 将nasm.exe加入...
深入解析红黑树数据结构
"教你透彻了解红黑树" 红黑树是一种自平衡的二叉查找树，它的设计目标是在保持查找效率的同时，通过特定的规则保证树的平衡，从而优化插入和删除操作的时间复杂度。红黑树的名字来源于其节点颜色属性，每个节点可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值