红黑树2 完结

最新推荐文章于 2021-11-03 18:07:12 发布
最新推荐文章于 2021-11-03 18:07:12 发布
阅读量96 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/under_control/article/details/120187280

// 红黑树2.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
//
//
//#include
//
//int main()
//{
// std::cout << “Hello World!\n”;
//}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧:
// 1. 使用解决方案资源管理器窗口添加/管理文件
// 2. 使用团队资源管理器窗口连接到源代码管理
// 3. 使用输出窗口查看生成输出和其他消息
// 4. 使用错误列表窗口查看错误
// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

#include
using namespace std;
//map 和set
template
struct RBNode
{
typedef bool color;
RBNode* _parent;
RBNode* _left;
RBNode* _right;
//key-value
//键值对出现的。
v _val;
//颜色
COLOR _color;

RBNode(const v& val = v())
	:_parent(nullptr)
	, _left(nullptr)
	, _right(nullptr)
	, _kv(kv)
	, _color(RED)
{}

};

template <class k, class v,class keyofvalue>
class RBTree
{
typedef RBTree Node;

RBTree()
	:_header(new Node)
{
	//创建头结点。
	//创建的就是结构的方便是为了解决的是迭代器的实现
	//创建空树
		//类似于之前带头的循环链表的结构。
	_header->_left = _header->_right = _header;
}
//红黑树的插入的时候就是主要是红的不能连续。
bool insert(const v& v)
{
	//1.搜索树的插入
		//空树：_header->_parent:nullptr
	if (_header->_parent == nullptr)
	{
		//创建根节点
		Node* root = new Node(v);

		_header->_parent = root;
		root->_parent = _header;
		_header->_left = _header->_right = root;

		//设置根节点是黑色
		root->_color = BLACK;
		return true;
	}
	//从根节点开始搜索
	Node* cur = _header->_parent;
	Node* parent = nullptr;
	keyofvalue kov;
	while (cur)
	{
		parent = cur;
		//和key值进行比较
		//if (cur->_val.first == val.first)
		if(kov(cur->_val)==kov(val))
		{
			//key 是不能重复的
			return false;
		}
		//else if (cur->_val.first > val.first)
		else if(kov(cur->val)>kov(cur->val))
		{
			cur = cur->_left;
		}
		else
		{
			cur = cur->_right;
		}
	}
	//创建待插入的节点
	cur = new Node(val);
	if (parent->_val.first > cur->_val.first)
		parent->_left = cur;
	else
		parent->_right = cur;
	cur->_parent = parent;
	//2.修改颜色或者调整结构
	//是否有红色连续的节点
	while (cur != _header->_parent&&cur->_parent->_color == RED)
	{
		parent = cur->_parent;
		Node* gfather = parent->_parent;

		if (gfather->_left == parent)
		{
			Node* uncle = gfather->_right;
			//1.uncle存在的，并且是红色的
			if (uncle&&uncle->_color == RED)
			{
				parent->_color = uncle->_color = BLACK;
				gfather->_color = RED;
				//继续更新
				cur = gfather;
			}
		}
		else
		{
			//判断是否是双旋场景
			if (cur == parent->_right)
			{
				//左旋
				RotateL(parent)
					//交换cur,parent指向，退化成右旋的场景
					swap(cur, parent);
			}
			//右旋
			RotateR(gfather);
			parent->_color = BLACK;
			gfather->_color = RED;
			break;
		}
	}
	else
	{
		//gfather->right=parent
		//判断是否是双旋场景
		//如果是那就是右左双旋
		Node* uncle = gfather->_left;
		if (uncle&&uncle->_color == RED)
		{
			parent->_color = uncle->_color = BLACK;
			gfather->_color = RED;
			cur = gfather;
		}
		else
		{
			if (cur == parent->_left)
			{
				//右旋
				RotateR(parent)
					//交换cur,parent指向，退化成右旋的场景
					swap(cur, parent);
			}
			//左旋
			RotateL(parent);
			parent->_color = BLACK;
			gfather->_color = RED;
			break;
		}
	}
	//根节点的颜色改成黑色
	_header->_parent->_color = BLACK;
	//更新header的左右指向
	_header->_left = leftMost();
	_header->_right = rightMost();
}

//左旋转
//parent
//               subR
//     subRL
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	subR->_left = parent;
	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;
	//判断根
	if (parent == _header->_parent)
	{
		_header->_parent = subR;
		subR->_parent = _header;
	}
	else
	{
		Node* pparent = parent->_parent;
		if (pparent->_left = parent)
			pparent->_left = subR;
		else
			pparent->_right = subR;
		subR->_parent = pparent;
	}
	parent->_parent = subR;
}
//右旋转
//位置关系
//                parent
//subL
//           subLR
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	subL->_right = subLR;
	parent->_left = subL;
	if (subLR)
		subLR->_parent = parent;
	//判断根
	if (parent == _header->_parent)
	{
		_header->_parent = subL;
		subL->_parent = _header;
	}
	else
	{
		Node* pparent = parent->_parent;
		if (pparent->_left == parent)
			pparent->_left = subL;
		else
			pparent->_right == subL;
		subL->_parent = pparent;

	}
	parent->_parent = subL;
}

