C++【实现红黑树(核心插入)】

news2024/11/19 14:53:56

文章目录

  • 一、红黑树概念介绍
  • 二、红黑树模拟实现
    • （1）红黑树节点
    • （2）红黑树插入分析(核心)
    • （3）插入代码思路(如何快速写插入算法)
    • （4）判断平衡函数
    • （5）查找函数
    • （6）测试函数
    • （7）测试结果
  • 三、红黑树源代码
    • （1）RbTree.h
    • （2）Test.cpp

一、红黑树概念介绍

概念：
红黑树，也是一种二叉搜索树，它是在每个结点上增加一个存储位表示结点的颜色，可以是红或黑，然后通过对任何一条从根到叶子的路径上各个结点着色方式的限制，保证了没有一条路径会能超过其他路径的俩倍，因而是近似平衡的。map和set的底层数据结构就是用红黑树来封装的。
性质：
1.根节点是黑色的
2.不能出现连续的红色节点
3. 每条路径上有相同数量的黑色节点
4. 每个叶子(空节点)结点都是黑色
5. 每个结点不是红色就是黑色
满足上面的性质，红黑树就能保证：最长路径中节点个数不会超过最短路径节点个数的2倍。
优势：
假设全部的黑色节点有N个 最短路径长度是logN 整棵树的节点数量：[N,2N]，最长路径长度：2logN。假设10亿个节点，AVL：最多查找30次左右；RB：最多查找60次左右。
综合而言，其实对于查找大量数据30次和60次没太大差别，而红黑树不要求绝对平衡，只需保证最长路径不超过最短路径的2倍，相对来说降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优。

二、红黑树模拟实现

（1）红黑树节点

enum Color
{
	RED=0,
	BLACK,
};
template<class K,class V>
struct RbTreeNode
{
	RbTreeNode<K, V>* _left;
	RbTreeNode<K, V>* _right;
	RbTreeNode<K, V>* _parent;
	pair<K, V>_kv;
	Color _col;
	RbTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};

里面同样用三叉链，要有左孩子右孩子，父节点，以及pair类的类型来存储kv两个相同或不同类型的值(当我们使用make_pair函数创建一个pair对象，该函数会自动推断参数类型)，并在里面增加一个枚举，用来表示一个节点不是红色就是黑色。关于构造函数里面的颜色初始化为黑色还是红色，在插入会讲解。

（2）红黑树插入分析(核心)

插入和前面的AVL插入部分是一样的，在里面如果是根节点，那就把跟点为置为黑色。
那这有一个问题就是节点构造函数里面的一个问题：我们在申请一个新节点时，宁愿新增红色还是黑色？
因为不管是增哪种颜色，本质上是违反规则三还是违反规则四的问题，如果插入黑色，一定违反规则四，但它代价太大，违反规则三就不一定，因为它的父节点可能为红色也可能为黑色，如果在黑色节点下面插入就没影响，反之就会影响。
对于上面的做法会出现下面的两大情况，第一GPC为一一条直线，第二GPC为折线。
如图：
在这里插入图片描述
G为祖父节点，P为父亲节点，C为当前节点，U为叔父节点
1、先解决当GPC为一条直线的时候：
（1）如果U存在且为红色，P必须变黑，U也得变黑，左右都增加了黑，那就把G变红,这样久能保持黑色节点不变，因为G现在变成红了，但是G的父节点如果是红色的还得继续处理 ，那就把G当成C节点，继续算它的祖父，再看U，如果U是红再把它变成黑。
在这里插入图片描述
它的所对应的抽象图以及具象图：
在这里插入图片描述

（2）如果U不存在或者存在且为黑又是两种情况
如果U不存在，再增加红节点，且有连续的红色节点，有可能会超过它的最短路径，只能旋转来降高度。把P变黑，把G给P的左，再把P作为左，同时把原来的G变红，这里就是左单旋加G和P变色。
如下例图：
在这里插入图片描述
它所对应的抽象及具象图：
在这里插入图片描述

