数据结构（高阶）—— 红黑树

news2025/7/14 5:46:55

目录

一、红黑树的概念

二、红黑树的性质

三、红黑树的结点定义

四、红黑树的插入

五、红黑树的验证

六、红黑树与AVL树的比较

一、红黑树的概念

        红黑树，是一种二叉搜索树，但在每个结点上增加了一个存储位表示结点的颜色，可以使Red或Black。通过对任何一条从根到叶子的路劲上各个结点着色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而近似平衡的。

二、红黑树的性质

红黑树有以下五点性质：

  1. 每个结点不是红色就是黑色。
  2. 根结点是黑色的。
  3. 如果一个结点是红色的，则它的两个孩子结点是黑色的。(没有连续的红结点)
  4. 对于每个结点，从该结点到其所有后代叶子结点的简单路径上，均包含相同数目的黑色结点。(每条路径上的黑色结点数量相同)
  5. 每个叶子结点都是黑色的（此处的叶子结点指定是空结点）。

        为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点给树的两倍呢？

        1. 根据性质3和性质4，我们知道不能有连续的红节点，但是连续的黑节点是可以的，当某个路径中的节点全为黑时，就是该树的最短路径；

        2. 根据性质1和性质4，我们知道最长路径是由一个黑节点和一个红节点交替组成；

        3. 并且最后的叶子节点均是黑色结点（图上为标注）；

这样一来就能够保证最长路径中节点个数不会超过最短路径节点给树的两倍。

三、红黑树的结点定义

        对于红黑树的结点定义，我们依旧使用三叉链来实现，因为红黑树本质也是一种二叉搜索树，相比AVL树的节点定义，我们不再使用平衡因子来控制这里的平衡，而是通过控制颜色来控制平衡。

//节点的颜色
enum Colour
{
	RED,
	BLACK
};

//红黑树节点的定义
template<class k,class v>
struct RBTreeNode
{
    //三叉链
	RBTreeNode<k, v>* _left;   //节点的左孩子
	RBTreeNode<k, v>* _right;  //节点的右孩子
	RBTreeNode<k, v>* _parent; //节点的父亲

	pair<k, v> _kv;//存储键值对

	Colour _col;//利用枚举记录红黑结点

    //构造函数
	RBTreeNode(const pair<k, v>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};

        对于红黑树的插入来说，我们都是要通过构造红黑树节点来进行插入的，那么就有一个问题，究竟是构造红节点还是黑节点呢？

        对于左图的红黑树，插入的是黑色节点，破坏了性质4，就需要对红黑树进行调整，这里很显然插入一个黑色节点影响了所有路径；

        对于右图的红黑树，插入的是红色节点，破坏了性质3，但是性质4是具备的，这里显然只是局部发生的影响，并没有影响整棵红黑树；

        以上图为例，当插入的是红节点时，其父节点如果是黑色，那么将不需要调整红黑树；如果是红色节点也只是影响局部，简单调整；但是插入黑色节点就不一样了，无论你插在哪里，对整棵树的影响很大；此时两种节点的插入，所带来的性价比就很显然易见了；

        权衡利弊下：插入红节点最佳。所以我们在构造结点进行插入时，默认将结点的颜色设置为红色。

四、红黑树的插入

红黑树的插入分为以下两个步骤：

  1. 按照二叉搜索树的插入方法，找到并插入。
  2. 若插入节点的父节点是红色，则需要对红黑树进行调整。

        当插入节点的父节点为黑色时，我们是不需要对红黑树进行调整的，因为并没有破坏红黑树的5个性质；但是其父节点是红色时，就需要分为四种情况进行调整。

        首先规定如下：cur为当前（新增）节点、p为父节点、g为祖父节点、u为叔叔节点

cur —— current；p —— parent；g —— grandfather；u —— uncle

情况一： cur为红，p为红，g为黑，u存在且为红

注意： 叔叔存在且为红时，cur结点是parent的左孩子还是右孩子，调整方法都是一样的。

情况二： cur为红，p为红，g为黑，u不存在/u为黑

说明：u的情况有两种