void inorder()
{
	_inorder(_header->_parent)
		cout << endl;
}
void _inorder(Node* root)
{
	if (root)
	{
		_inorder(root->_left);
		cout << root->_kv.first << " ";
		_inorder(root->_right);
	}
}
Node* leftMost()
{
	Node* cur = _header->_parent;
	while (cur&&cur->_right)
	{
		cur = cur->_right;
	}
	return cur;
}
//红黑树：
//1.根：黑色
//2.每条路径黑色个数相同
//3.红色不能相同
//成员：header
bool isBalance()
{
	if (_header->_parent == nullptr)
		return true;
	Node* root = _header->_parent;

	if (root->_color == RED)
		return false;
	//统计一条路径上的黑色结点的个数
	int bCount = 0;
	Node* cur = root;
	while (cur)
	{
		if (cur->_color == BLACK)
			++bCount;
		cur = cur->_left;
	}

	//遍历每一条路径
	int curBCount = 0;
	return isBalance(root, bCount, curBCount);
}

bool _isBalance(Node* root, int& bCount, int curBCount)
{
	//当root为空时，一条路径遍历结束
	if (root == nullptr)
	{
		//判断和黑色结点个数是否相同
		if (curBCount != bCount)
			return false;
		else
			return true;
	}
	//判断当前节点是否是黑色
	if (root->_color == BLACK)
		++curBCount;

	//判断是否有红色连续的节点
	if (root->_parent&&root->_color == RED && root->_parent->_color == RED)

	{
		cout << "data:" << root->_kv.first << endl;
		return false;
	}
	return _isBalance(root->_left, bCount, curBCount) && _isBalance(root->_right, bCount, curBCount);
}

private:
Node* _header;
};

//map实现
template <class k,class T>
class Map
{
struct MapkeyofValue
{
const K& operator() (const pair<k,v>& val)
};

public:
bool insert(const pair<k, T>& kv)
{
_rbt.insert(kv);
}
v& operator[](const pair<k, v>& kv)
{
bool
}
private:
typedef RBTree<k, pair<k, T>> rbt;
rbt _rbt;
};

//set 实现
template
class set
{
public:
bool insert(const pair<k, T>& kv)
{
_rbt.insert(kv);
}

private:
typedef RBTree<k, pair<k, T>> rbt;
rbt _rbt;
};
void test()
{
Map<int, int> m;
m.insert(make_pair(1, 1));
m.insert(make_pair(1, 1));
m.insert(make_pair(1, 1));
}

int main()
{
test();
return 0;

}

//红黑树
//双旋就是表示的是高度差是不在一边的操作。例如是左边的右边高之类的。
//每条路径上黑色个数是相同的。

#include
#include
using namespace std;
//使用的是内置类型颜色
enum COLOR
{
BLACK,
RED
}

template <class k, class v>
struct RBNode
{
typedef bool color;
RBNode<k, v>* _parent;
RBNode<k, v>* _left;
RBNode<k, v>* _right;
//key-value
//键值对出现的。
pair<k,v> _kv;
//颜色
COLOR _color;

RBNode(const pair<k, v>& kv = pair<k, v>())
	:_parent(nullptr)
	, _left(nullptr)
	, _right(nullptr)
	, _kv(kv)
	, _color(RED)
{}

};

