算法导论 红黑树 学习 删除(四)

最新推荐文章于 2023-05-21 23:49:59 发布
最新推荐文章于 2023-05-21 23:49:59 发布
阅读量882 收藏 2
点赞数
分类专栏： C/C++语言 数据结构与算法 文章标签： 红黑树 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stecdeng/article/details/55107069
版权

学习算法 还是建议看看算法导论

算法导论第三版 如果不看数学推导 仅看伪代码 难度还是适中

本系列只是记录我的学习心得 和伪代码转化代码的过程

深入学习 还是建议大家看看算法书籍 教程更加系统。

本文参考算法导论第13章节 红黑树

代码由本人写成

转载请标明出处


先看看不做颜色处理的删除

不做颜色处理的删除基本就和二叉树类似

如果删除节点没有子树 最简单 直接删除

如果待删除的节点只有一个儿子(左子树或者右子树) 那么删除该节点 儿子补上即可

void RBTransplant(std::shared_ptr<node>& root,
	std::shared_ptr<node> u, std::shared_ptr<node> 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_;
}

u是要删除的节点 v是补上的节点

过程如图:



若是待删除节点有两个子树 那么寻找待删除节点右子树最小的节点，这个节点要么就是删除节点右子树，要么就是沿着删除节点右子树向左遍历的终点

如图： 如果7是待删除节点，那么目标不是11 就是9

将删除节点和目标节点值互换 在处理目标节点  那么就把两棵子树节点的删除更改为无子树或者单子树节点的删除，很巧妙！




伪代码如图


删除代码及测试代码如下(删除未调整颜色版本,可运行)

// rbTreeTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <memory>
#include <iostream>

using namespace std;

enum Color {
	red = 1,
	black
};

struct node {
	Color color_;
	std::shared_ptr<node> left_;
	std::shared_ptr<node> right_;
	std::shared_ptr<node> parent_;
	int value_;
	node() {
		left_ = right_ = parent_ = nullptr;
		value_ = -1;
		color_ = black;
	}
};

std::shared_ptr<node> nil(new node);


std::shared_ptr<node> CreateNode(Color color, int i) {
	std::shared_ptr<node> p(new node);
	p->color_ = color;
	p->left_ = nil;
	p->right_ = nil;
	p->parent_ = nil;
	p->value_ = i;
	return p;
}

void RightRotate(std::shared_ptr<node>& root, std::shared_ptr<node> x) {
	std::shared_ptr<node> y = x->left_;
	x->left_ = y->right_;
	if (y->right_ != nil)
		y->right_->parent_ = x;
	y->parent_ = x->parent_;
	if (x->parent_ == nil) {
		root = y;
	}
	else if (x->parent_->left_ == x) {
		x->parent_->left_ = y;
	}
	else {
		x->parent_->right_ = y;
	}

	y->right_ = x;
	x->parent_ = y;
}

void LeftRotate(std::shared_ptr<node>& root, std::shared_ptr<node> x) {
	std::shared_ptr<node> 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->parent_->left_ == x) {
		x->parent_->left_ = y;
	}
	else {
		x->parent_->right_ = y;
	}
	y->left_ = x;
	x->parent_ = y;
}

void PrinTree(std::shared_ptr<node> root) {
	if (root == nil) {
		std::cout << "nil:" << ":color-" << root->color_ << " ; " << std::endl << std::endl;
		return;
	}
	std::cout << root->value_ << ":color-" << root->color_ << "; address:" << root << std::endl;
	if (root->parent_ == nil) {
		std::cout << "parent_:" << "nil" << std::endl;
	}
	else {
		std::cout << "parent_:" << root->parent_->value_ << std::endl;
	}

	if (root->left_ == nil) {
		std::cout << "left_:" << "nil" << std::endl;
	}
	else {
		std::cout << "left_:" << root->left_->value_ << std::endl;
	}


	if (root->right_ == nil) {
		std::cout << "right_:" << "nil" << std::endl;
	}
	else {
		std::cout << "right_:" << root->right_->value_ << std::endl;
	}

	std::cout << std::endl;


	if (root->left_ != nil)
		PrinTree(root->left_);
	if (root->right_ != nil)
		PrinTree(root->right_);
}