  • 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4 —— 每条路径黑色节点个数相同。

  • 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。

1. p为g的左孩子，cur为p的左孩子，则进行右单旋转；

2. p为g的右孩子，cur为p的右孩子，则进行左单旋转； 

p、g变色–p变黑，g变红

 情况三： cur为红，p为红，g为黑，u不存在/u为黑

1.p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；转换成了情况2，对g进行右单旋

2.p为g的右孩子，cur为p的左孩子，则针对p做右单旋转； 转换成了情况2，对g进行左单旋 

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);
	cur->_col = RED; // 新增节点

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

	// 控制平衡
	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		if (parent == grandfather->_left) //parent是左孩子
		{
			Node* uncle = grandfather->_right;
			// 情况1、uncle存在且为红
			if (uncle && uncle->_col == RED)
			{
				// 变色+继续向上处理
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				cur = grandfather;
				parent = cur->_parent;
			}
			else //情况2和3：uncle不存在 / 存在且为黑
			{
				if (cur == parent->_left)//如果新增结点在parent的左侧，即是情况2
				{
					// 单旋
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else     //如果新增结点在parent的右侧，即是情况3
				{
					// 双旋
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else // parent == grandfather->_right  //parent是右孩子
		{
			Node* uncle = grandfather->_left;
            // 情况1、uncle存在且为红
			if (uncle && uncle->_col == RED)
			{
				// 变色+继续向上处理
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				cur = grandfather;
				parent = cur->_parent;
			}
			else //情况2和3：uncle不存在 / 存在且为黑
			{
				if (cur == parent->_right)
				{
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}

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

//左单选
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL;
	if (subRL)
	{
		subRL->_parent = parent;
	}
	Node* parentParent = parent->_parent;
	subR->_left = parent;
	parent->_parent = subR;

	if (parent == _root)//这里表明原来是根
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (parentParent->_left == parent)
		{
			parentParent->_left = subR;
		}
		else
		{
			parentParent->_right = subR;
		}
		subR->_parent = parentParent;
	}
}

//右单旋
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	parent->_left = subLR;

	if (subLR)
	{
		subLR->_parent = parent;
	}
	Node* parentParent = parent->_parent;
	subL->_right = parent;
	parent->_parent = subL;
	if (parent == _root)//这里表明原来是根
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		if (parentParent->_left == parent)
		{
			parentParent->_left = subL;
		}
		else
		{
			parentParent->_right = subL;
		}
		subL->_parent = parentParent;
	}
}

五、红黑树的验证

利用中序遍历先判断是否是二叉搜索树 

void InOrder()
{
	_InOrder(_root);
}

void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	cout << root->_kv.first << ":" << root->_kv.second << endl;
	_InOrder(root->_right);
}

        检测是否满足红黑树的性质：任意选取一条路径找出黑色结点的个数作为基准值，然后依次与其他路径比较，如果都相同则满足红黑树的性质；

bool IsBalance()
{
	if (_root && _root->_col == RED)
	{
		cout << "根结点不是黑色" << endl;//为了测试
		return false;
	}  
	//最左路径黑色结点数量做基准值
	int banchmark = 0;//保存最左侧路径中黑色结点的个数
	Node* left = _root;
	while (left) 
	{
		if (left->_col == BLACK)
			++banchmark;
		left = left->_left;
	}

	int blackNum = 0;//递归遍历时记录黑色结点的个数
	return _IsBalance(_root, banchmark, blackNum);
}

bool _IsBalance(Node* root, int banchmark, int blackNum)
{
    //走到null之后，判断banchmark和blackNum是否相等
	if (root == nullptr)
	{
		if (banchmark != blackNum)
		{
			cout << "存在路径黑色结点的数量不相等" << endl;//为了测试
			return false;
		}
		return true;
	}
	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout<<"出现了连续的红色结点" << endl;//为了测试
		return false;
	}
	if (root->_col == BLACK)// 统计黑色节点的个数
	{
		++blackNum;
	}
	return _IsBalance(root->_left, banchmark, blackNum) 
		&& _IsBalance(root->_right, banchmark, blackNum);
}