template <class k,class v>
class RBTree
{
typedef RBTree<k, v> Node;

RBTree()
	:_header(new Node)
{
//创建头结点。
//创建的就是结构的方便是为了解决的是迭代器的实现
//创建空树
	//类似于之前带头的循环链表的结构。
	_header->_left = _header->_right = _header;
}
//红黑树的插入的时候就是主要是红的不能连续。
bool insert(const pair<k, v>& kv)
{
//1.搜索树的插入
	//空树：_header->_parent:nullptr
	if (_header->_parent == nullptr)
	{
		//创建根节点
		Node* root = new Node(kv);

		_header->_parent = root;
		root->_parent = _header;
		_header->_left = _header->_right = root;

		//设置根节点是黑色
		root->_color = BLACK;
		return true;
	}
	//从根节点开始搜索
	Node* cur = _header->_parent;
	Node* parent = nullptr;
	while (cur)
	{
		parent = cur;
		//和key值进行比较
		if (cur->_kv.first == kv.first)
		{
			//key 是不能重复的
			return false;
		}
		else if (cur->_kv.first > kv.first)
		{
			cur = cur->_left;
		}
		else
		{
			cur = cur->_right;
		}
	}
	//创建待插入的节点
	cur = new Node(kv);
	if (parent->_kv.first > cur->_kv.first)
		parent->_left = cur;
	else
		parent->_right = cur;
	cur->_parent = parent;
	//2.修改颜色或者调整结构
	//是否有红色连续的节点
	while (cur != _header->_parent&&cur->_parent->_color == RED)
	{
		parent = cur->_parent;
		Node* gfather = parent->_parent;

		if (gfather->_left == parent)
		{
			Node* uncle = gfather->_right;
			//1.uncle存在的，并且是红色的
			if (uncle&&uncle->_color == RED)
			{
				parent->_color = uncle->_color = BLACK;
				gfather->_color = RED;
				//继续更新
				cur = gfather;
			}
		}
		else
		{
			//判断是否是双旋场景
			if (cur == parent->_right)
			{
				//左旋
				RotateL(parent)
					//交换cur,parent指向，退化成右旋的场景
				swap(cur, parent);
			}
			//右旋
			RotateR(gfather);
			parent->_color = BLACK;
			gfather->_color = RED;
			break;
		}
	}
	else
	{
		//gfather->right=parent
		//判断是否是双旋场景
		//如果是那就是右左双旋
		Node* uncle = gfather->_left;
		if (uncle&&uncle->_color == RED)
		{
			parent->_color = uncle->_color = BLACK;
			gfather->_color = RED;
			cur = gfather;
		}
		else
		{
      if (cur == parent->_left)
		{
			//右旋
			RotateR(parent)
				//交换cur,parent指向，退化成右旋的场景
				swap(cur, parent);
		}
       //左旋
		RotateL(parent);
		parent->_color = BLACK;
		gfather->_color = RED;
		break;
		}
	}
	//根节点的颜色改成黑色
	_header->_parent->_color = BLACK;
	//更新header的左右指向
	_header->_left = leftMost();
	_header->_right = rightMost();
}

//左旋转
//parent
//               subR
//     subRL
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	subR->_left = parent;
	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;
	//判断根
	if (parent == _header->_parent)
	{
		_header->_parent = subR;
		subR->_parent = _header;
	}
	else
	{
		Node* pparent = parent->_parent;
		if (pparent->_left = parent)
			pparent->_left = subR;
		else
			pparent->_right = subR;
		subR->_parent = pparent;
	}
	parent->_parent = subR;
}
//右旋转
//位置关系
//                parent
//subL
//           subLR
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	subL->_right = subLR;
	parent->_left = subL;
	if (subLR)
		subLR->_parent = parent;
	//判断根
	if (parent == _header->_parent)
	{
		_header->_parent = subL;
		subL->_parent = _header;
	}
	else
	{
		Node* pparent = parent->_parent;
		if (pparent->_left == parent)
			pparent->_left = subL;
		else
			pparent->_right == subL;
		subL->_parent = pparent;

	}
	parent->_parent = subL;
}