void RBInsertFixup(std::shared_ptr<node>& root, std::shared_ptr<node> z) {
	while (z->parent_->color_ == red) {   //插入节点Z是红色 若Z父节点也是红色则需要调整
		if (z->parent_ == z->parent_->parent_->left_) {  // 父节点是左子树的情况
			std::shared_ptr<node> y = z->parent_->parent_->right_;
			if (y->color_ == red) {                   //  情况1
				z->parent_->color_ = black;
				y->color_ = black;
				z->parent_->parent_->color_ = red;
				z = z->parent_->parent_;
			}
			else {
				if (z == z->parent_->right_) {
					z = z->parent_;                  //  情况2
					LeftRotate(root, z);
				}
				z->parent_->color_ = black;           //  情况3
				z->parent_->parent_->color_ = red;
				RightRotate(root, z->parent_->parent_);
			}
		}
		else {// 父节点是右子树的情况 与上面判断处理均是镜像对称
			std::shared_ptr<node> y = z->parent_->parent_->left_;
			if (y->color_ == red) {
				z->parent_->color_ = black;
				y->color_ = black;
				z->parent_->parent_->color_ = red;
				z = z->parent_->parent_;
			}
			else {
				if (z == z->parent_->left_) {
					z = z->parent_;
					RightRotate(root, z);
				}
				z->parent_->color_ = black;
				z->parent_->parent_->color_ = red;
				LeftRotate(root, z->parent_->parent_);
			}
		}
	}//while (z->parent_->color_ == red)
	root->color_ = black;
}//function end

void RBInsert(std::shared_ptr<node>& root, std::shared_ptr<node> ins) {
	std::shared_ptr<node> y = nil;
	std::shared_ptr<node> x = root;

	while (x != nil) {
		y = x;
		if (ins->value_ < x->value_) {
			x = x->left_;
		}
		else {
			x = x->right_;
		}
	}
	ins->parent_ = y;
	if (y == nil) {
		root = ins;
	}
	else if (ins->value_ < y->value_) {
		y->left_ = ins;
	}
	else {
		y->right_ = ins;
	}
	ins->left_ = ins->right_ = nil;
	ins->color_ = red;
	// todo  fixup
	RBInsertFixup(root, ins);
}

std::shared_ptr<node> CreateRB() {
	std::shared_ptr<node> root = nil;
	std::shared_ptr<node> x = CreateNode(red, 7);
	RBInsert(root, x);


	x = CreateNode(red, 4);
	RBInsert(root, x);

	x = CreateNode(red, 11);
	RBInsert(root, x);

	x = CreateNode(red, 3);
	RBInsert(root, x);


	
	//PrinTree(root);
	//std::cout << std::endl;

	return root;
}

//=============================================
// delete test
std::shared_ptr<node> RBMinimum(std::shared_ptr<node> n) {
	while (n->left_ != nil) {
		n = n->left_;
	}
	return n;
}

std::shared_ptr<node> RBMaximum(std::shared_ptr<node> n) {
	while (n->right_ != nil) {
		n = n->right_;
	}
	return n;
}

std::shared_ptr<node> RBSuccessor(std::shared_ptr<node> n) {
	if (n->right_ != nil)
		return RBMinimum(n->right_);
	std::shared_ptr<node> y = n->parent_;
	while (y != nil && n == y->right_) {
		n = y;
		y = y->parent_;
	}
	return y;
}