如果U存在且为黑色
U存在且为黑是由第一种请况变化而来，这里发生了右单旋，P的左孩子作为G的左孩子，而G又作为P的右孩子，且P变为黑，G变为红。
在这里插入图片描述
对于上面的U不存在或者存在为黑两种情况进行总结： P为G的左孩子时，C为P的左孩子进行右单旋转，如果P为G的右孩子，C为P的右孩子，进行左单旋转。P变为黑色，G变为红色。
旋转的目的就是为了防止最长路径超过最短路径的2倍。GPC为一条线的时候就是左单旋转或右单旋。

2、再解决GPC为折线的情况
（1）U存在且为黑
出现这种折线情况的原因是由第一种情况先变色而产生，然后p变成g的左，c变成p的右，c为红，p为红，g为黑，接着我们先以p为轴进行左旋转进行降低高度，在以g为轴进行右旋，且g变红，c变黑，因为这样才能保证不出现连续红结点且保证每个路径黑色数量一样。以上实际进行了双旋。
在这里插入图片描述

（2）U不存在，直接右单旋

（3）插入代码思路(如何快速写插入算法)

在这里插入图片描述

（一）先看左面这种大情况
插入C1肯定为红节点，P1如果是红，就需要开始作处理：先利用三叉链，从P1得出G1，进入核心环节：左面的这种情况是P1是G1的左孩子时，里面又要有分两种情况：
（1）如果是U存在且为红，我们把P1和U变为黑，G1变为红，更新C1到G1的位置，继续往上调整；
（2）如果是U不存在或黑(是一种情况)，如果U不存在就不能变黑，而且就算存在为黑说明是一定是由继续往上调整的那一步(情况(1))而来的即继续往上处理，我们还是是增加了节点，就可能导致最长路径超过最短路径的2倍或者一直用情况(1)的方式最终导致每条路径黑色数量不相等。这时候我们就要通过旋转方式降低高度加变色来解决。所以在这里又分两种：G1P1C1为直线和G1P1C1为折线：

  • 如果是C1P1在一条直线上即C1是P1的左孩子，我们以G1为轴进行右单旋(哪边高往哪边降)，G1要变红，P1要变成黑，因为G1下来了P1作为根，不能出现连续的红节点P要变黑，又因为保证黑色数量相等，G1要变红。
  • 如果是C1和P1，G1是折线的时候即C1是P1的右孩子，这时候需要先以P1为轴进行左单旋，再以G1为轴进行右单旋，最终C1做了根节点，G1是右孩子，因为P1是红，C1是红不能出现连续红节点，需把C1变黑，但是还要保证黑色数量相等，就把G1变红。最后结束break，只有情况(1)才会继续向上来回处理。
    （二）再看右面这种大情况
    和（一）情况类似
    P2是G2的右孩子，同理那旋转方式就根上面相反。
    所以我们的插入函数：
bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandf = parent->_parent;
			if (grandf->_left == parent)
			{
				Node* unc = grandf->_right;
				if (unc && unc->_col == RED)//u存在且为红，变色处理
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;

					cur = grandf;//继续往上调整
					parent = cur->_parent;
				}
				else//u不存在或者黑
				{
					if (parent->_left == cur)
					{
						RotateR(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
						
					}
					else
					{
						RotateL(parent);
						RotateR(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* unc = grandf->_left;
				if (unc && unc->_col == RED)
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;

					cur = grandf;
					parent = cur->_parent;
				
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;

					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

（4）判断平衡函数

bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色错误" << endl;
			return false;
		}
		int Bsign = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++Bsign;
			}
			cur = cur->_left;
		}
		return _check(_root, 0, Bsign);

	}
	bool _check(Node* root, int Bnum, int Bsign)
	{
		if (root == nullptr)
		{
		
			if (Bnum != Bsign)
			{
				cout << "黑色节点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++Bnum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "连续红色节点" << endl;
			return false;
		}
		return _check(root->_left,Bnum,Bsign) && _check(root->_right, Bnum, Bsign);
	}
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

首先不能以最长路径不超过最短路径2倍为准则判断平衡，它只是结果。
还是要以前面说的规则：
第一个：先检查根是不是黑色的；
第二个：再检查连续的红色节点：如果是红色的就去检查儿子，这种方式不行，因为孩子可能不存在，可以改为它的父亲，如果是红一定有父亲，如果父亲为红就存在连续红色节点直接返回假；
还有一个：最重要的规则：判断黑色节点的数量是否相等，我们需要先记录一下黑色数量，我们可以先获取一条路径的黑色数量Bsign，然后以它为标准，如何让每条路径以它标准判断是否相等？我们可以在参数里面的形参传值Bnum，往下递归就会往下传，下一层++不会影响上一层++，因为下一层是上一层的拷贝，只要有一条不相等就返回假。

（5）查找函数

Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

从根开始走，如果比它大，就往右边走，如果比它小，就往左边走，如果相等说明找到，否则返回空。

（6）测试函数

void Test()
{

	int arr[] = { 33, 22, 6, 1, 3, 5, 66, 7, 16, 14, 16, 3, 7, 11, 9, 36, 18, 14, 15 };
	RbTree<int, int> t;
	for (auto n : arr)
	{
	
		t.Insert(make_pair(n, n));
	}

	t.Inorder();
	cout << endl;
	cout << t.IsBalance() << endl;
	cout << "高度："<<t.height() << endl;

	cout << endl;
	cout << "随机数据测试:" << endl;

	srand(time(0));
	const size_t N = 100000;
	RbTree<int, int> r;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		r.Insert(make_pair(x, x));

	}

	cout << r.IsBalance() << endl;
	cout <<"高度："<< r.height() << endl;
}

（7）测试结果

在这里插入图片描述

三、红黑树源代码

（1）RbTree.h

#pragma once
#include<iostream>
#include<utility>
#include<ctime>
using namespace std;
enum Color
{
	RED=0,
	BLACK,
};
template<class K,class V>
struct RbTreeNode
{
	RbTreeNode<K, V>* _left;
	RbTreeNode<K, V>* _right;
	RbTreeNode<K, V>* _parent;
	pair<K, V>_kv;
	Color _col;
	RbTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};
template <class K,class V>
class RbTree
{
	typedef RbTreeNode<K, V> Node;
public:
	~RbTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandf = parent->_parent;
			if (grandf->_left == parent)
			{
				Node* unc = grandf->_right;
				if (unc && unc->_col == RED)//u存在且为红，变色处理
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;

					cur = grandf;//继续往上调整
					parent = cur->_parent;
				}
				else//u不存在或者黑
				{
					if (parent->_left == cur)
					{
						RotateR(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
						
					}
					else
					{
						RotateL(parent);
						RotateR(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* unc = grandf->_left;
				if (unc && unc->_col == RED)
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;

					cur = grandf;
					parent = cur->_parent;
				
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;

					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}
	void Inorder()
	{
		_InOrder(_root);

	}
	int height()
	{
		return _Height(_root);
	}
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色错误" << endl;
			return false;
		}
		int Bsign = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++Bsign;
			}
			cur = cur->_left;
		}
		return _check(_root, 0, Bsign);

	}