void inorder()
{
	_inorder(_header->_parent)
		cout << endl;
}
void _inorder(Node* root)
{
	if (root)
	{
		_inorder(root->_left);
		cout << root->_kv.first << " ";
		_inorder(root->_right);
	}
}
Node* leftMost()
{
	Node* cur = _header->_parent;
	while (cur&&cur->_right)
	{
		cur = cur->_right;
	}
	return cur;
}
//红黑树：
//1.根：黑色
//2.每条路径黑色个数相同
//3.红色不能相同
//成员：header
bool isBalance()
{
	if (_header->_parent == nullptr)
		return true;
	Node* root = _header->_parent;

	if (root->_color == RED)
		return false;
	//统计一条路径上的黑色结点的个数
	int bCount = 0;
	Node* cur = root;
	while (cur)
	{
		if (cur->_color == BLACK)
			++bCount;
		cur = cur->_left;
	}

	//遍历每一条路径
	int curBCount = 0;
	return isBalance(root, bCount, curBCount);
}

bool _isBalance(Node* root, int& bCount, int curBCount)
{
//当root为空时，一条路径遍历结束
	if (root == nullptr)
	{
		//判断和黑色结点个数是否相同
		if (curBCount != bCount)
			return false;
		else
			return true;
	}
	//判断当前节点是否是黑色
	if (root->_color == BLACK)
		++curBCount;

	//判断是否有红色连续的节点
	if (root->_parent&&root->_color == RED && root->_parent->_color == RED)

	{
		cout << "data:" << root->_kv.first << endl;
		return false;
	}
	return _isBalance(root->_left, bCount, curBCount) && _isBalance(root->_right, bCount, curBCount);
}
private:
	Node* _header;

};

void test()
{
RBTree<int, int> rbt;
rbt.insert(make_pair(10, 10));
rbt.insert(make_pair(15, 15));
rbt.insert(make_pair(5, 5));
rbt.insert(make_pair(2, 2));
}

void test1()
{
RBTree<int, int> rbt;
int n;
cin >> n;
for (int i = n; i > 0; --i)
{
rbt.insert(make_pair(i, i));
}
rbt.inorder();
cout << rbt.isBalance() << endl;
}
int main()
{

test();
test1();
return 0;

}