void RBTransplant(std::shared_ptr<node>& root,
	std::shared_ptr<node> u, std::shared_ptr<node> 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 RBDelete(std::shared_ptr<node>& root,std::shared_ptr<node> z) {
	if (root == nil || z == nil) {
		return;
	}
	std::shared_ptr<node> y = z;
	Color original_color = y->color_;
	std::shared_ptr<node> x;
	if (z->left_ == nil) {
		x = z->right_;
		RBTransplant(root, z, z->right_);
	}
	else if (z->right_ == nil) {
		x = z->left_;
		RBTransplant(root, z, z->left_);
	}
	else {
		y = RBMinimum(z->right_);
		original_color = y->color_;
		x = y->right_;
		if (y->parent_ == z)
			x->parent_ = y;
		else {
			RBTransplant(root,y,y->right_);
			y->right_ = z->right_;
			y->right_->parent_ = y;
		}
		RBTransplant(root,z,y);
		y->left_ = z->left_;
		y->left_->parent_ = y;
		y->color_ = z->color_;
	}
	if (y->color_ == black) {}
		//RBDeleteFixup(root,x);
		
}

//=============================================

int main()
{
	std::shared_ptr<node> root = CreateRB();
	PrinTree(root);
	std::cout << "===========================" << std::endl;
	
	RBDelete(root,root);
	PrinTree(root);
	std::cout << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << std::endl;
	


	return 0;
}



最后全部代码如下  增删 打印 调整功能 可运行调试

// rbTreeTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <memory>
#include <iostream>

using namespace std;

enum Color {
	red = 1,
	black
};

struct node {
	Color color_;
	std::shared_ptr<node> left_;
	std::shared_ptr<node> right_;
	std::shared_ptr<node> parent_;
	int value_;
	node() {
		left_ = right_ = parent_ = nullptr;
		value_ = -1;
		color_ = black;
	}
};

std::shared_ptr<node> nil(new node);


std::shared_ptr<node> CreateNode(Color color, int i) {
	std::shared_ptr<node> p(new node);
	p->color_ = color;
	p->left_ = nil;
	p->right_ = nil;
	p->parent_ = nil;
	p->value_ = i;
	return p;
}

void RightRotate(std::shared_ptr<node>& root, std::shared_ptr<node> x) {
	std::shared_ptr<node> y = x->left_;
	x->left_ = y->right_;
	if (y->right_ != nil)
		y->right_->parent_ = x;
	y->parent_ = x->parent_;
	if (x->parent_ == nil) {
		root = y;
	}
	else if (x->parent_->left_ == x) {
		x->parent_->left_ = y;
	}
	else {
		x->parent_->right_ = y;
	}

	y->right_ = x;
	x->parent_ = y;
}

void LeftRotate(std::shared_ptr<node>& root, std::shared_ptr<node> x) {
	std::shared_ptr<node> 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->parent_->left_ == x) {
		x->parent_->left_ = y;
	}
	else {
		x->parent_->right_ = y;
	}
	y->left_ = x;
	x->parent_ = y;
}

void PrinTree(std::shared_ptr<node> root) {
	if (root == nil) {
		std::cout << "nil:" << ":color-" << root->color_ << " ; " << std::endl << std::endl;
		return;
	}
	std::cout << root->value_ << ":color-" << root->color_ << "; address:" << root << std::endl;
	if (root->parent_ == nil) {
		std::cout << "parent_:" << "nil" << std::endl;
	}
	else {
		std::cout << "parent_:" << root->parent_->value_ << std::endl;
	}

	if (root->left_ == nil) {
		std::cout << "left_:" << "nil" << std::endl;
	}
	else {
		std::cout << "left_:" << root->left_->value_ << std::endl;
	}


	if (root->right_ == nil) {
		std::cout << "right_:" << "nil" << std::endl;
	}
	else {
		std::cout << "right_:" << root->right_->value_ << std::endl;
	}

	std::cout << std::endl;


	if (root->left_ != nil)
		PrinTree(root->left_);
	if (root->right_ != nil)
		PrinTree(root->right_);
}

void RBInsertFixup(std::shared_ptr<node>& root, std::shared_ptr<node> z) {
	while (z->parent_->color_ == red) {   //插入节点Z是红色 若Z父节点也是红色则需要调整
		if (z->parent_ == z->parent_->parent_->left_) {  // 父节点是左子树的情况
			std::shared_ptr<node> y = z->parent_->parent_->right_;
			if (y->color_ == red) {                   //  情况1
				z->parent_->color_ = black;
				y->color_ = black;
				z->parent_->parent_->color_ = red;
				z = z->parent_->parent_;
			}
			else {
				if (z == z->parent_->right_) {
					z = z->parent_;                  //  情况2
					LeftRotate(root, z);
				}
				z->parent_->color_ = black;           //  情况3
				z->parent_->parent_->color_ = red;
				RightRotate(root, z->parent_->parent_);
			}
		}
		else {// 父节点是右子树的情况 与上面判断处理均是镜像对称
			std::shared_ptr<node> y = z->parent_->parent_->left_;
			if (y->color_ == red) {
				z->parent_->color_ = black;
				y->color_ = black;
				z->parent_->parent_->color_ = red;
				z = z->parent_->parent_;
			}
			else {
				if (z == z->parent_->left_) {
					z = z->parent_;
					RightRotate(root, z);
				}
				z->parent_->color_ = black;
				z->parent_->parent_->color_ = red;
				LeftRotate(root, z->parent_->parent_);
			}
		}
	}//while (z->parent_->color_ == red)
	root->color_ = black;
}//function end