六、红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，

红黑树和AVL树控制二叉树平衡的方式不同：

  • AVL树是通过控制左右高度差不超过1来实现二叉树平衡的，实现的是二叉树的严格平衡。
  • 红黑树是通过控制结点的颜色，从而使得红黑树当中最长可能路径不超过最短可能路径的2倍，实现的是近似平衡。

        相对而言，红黑树降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

七、源代码

#include <iostream>
using namespace std;

enum Colour
{
	RED,
	BLACK
};

template<class k,class v>
struct RBTreeNode
{
	RBTreeNode<k, v>* _left;
	RBTreeNode<k, v>* _right;
	RBTreeNode<k, v>* _parent;
	pair<k, v> _kv;
	Colour _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()
		:_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);
		cur->_col = RED; // 新增节点
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		// 控制平衡
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// 1、uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色+继续向上处理
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else // 2 + 3、uncle不存在/ 存在且为黑
				{
					if (cur == parent->_left)
					{
						// 单旋
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						// 双旋
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else // parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					// 变色+继续向上处理
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else // 2 + 3、uncle不存在/ 存在且为黑
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

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

	//左单选
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)//这里表明原来是根
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}
	}

	//由单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* parentParent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (parent == _root)//这里表明原来是根
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
	}

void InOrder()
{
	_InOrder(_root);
}