红黑树与2-3树：插入、删除操作的时间复杂度与实现机制比较
一键难忘的博客
11-03 2879
红黑树是一种平衡二叉查找树，其节点具有颜色属性（红色或黑色）。通过一系列规则来确保树的平衡性，红黑树的最大高度是 (2 \log(n)) 级别，从而保证了查找、插入和删除操作的时间复杂度为 (O(\log n))。节点是红色或黑色。根节点是黑色。所有叶节点（NIL）是黑色。红色节点的子节点必须是黑色（即不存在两个相连的红色节点）。从任一节点到其所有叶节点的每条路径都包含相同数量的黑色节点。2-3树是一种B树的特例，其中每个节点可以包含2个或3个子节点。
如果你看不懂KMP算法，那就看一看这篇文章( 绝对原创，绝对通俗易懂)
Stay Hungry,Stay Foolish
03-09 2万+
KMP算法之浅显易懂的阐述！
Leecode第五题——最小回文子串
whose_shepherd的博客
09-14 851
给你一个字符串 s，找到 s 中最长的回文子串。 示例 1： 输入：s = “babad” 输出：“bab” 解释：“aba” 同样是符合题意的答案。 这道题可以使用动态规划，核心思想在于这次不是一个一个字节的往上加的动态规划，单个字节的动态规划找不到合适的max（res[i-1]，res[i…]+A[i]） 因为每个字节进行判断是需要和对照位置的字符串里的字节相同后才能增长回文子串 所以核心思想是建立二维数组，把首节点和末节点纳入考虑 因为s[i][j]是回文子串的条件是s[i+1][j-1]必须是回文串
KMP算法的c++实现
qq_45639511的博客
08-11 302
// KMP算法.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include "cstdio" #include "iostream" #include "cstring" using namespace std; int ne[20];///这个数组中盛放的是匹配字符串的next值 void GetNext(char* a)///这个函数是为了标记匹配字符串的next值 { int len = strlen(a);///先求字符串的长度，便于循环赋值
1159 Palindrome(最小插入回文串)
weixin_34348111的博客
10-15 179
标题效果 定的字符串长度的串和内容。中的字符可以在任何位置被插入。它至少需要为数字，这使得编程回文串串. 回文序列从左至右，从右到左和读取相同. 例如. aaaacbbbb它是一个回文串 aaab前面插入b使得原串变为baaab这个回文串 我的思路. 1.假设该串为空串，或者长度为一。该串是回文串. 2.假设有字符串，a[o...n-1]，（0&lt;=l，r&lt;n)假...
最短回文串 -- C语言
六六哥的博客
03-04 2805
需求 给定一个字符串s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。 示例1: 输入:"aacecaaa" 输出:"aaacecaaa" 示例2: 输入:"abcd" 输出:"dcbabcd" 思路 要找到最短的添加内容，就相当于从字符串位置0开始，查找到最长的回文串，最长回文串后面的部...
两个List循环
田维常
10-30 4255
两个List循环
红黑树精通指南：面试、实战与源码分析
热门推荐
张彦峰的博客
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
从2-3树理解红黑树
02-25
《从2-3树理解红黑树》 2-3树和红黑树是两种重要的自平衡二叉查找树（AVL树）类型，它们在数据结构和算法领域扮演着重要角色，尤其在高效的数据存储和检索方面。2-3树是一种特殊的树形数据结构，而红黑树则是一种对...
红黑树的插入详细图解，直接拿下红黑树
08-17
2. **颜色调整**：新插入的红色节点可能会破坏红黑树的性质。红黑树有五个性质： - 每个节点要么是红色，要么是黑色。 - 根节点是黑色。 - 所有叶子节点（NIL或NULL节点）是黑色。 - 如果一个节点是红色的，那么...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
KMP C++
蜗牛随笔
12-23 708
#include #include using namespace std; void print(const int* p, const int &n){ cout << "前缀数组："; for(int i = 0; i < n - 1; i++){ cout << *(p++) << " "; } cout << *p << endl; } int *prefix(con
转载一篇写KMP算法写得非常好的博文
Simon_coder的博客
06-02 890
KMP算法详解
KMP c++
你好_晴天
11-19 181
#include <iostream> using namespace std; void get_next(char T[],int next[]){ next[0]=-1; int i,j,k; for(j=1;T[j]!='\0';j++){//依次求next[j] for(k=j-1;k>=1;k--){ ...
【算法-LeetCode】214. 最短回文串（字符串；回文；KMP）
赖念安的博客
11-03 1743
214. 最短回文串 - 力扣（LeetCode） 文章起笔：2021年11月2日15:25:01 问题描述及示例 给定一个非负整数，你至多可以交换一次数字中的任意两位。返回你能得到的最大值。 示例 1 : 输入: 2736 输出: 7236 解释: 交换数字2和数字7。 示例 2 : 输入: 9973 输出: 9973 解释: 不需要交换。 注意: 给定数字的范围是 [0, 108] 我的题解 我的思路稍微有点绕，但是总体结构还是比较清晰的。 首先将数值类型的参数 num 转化为数字数组
最小回文串划分
愿岁月如歌
08-29 484
转移方程 dp[i] = min(dp[j-1] + 1 , dp[i]) 1 #include #include #include #include #include #include using namespace std; int dp[100000]; char s[100000]; int T; bool judge(int from , int to) { whi
LeetCode 最短回文子串
hestyle的博客
03-01 1602
给定一个字符串 s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。 示例 1: 输入: "aacecaaa" 输出: "aaacecaaa" 示例 2: 输入: "abcd" 输出: "dcbabcd" 思路分析：首先我们需要确定最短的回文中心在哪里。 回文中心分两种情况：（我们从正中间向右扫描，穷举回文中心） 1、形如 "abbacd" 这种，...
最短回文串
weixin_37841366的博客
10-07 1050
因此s1也是回文串，要找到最短的,等价于找到最长的s1 ,换言之，需要在字符串s中找出一个最长的前缀s1,它是一个回文串，找到s1之后，剩余的部分s2的反序就是结果 如果使用暴力方法，会超时 利用Rabin-Karp字符串哈希算法来找出最长的回文串 在该方法中，我们将字符串看成一个 进制的数，它对应的十进制值就是哈希值。显然，两个字符串的哈希值相等，当且仅当这两个字符串本身相同。然而如果字符串本身很长，其对应的十进制值在大多数语言中无法使用内置的整数类型进行存储。因此，我们会将十进制值对一个大...
UVA - 11584 Partitioning by Palindromes
那些年
12-20 1080
题意：输入一个有小写字母组成的字符串，你的任务是将它划分成尽量少的回文串 思路：dp[i]代表到第i位的最小值，枚举它的前几位求出最小值，为了方便枚举整个长度我们 从str[1]开始输入 #include #include #include #include using namespace std; const int MAXN = 2000; char str[MAXN]; int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值