private:
	void RotateL(Node* parent)//左单旋
	{
		Node* suR = parent->_right;//11的右孩子即22
		Node* suRL = suR->_left;//11的右孩子的左孩子即b
		Node* ppnode = parent->_parent;//维护父结点的父结点


		parent->_right = suRL;//11右孩子链接b
		if (suRL)//如果b不为空
			suRL->_parent = parent;//更新双亲结点


		suR->_left = parent;//22上提，左孩子链接11
		parent->_parent = suR;//更新双亲结点

		if (ppnode == nullptr)
		{
			_root = suR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = suR;
			}
			else
			{
				ppnode->_right = suR;
			}
			suR->_parent = ppnode;
		}

	}
	void RotateR(Node* parent)//右单旋
	{
		Node* suL = parent->_left;
		Node* suLR = suL->_right;

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

		Node* ppnode = parent->_parent;

		suL->_right = parent;
		parent->_parent = suL;


		if (parent == _root)
		{
			_root = suL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = suL;
			}
			else
			{
				ppnode->_right = suL;
			}
			suL->_parent = ppnode;
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
	int _Height(Node* root)
	{
		if (root == NULL)
			return 0;

		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		return leftH > rightH ? leftH + 1 : rightH + 1;
	}
	bool _check(Node* root, int Bnum, int Bsign)
	{
		if (root == nullptr)
		{
		
			if (Bnum != Bsign)
			{
				cout << "黑色节点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++Bnum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "连续红色节点" << endl;
			return false;
		}
		return _check(root->_left,Bnum,Bsign) && _check(root->_right, Bnum, Bsign);
	}
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}
	

private:
	Node* _root;
};

void Test()
{

	int arr[] = { 33, 22, 6, 1, 3, 5, 66, 7, 16, 14, 16, 3, 7, 11, 9, 36, 18, 14, 15 };
	RbTree<int, int> t;
	for (auto n : arr)
	{
	
		t.Insert(make_pair(n, n));
	}

	t.Inorder();
	cout << endl;
	cout << t.IsBalance() << endl;
	cout << "高度："<<t.height() << endl;

	cout << endl;
	cout << "随机数据测试:" << endl;

	srand(time(0));
	const size_t N = 100000;
	RbTree<int, int> r;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		r.Insert(make_pair(x, x));

	}

	cout << r.IsBalance() << endl;
	cout <<"高度："<< r.height() << endl;
}

（2）Test.cpp