void RBInsert(std::shared_ptr<node>& root, std::shared_ptr<node> ins) {
	std::shared_ptr<node> y = nil;
	std::shared_ptr<node> x = root;

	while (x != nil) {
		y = x;
		if (ins->value_ < x->value_) {
			x = x->left_;
		}
		else {
			x = x->right_;
		}
	}
	ins->parent_ = y;
	if (y == nil) {
		root = ins;
	}
	else if (ins->value_ < y->value_) {
		y->left_ = ins;
	}
	else {
		y->right_ = ins;
	}
	ins->left_ = ins->right_ = nil;
	ins->color_ = red;
	// todo  fixup
	RBInsertFixup(root, ins);
}

std::shared_ptr<node> CreateRB() {
	
	std::shared_ptr<node> root = nil;
	std::shared_ptr<node> x = CreateNode(red, 15);
	RBInsert(root, x);


	x = CreateNode(red, 10);
	RBInsert(root, x);

	x = CreateNode(red, 20);
	RBInsert(root, x);

	x = CreateNode(red, 5);
	RBInsert(root, x);

	x = CreateNode(red, 13);
	RBInsert(root, x);

	x = CreateNode(red, 17);
	RBInsert(root, x);

	x = CreateNode(red, 25);
	RBInsert(root, x);
	

	return root;
}

//=============================================
// delete test
std::shared_ptr<node> RBMinimum(std::shared_ptr<node> n) {
	while (n->left_ != nil) {
		n = n->left_;
	}
	return n;
}

std::shared_ptr<node> RBMaximum(std::shared_ptr<node> n) {
	while (n->right_ != nil) {
		n = n->right_;
	}
	return n;
}

std::shared_ptr<node> RBSuccessor(std::shared_ptr<node> n) {
	if (n->right_ != nil)
		return RBMinimum(n->right_);
	std::shared_ptr<node> y = n->parent_;
	while (y != nil && n == y->right_) {
		n = y;
		y = y->parent_;
	}
	return y;
}

void RBTransplant(std::shared_ptr<node>& root,
	std::shared_ptr<node> u, std::shared_ptr<node> 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 RBDeleteFixup(std::shared_ptr<node>& root, std::shared_ptr<node> x) {
	while (x != root && x->color_ == black) {
		if (x == x->parent_->left_) {
			std::shared_ptr<node> w = x->parent_->right_;
			if (w->color_ == red) {
				w->color_ = black;
				x->parent_->color_ = red;
				LeftRotate(root, x->parent_);
				w = x->parent_->right_;
			}

			if (w->left_->color_ == black && w->right_->color_ == black) {
				w->color_ = red;
				x = x->parent_;
			}
			else {
				if (w->right_->color_ == black) {
					w->left_->color_ = black;
					w->color_ = red;
					RightRotate(root,w);
					w = x->parent_->right_;
				}
				w->color_ = x->parent_->color_;
				x->parent_->color_ = black;
				w->right_->color_ = black;
				LeftRotate(root,x->parent_);
				x = root;
			}
		}else {
			std::shared_ptr<node> w = x->parent_->left_;
			if (w->color_ == red) {
				w->color_ = black;
				x->parent_->color_ = red;
				RightRotate(root, x->parent_);
				w = x->parent_->left_;
			}

			if (w->right_->color_ == black && w->left_->color_ == black) {
				w->color_ = red;
				x = x->parent_;
			}
			else {
				if (w->left_->color_ == black) {
					w->right_->color_ = black;
					w->color_ = red;
					LeftRotate(root, w);
					w = x->parent_->left_;
				}
				w->color_ = x->parent_->color_;
				x->parent_->color_ = black;
				w->left_->color_ = black;
				RightRotate(root, x->parent_);
				x = root;
			}
		}
	}//while (x != root && x->color_ == black) 

	x->color_ = black;
}






void RBDelete(std::shared_ptr<node>& root,std::shared_ptr<node> z) {
	if (root == nil || z == nil)
		return;
	std::shared_ptr<node> y;
	std::shared_ptr<node> x;
	if (z->left_ == nil || z->right_ == nil) {
		y = z;
	}
	else {
		y = RBSuccessor(z);
	}

	if (y->left_ != nil) {
		x = y->left_;
	}
	else {
		x = y->right_;
	}
	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;
		}
	}

	if (y != z) {
		z->value_ = y->value_;
	}

	if (y->color_ == black) {
		//todo
		RBDeleteFixup(root,x);
	}
}