void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	cout << root->_kv.first << ":" << root->_kv.second << endl;
	_InOrder(root->_right);
}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根结点不是黑色" << endl;
			return false;
		}  
		//最左路径黑色结点数量做基准值
		int banchmark = 0;
		Node* left = _root;
		while (left) 
		{
			if (left->_col == BLACK)
				++banchmark;
			left = left->_left;
		}
		int blackNum = 0;
		return _IsBalance(_root, banchmark, blackNum);
	}

	bool _IsBalance(Node* root, int banchmark, int blackNum)
	{
		if (root == nullptr)
		{
			if (banchmark != blackNum)
			{
				cout << "存在路径黑色结点的数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout<<"出现了连续的红色结点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return _IsBalance(root->_left, banchmark, blackNum) 
			&& _IsBalance(root->_right, banchmark, blackNum);
	}

	int Height()
	{
		return _Height(_root);
	}
	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

private:
	Node* _root;
};

void TestRBTree()
{
	RBTree<int, int> t;
	//int a[] = { 5,4,3,2,1,0 };
	int a[] = { 16,3,7,11,9,26,18,14,15 };
	//int a[] = { 4,2,6,1,3,5,15,7,16,14 };
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
		//cout << "Insert" << e << ":" << t.IsBalance() << endl;
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
	cout << t.Height() << endl;

}

 

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

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

相关文章

升级打怪拿offer，10w+字总结的Java面试题（附答案）够你刷

升级打怪拿offer，10w+字总结的Java面试题（附答案）够你刷

升级打怪拿offer&#xff0c;献上熬夜整理最新“10w字总结的Java面试题&#xff08;附答案&#xff09;”够你刷&#xff01; 其包含的内容模块有&#xff1a;基础、JVM、多线程与高并发、Spring、MyBatis、SpringBoot、MYSQL、SpringCloud、Dubbo、Nginx、MQ、数据结构与算法…
阅读更多...
CF104064 E. Exchange Students(NWERC2021)

CF104064 E. Exchange Students(NWERC2021)

题目分析 首先需要观察到一个性质&#xff1a;在最优方案下的操作一定是首先交换距离最近能交换的两个点来达到交换的效果&#xff0c;这个很好理解&#xff1a;题目要求如果要交换两个人的位置&#xff0c;中间的人的身高必须严格小于这两个人&#xff0c;因此合法的交换操作仅…
阅读更多...
生成对抗网络（GAN）

生成对抗网络（GAN）

GAN简介 GAN思想是一种二人的零和博弈思想&#xff0c;GAN中有两个博弈者&#xff0c;一个生成器&#xff08;G&#xff09;&#xff0c;一个判别器&#xff08;D&#xff09;&#xff0c;这两个模型都有各自的输入和输出。具体功能如下&#xff1a; 生成器&#xff08;G&…
阅读更多...
声门脉冲语音处理

声门脉冲语音处理

对于 0<t<tpeak&#xff0c;gattack(t) 攻击部分&#xff0c;即上升分支的时间&#xff0c;时间 t 的范围从 0 秒到最大峰值时间 tpeak &#xff0c;图示例中选择为大约总长度的 35%&#xff0c;即 tpeak35%⋅T0&#xff0c;或者在样本 Lattack⌊35%⋅Lg⌉ 中&#xff0c…
阅读更多...
2023年系统规划与设计管理师-第三章信息技术服务知识

2023年系统规划与设计管理师-第三章信息技术服务知识

一. 思维导图 二.IT 服务管理 (ITSM) 1. 什么是 IT 服务管理 (ITSM)&#xff1f; IT 服务管理 (ITSM) 包含一组策略和实践&#xff0c;这些策略和实践可用于为最终用户实施、交付和管理 IT 服务&#xff0c;以满足最终用户的既定需求和企业的既定目标。 在此定义中&#xff0…
阅读更多...
otn 709帧结构

otn 709帧结构

otn架构说明： 基于G.709接口，包括波分侧和客户侧，客户侧通常用于互联互通。 光通路净荷单元：OPU0/OPU1/OPU2/OPU3/OPU4/flex，主要用于完成业务同步或异步映射； 光通路数据单元：ODU0/ODU1/ODU2/ODU3/ODU4/ODU-flex，完成通道连接性能监测和子速率复用、 光通路传送单元…
阅读更多...
POJ1008：玛雅日历

POJ1008：玛雅日历

一、Description During his last sabbatical, professor M. A. Ya made a surprising discovery about the old Maya calendar. From an old knotted message, professor discovered that the Maya civilization used a 365 day long year, called Haab, which had 19 months.…
阅读更多...
Netty学习笔记

Netty学习笔记

文章目录二、Netty 入门2.1、概述2.1.1、Netty 是什么&#xff1f;2.1.2、Netty 的作者2.1.3、Netty 的地位2.1.4、Netty 的优势2.2、Hello World2.2.1、目标2.2.2、服务器端2.2.3、客户端2.2.4、流程梳理&#x1f4a1; 提示2.3、组件2.3.1、EventLoop&#x1f4a1; 优雅关闭演…
阅读更多...
保姆级二进制安装高可用k8s集群文档(1.23.8)

保姆级二进制安装高可用k8s集群文档(1.23.8)

保姆级二进制安装高可用k8s集群文档k8s搭建方式前期准备集群规划机器准备1、master vagrantfile2、master install.sh3、node vagrantfile4、node install.sh5、时间同步vagran 启动脚本vagrant up注意点安装conntrack 工具ipvs的安装VBoxManage snapshot 准备虚拟机快照ETCD部…
阅读更多...
C语言编程作业参考答案

C语言编程作业参考答案

编程题参考答案 文章目录编程题参考答案week1_test选择结构-编程题循环结构上机练习数组编程函数编程2week1_test Write a program to output the average of 2 integers. #include <stdio.h>void main(){int a , b;double c;printf("Please enter 1 integers\n&q…
阅读更多...
官网下载mysql 8.0.27及安装

官网下载mysql 8.0.27及安装

https://www.mysql.com/downloads/&#xff0c;找到社区版下载链接MySQL Community (GPL) Downloads 1、 2、 3、 4、 5、
阅读更多...
光谱异常样本检测分析

光谱异常样本检测分析

以近红外光谱为例&#xff0c;大部分光谱数据在不考虑分类问题时&#xff0c;在构建模型前需要对采集数据进行样本分析&#xff0c;以降低因生产过程异常、人为误操作和其他原因对软测量模型的影响&#xff0c;即异常样本检测分析。 按照定义&#xff0c;异常样本检测任务指的是…
阅读更多...
k8s编程operator——(3) 自定义资源CRD.md

k8s编程operator——(3) 自定义资源CRD.md

文章目录1、自定义资源的使用1.1 注册自定义资源1.2 使用自定义资源&#xff1a;1.3 Finalizers1.4 合法性验证2、如何操作自定义资源2.1 使用RestClient和DynamicClient来操作自定义资源对象2.2 使用sharedIndexInformer2.3 code-generator2.3.1 下载安装2.3.2 code-generator…
阅读更多...
Ajax、Fetch、Axios三者的区别

Ajax、Fetch、Axios三者的区别

1.Ajax&#xff08;Asynchronous JavaScript And XML&#xff09; Ajax 是一个技术统称&#xff0c;它很重要的特性之一就是让页面实现局部刷新。 特点&#xff1a; 局部刷新页面&#xff0c;无需重载整个页面。 简单来说&#xff0c;Ajax 是一种思想&#xff0c;XMLHttpReq…
阅读更多...
毕业设计-基于机器学习的图片处理图片倾斜校正

毕业设计-基于机器学习的图片处理图片倾斜校正

前言 &#x1f4c5;大四是整个大学期间最忙碌的时光,一边要忙着备考或实习为毕业后面临的就业升学做准备,一边要为毕业设计耗费大量精力。近几年各个学校要求的毕设项目越来越难,有不少课题是研究生级别难度的,对本科同学来说是充满挑战。为帮助大家顺利通过和节省时间与精力投…
阅读更多...
如何简单理解大数据

如何简单理解大数据

如何简单理解大数据 HDFS-存储 海量的数据存储 hadoop 只是一套工具的总称&#xff0c;它包含三部分&#xff1a;HDFS&#xff0c;Yarn&#xff0c;MapReduce&#xff0c;功能分别是分布式文件存储、资源调度和计算。 按理来说&#xff0c;这就足够了&#xff0c;就可以完成大…
阅读更多...
matlab实现MCMC的马尔可夫转换MS- ARMA - GARCH模型估计

matlab实现MCMC的马尔可夫转换MS- ARMA - GARCH模型估计

状态转换模型&#xff0c;尤其是马尔可夫转换&#xff08;MS&#xff09;模型&#xff0c;被认为是识别时间序列非线性的不错的方法。 估计非线性时间序列的方法是将MS模型与自回归移动平均 - 广义自回归条件异方差&#xff08;ARMA - GARCH&#xff09;模型相结合&#xff0c;…
阅读更多...
Ubuntu22.04+Nvidia驱动+Cuda11.8+cudnn8.6

Ubuntu22.04+Nvidia驱动+Cuda11.8+cudnn8.6

Ubuntu22.04Nvidia驱动Cuda11.8 一、准备环境 ubuntu 22.04nvidia显卡 这里使用的是RTX3060已安装Python3.10 二、安装pip3 # 安装 sudo apt install python3-pip # 升级 sudo pip3 install --upgrade pip # 如果要卸载&#xff0c;使用命令&#xff1a; sudo apt-get remov…
阅读更多...
MySQL创建和管理表

MySQL创建和管理表

基础知识 一条数据存储的过程 存储数据是处理数据的第一步 。只有正确地把数据存储起来&#xff0c;我们才能进行有效的处理和分析。否则&#xff0c;只能是一团乱麻&#xff0c;无从下手。 那么&#xff0c;怎样才能把用户各种经营相关的、纷繁复杂的数据&#xff0c;有序、…
阅读更多...
ES6解析赋值

ES6解析赋值

ES6中新增了一种数据处理方式&#xff0c;可以将数组和对象的值提取出来对变量进行赋值&#xff0c;这个过程时将一个数据结构分解成更小的部分&#xff0c;称之为解析。 1.对象解析赋值: 在ES5中&#xff0c;要将一个对象的属性提取出来&#xff0c;需要经过一下几个过程。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023