#include"RbTree.h"
int main()
{
	Test();
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/591715.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

01_java基础语法

01_java基础语法

1. Java概述 1.1 Java语言背景介绍&#xff08;了解&#xff09; 语言&#xff1a;人与人交流沟通的表达方式 计算机语言&#xff1a;人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司&#xff08;Stanford University Network&#xff09;在1995年推出的…
阅读更多...
【软硬件测试】测试经验：软硬件结合测试要点

【软硬件测试】测试经验：软硬件结合测试要点

目录 一、应用行业 二、测试要点 三、硬件测试 &#xff08;1&#xff09;测试含义 &#xff08;2&#xff09;测试方法 &#xff08;3&#xff09;相关链接 四、结合测试 &#xff08;1&#xff09;测试含义 &#xff08;2&#xff09;测试工具 &#xff08;3&am…
阅读更多...
NIO之SocketChannel,SocketChannel ,DatagramChannel解读

NIO之SocketChannel,SocketChannel ,DatagramChannel解读

目录 基本概述 ServerSocketChannel 打开 ServerSocketChannel 关闭 ServerSocketChannel 监听新的连接 阻塞模式 非阻塞模式 SocketChannel SocketChannel 介绍 SocketChannel 特征 创建 SocketChannel 连接校验 读写模式 读写 DatagramChannel 打开 Datagr…
阅读更多...
chatgpt赋能python：Python中的开方指令：介绍和使用

chatgpt赋能python：Python中的开方指令：介绍和使用

Python中的开方指令&#xff1a;介绍和使用 Python是一种流行的编程语言&#xff0c;广泛用于数据科学、机器学习、Web开发和其他领域。在许多情况下&#xff0c;需要对数值进行数学计算&#xff0c;其中包括开方运算。Python中有多种方法可以执行开方运算&#xff0c;本文将介…
阅读更多...
chatgpt赋能python：Python中的“或”语句：使用方法和示例

chatgpt赋能python：Python中的“或”语句：使用方法和示例

Python中的“或”语句&#xff1a;使用方法和示例 在Python编程中&#xff0c;“或"语句表示为"or”&#xff0c;它是逻辑运算符的一种形式。"或"语句可以用于组合两个或多个条件&#xff0c;只要其中一个条件成立&#xff0c;整个语句就会返回True。在本…
阅读更多...
Rust每日一练(Leetday0016) 全排列I\II、旋转图像

Rust每日一练(Leetday0016) 全排列I\II、旋转图像

目录 46. 全排列 Permutations &#x1f31f;&#x1f31f; 47. 全排列 II Permutations II &#x1f31f;&#x1f31f; 48. 旋转图像 Rotate Image &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专…
阅读更多...
Golang每日一练(leetDay0082) 用队列实现栈、用栈实现队列

Golang每日一练(leetDay0082) 用队列实现栈、用栈实现队列

目录 225. 用队列实现栈 Implement Stack Using Queues &#x1f31f; 232. 用栈实现队列 Implement Queue Using Stacks &#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Rust每日一练 专栏 Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 …
阅读更多...
C#，码海拾贝（29）——求解“大型稀疏方程组”的“全选主元高斯－约去消去法”之C#源代码，《C#数值计算算法编程》源代码升级改进版

C#，码海拾贝（29）——求解“大型稀疏方程组”的“全选主元高斯－约去消去法”之C#源代码，《C#数值计算算法编程》源代码升级改进版

大型稀疏矩阵线性化方程组的数值求解问题 广泛存在于工程实践尤其是计算机仿真领域 如水力管网计算&#xff0c;电力系统的大型导纳矩阵计算&#xff0c;高阶偏微分方程的数值求解&#xff0c;以及铸件充型过程与凝固过程的数值模拟等。 经常出现在科学和工程计算中, 因此寻找稀…
阅读更多...
chatgpt赋能python：Python中的平均值及其计算方式

chatgpt赋能python：Python中的平均值及其计算方式

Python中的平均值及其计算方式 Python是广泛使用的编程语言之一&#xff0c;它拥有强大而且易于使用的数据处理和分析功能。在数据分析领域&#xff0c;计算平均值是非常常见的操作之一。Python中有多种方法可以计算平均值&#xff0c;包括使用内置的函数和使用第三方库。本文…
阅读更多...
MySQL数据库 1.概述

MySQL数据库 1.概述

数据库相关概念&#xff1a; 数据库(Database)&#xff1a;数据库是指一组有组织的数据的集合&#xff0c;通过计算机程序进行管理和访问。数据库管理系统&#xff1a;操纵和管理数据库的大型软件SQL&#xff1a;操作关系型数据库的编程语言&#xff0c;定义了一套操作关系型数…
阅读更多...
Linux之模拟shell命令行解释器

Linux之模拟shell命令行解释器

文章目录 前言一、输出提示符1.实际2.模拟 二、输入指令、获取指令1.实际2.模拟 三、fork创建子进程四、内建命令五、代码实现总结 前言 本文是基于前面介绍过的关于进程创建、进程终止、进程等待、进程替换等知识&#xff0c;尝试做的一个简单的shell命令解释器。 一、输出提…
阅读更多...
OpenCV实战（25）——3D场景重建

OpenCV实战（25）——3D场景重建

OpenCV实战&#xff08;25&#xff09;——3D场景重建 0. 前言1. 重建 3D 场景1.1 3D 场景点重建1.2 算法原理 2. 分解单应性3. 光束平差法4. 完整代码小结系列链接 0. 前言 在《相机姿态估计》一节中&#xff0c;我们学习了如何在校准相机时恢复观察 3D 场景的相机的位置。算…
阅读更多...
TypeScript的10个缺点

TypeScript的10个缺点

文章目录 1. 语法繁琐2. 难以集成到一些工作流程3. 学习成本高4. 代码量多5. 编译时间长6. 在小型项目中无必要性7. 可读性降低8. 抽象层次增加9. 缺少类型定义10. 生态系统 1. 语法繁琐 TypeScript 的类型注解、泛型等语法增加了代码的复杂度和学习难度&#xff0c;对小型项目…
阅读更多...
LC-1130. 叶值的最小代价生成树（贪心、区间DP、单调栈）

LC-1130. 叶值的最小代价生成树（贪心、区间DP、单调栈）

1130. 叶值的最小代价生成树 难度中等272 给你一个正整数数组 arr&#xff0c;考虑所有满足以下条件的二叉树&#xff1a; 每个节点都有 0 个或是 2 个子节点。数组 arr 中的值与树的中序遍历中每个叶节点的值一一对应。每个非叶节点的值等于其左子树和右子树中叶节点的最大…
阅读更多...
chatgpt赋能python：Python中的逆序操作

chatgpt赋能python：Python中的逆序操作

Python 中的逆序操作 在 Python 中&#xff0c;逆序&#xff08;reverse&#xff09;操作指的是将一个序列的元素顺序反转&#xff0c;也即将序列中最后一个元素变成第一个&#xff0c;倒数第二个元素变成第二个&#xff0c;以此类推。逆序有很多实际用途&#xff0c;比如根据…
阅读更多...
基于C语言的平衡二叉树操作(包含完整代码)

基于C语言的平衡二叉树操作(包含完整代码)

平衡二叉树的定义: 为避免树的高度增长过快&#xff0c;降低二叉排序树的性能&#xff0c;规定在插入和删除二叉树结点时&#xff0c;要保证任意结点的左、右子树高度差的绝对值不超过1&#xff0c;将这样的二义树称为平衡二叉树AVL (Balanced Binary Tree),简称平衡树。 平衡…
阅读更多...
【源码解析】流控框架Sentinel源码深度解析

【源码解析】流控框架Sentinel源码深度解析

前言 前面写了一篇Sentinel的源码解析&#xff0c;主要侧重点在于Sentinel流程的运转原理。流控框架Sentinel源码解析&#xff0c;侧重点在整个流程。该篇文章将对里面的细节做深入剖析。 统计数据 StatisticSlot用来统计节点访问次数 SpiOrder(-7000) public class Statis…
阅读更多...
PCL 改进点云双边滤波算法

PCL 改进点云双边滤波算法

文章目录 一、简介二、实现代码三、实现效果参考资料一、简介 我们先来回顾一下之前该算法的计算过程，在二维图像领域中，双边滤波算法是通过考虑中心像素点到邻域像素点的距离(一边)以及像素亮度差值所确定的权重(另一边)来修正当前采样中心点的位置，从而达到平滑滤波效果。…
阅读更多...
PHPMySQL基础（五）:模拟登录后跳转+会话存储功能实现

PHPMySQL基础（五）:模拟登录后跳转+会话存储功能实现

PHP&MySQL基础&#xff08;一&#xff09;:创建数据库并通过PHP进行连接_长风沛雨的博客-CSDN博客 PHP&MySQL基础&#xff08;二&#xff09;:通过PHP对MySQL进行增、删、改、查_长风沛雨的博客-CSDN博客 PHP&MySQL基础&#xff08;三&#xff09;:处理查询SQL返…
阅读更多...
一图看懂 tqdm 模块：一个可在循环和命令行中使用的快速、可扩展的进度条，资料整理+笔记（大全）

一图看懂 tqdm 模块：一个可在循环和命令行中使用的快速、可扩展的进度条，资料整理+笔记（大全）

本文由 大侠(AhcaoZhu)原创&#xff0c;转载请声明。 链接: https://blog.csdn.net/Ahcao2008 一图看懂 tqdm 模块&#xff1a;一个可在循环和命令行中使用的快速、可扩展的进度条&#xff0c;资料整理笔记&#xff08;大全&#xff09; &#x1f9ca;摘要&#x1f9ca;模块图&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023