//=============================================

int main()
{
	std::shared_ptr<node> root = CreateRB();
	PrinTree(root);
	std::cout << "===========================" << std::endl;


	RBDelete(root,root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	RBDelete(root, root);
	PrinTree(root);
	std::cout << "===========================" << std::endl;

	return 0;
}

运行效果图


stecdeng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论学习--红黑树详解之删除(含完整红黑树代码)
荒野孤鹰
07-06 6356
前面我们讨论了红黑树的插入的实现，基本思想是分类讨论；然后分情况讨论以后我们发现插入操作调整函数只需要处理三种情况，并不是太复杂。但是删除操作会更复杂一点，因为二叉搜索树的删除操作本身就分成了多种情况，这样在执行删除操作后要处理的情况会更多；下面对于删除操作我们仍旧采取分类讨论的方法，将所有的情况梳理清楚后，就可以理解红黑树的删除调整函数的实质了。 下面先放出红黑树删除函数的代码：//红黑树删除函
算法导论中红黑树的实现
07-18
根据算法导论中红黑树的讲解，用C写了一个关于红黑树的建立，查询节点，插入，删除操作
《算法导论》学习（十六）----一文讲懂红黑树
weixin_52042488的博客
09-28 1213
本文将主要讲解红黑树，给出了红黑树复杂的插入删除操作的讲解
算法导论之红黑树的学习
superxlcr的博客
03-22 582
最近学习了二叉搜索树中的红黑树，感觉收获颇丰，在此写一篇文章小结一下学到的知识，顺便手写一下Java代码。 1.引言 先来讲讲什么是二叉搜索树，二叉搜索树有如下特点：他是以一颗二叉树（最多有两个子结点）来组织的，对于树中的某个节点，其左子树的所有元素均小于该节点，其右子树的元素均大于该节点。我们知道一颗有N个节点的二叉树的高度至少为lgN，然后在树上的操作都与其高度有关，因此限制树的高
算法导论-第13章-红黑树
最新发布
CSDN博客
05-21 244
第12章介绍了一棵高度为h的二叉搜索树，它可以支持任何一种基本动态集合操作，如SEARCHSUCCESSORMINIMUMMAXIMUMINSERT和DELETE等，其时间复杂度均为Oh。因此，如果搜素树的高度较低时，这些操作会执行的较快。然而，如果树的高度较高时，这些操作可能不比在链表上执行得快。（red-black tree）是“平衡”搜索树的一种，可以保证在最坏情况下基本动态集合操作得时间复杂度为Ologn。
算法导论红黑树C++实现
sinat_15652045的博客
07-28 339
用一个类封装了红黑树的一些属性，水平有限，敬请批评指正，谢谢！#include "Header.h"enum NodeColor { Red, Black };struct RBTreeNode{RBTreeNode* leftchild;RBTreeNode* rightchild;RBTreeNode* parents;//char color;NodeColor color;int key;
算法导论之红黑树
Mr_LeeY的博客
08-28 405
红黑树是特殊的搜索树，除了要满足搜索树外，还得满足color的要求。原则上说树的所有操作只有两种：插入和删除。 基本知识左旋、右旋、最小后继和节点替换不在重复。只针对插入和删除，说其内部原理。插入：插入一个元素时，由于红黑树根本也是一棵搜索树，所以可以先用搜索树的方式插入一个元素。由于在末尾添加的元素，如果置黑，可能导致其他树的黑路径长度少一。置红的话就不存在这个问题，只会存在两个红节点相邻的问题
算法导论——红黑树
WaterWin的博客
11-15 549
红黑树是二叉搜索树的一种特例，它对每个节点增加了一个颜色的属性，通过增加以下的条件使得这颗二叉树更加平衡： 1.每个节点或是红色的，或是黑色的。 2.根节点是黑色的。 3.每个叶节点是黑色的。 4.如果一个节点是红色的，那么它的两个子节点都是黑色的。 5.对每个节点，从该节点到其所有后代节点的简单路径上，均包含相同数目的黑色节点。 红黑树的插入和删除如果按照二叉树的处理，那么它的性质可能被破坏，那...
算法导论习题练习——红黑树的插入和删除
热门推荐
Lavi的专栏
12-17 1万+
题目13.3-2 将关键字 41、38、31、12、19、8 连续地插入一棵初始化为空的红黑树之后，试画出该结果树。 Solution： 13.4-3 在练习13.3-2中，我们将关键字41，38，31，12，19，8连续插入一棵初始为空的树中，从而得到一棵红黑树。请给出从该树中连续删除关键字8，12，19，31，38，41后的结果。 Solution： 首先，节点关键字为8的节点为红色
红黑树——算法导论
jiuweideqixu的博客
07-28 185
转自：https://www.cnblogs.com/dongkuo/p/4922058.html 1. 什么是红黑树 (1) 简介 上一篇我们介绍了基本动态集合操作时间复杂度均为O(h)的二叉搜索树。但遗憾的是，只有当二叉搜索树高度较低时，这些集合操作才会较快；即当树的高度较高（甚至一种极端情况是树变成了1条链）时，这些集合操作并不比在链表上执行的快。 于是我们需要构建出...
算法导论的红黑树的C++实现源码
03-29
在《算法导论》这本书中，红黑树是重要的章节之一，因为它提供了高效的数据存储和检索方法。下面我们将详细探讨红黑树的特性、C++实现的关键点以及测试验证的方法。 红黑树的主要特性： 1. 每个节点要么是红色，...
红黑树与区间树算法实现
04-08
总的来说，这个实验旨在让学习者深入理解红黑树和区间树的原理，以及如何在实际编程中应用它们。通过C++实现和graphviz的可视化，学生能够直观地看到数据结构的操作过程，这对于理解和掌握这些高级数据结构的概念至...
红黑树的C实现，算法导论的红黑树C实现
03-21
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972...《算法导论》这本书提供了详细的红黑树理论和实现指导，是学习红黑树的重要资源。通过阅读书中的代码和实践，可以深入理解红黑树的工作原理及其C语言实现细节。
c++ 计算cpu占用率
stecdeng的专栏
02-20 8734
计算CPU占用率就是获取系统总的内核时间 用户时间及空闲时间 其中空闲时间就是内核空转 所以内核时间包含空闲时间 然后计算 运行时间 = 内核时间 加 用户时间 减去 空闲时间 间隔时间 =  内核时间 加 用户时间 cpu使用率% = 运行时间 / 间隔时间 ; 无论单个进程cpu占用率还是系统整个cpu占用路 都是如此原理 核心代码就是如下几段
无盘工作站原理分析
stecdeng的专栏
02-26 6066
无盘系统就是用户使用的客户端机器没有硬盘 客户端向硬盘读写的内容均是通过网路从服务器获取 从而减少人力维护成本。而服务器更改配置和更新客户端的配置与硬盘中的内容，也只需要更改服务器上的镜像文件，提升维护效率。 由于我没接触过无盘的具体底层开发 以下只是我对无盘的猜测理解 1 无盘的启动 有硬盘的客户机 从机器上电后，启动BIOS，开始BIOS自检。通过自检后，bios找到硬盘上的
C语言版STL
stecdeng的专栏
04-20 4716
找到一个C语言实现的STL，目测似乎比C++版本的容易理解。没有太多不常用的技巧和难以理解的宏。而且贴心的提供了build in windows 的编译方式，为不同平台的学习者调试学习提供了便利。 而且也可以学习下C语言的设计模式。有空学习下。   libcstl是使用标准C编写的通用的数据结构和常用算法的库, 它模仿STL的接口形式, 包括序列容器,关联容器,容器适配器,迭代器,函数,
2016年，你读过的最好的IT技术书有哪几本？
stecdeng的专栏
02-14 2677
def 程序员 原文 https://www.zhihu.com/question/54350343 陈硕   等  54 人赞同了该回答 1 知乎 陈硕大牛的 服务器多线程编程muduo 输的好不好可能更多的在于适合不适合 尤其是技术书籍 如果你已经具有C++基础 对野指针和内存泄漏有自己的心得和疑惑 如果你已经具有网络编程基础 对实
红黑树算法详解：插入、删除与旋转
"红黑树算法(算法导论) 详解 【for_wind】" 红黑树是一种自平衡的二叉查找树（BST），由鲁道夫·贝尔在1972年提出，其名称来源于节点可能的颜色：红色或黑色。红黑树的主要目标是保持树的平衡，从而在插入、删除和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值