演算法導論紅黑樹學習刪除(四)

阿新 • • 發佈：2019-02-12

學習演算法還是建議看看演算法導論

演算法導論第三版如果不看數學推導僅看虛擬碼難度還是適中

本系列只是記錄我的學習心得和虛擬碼轉化程式碼的過程

深入學習還是建議大家看看演算法書籍教程更加系統。

本文參考演算法導論第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;
}

執行效果圖

演算法導論紅黑樹學習刪除(四)

學習演算法還是建議看看演算法導論演算法導論第三版如果不看數學推導僅看虛擬碼難度還是適中本系列只是記錄我的學習心得和虛擬碼轉化程式碼的過程深入學習還是建議大家看看演算法書籍教程更加系統。本文參考演算法導論第13章節紅黑樹程式碼由本人寫成

學習演算法導論——紅黑樹旋轉插入和刪除

參考：《演算法導論》紅黑樹是一棵二叉搜尋樹，每個節點有一個標誌位表示顏色，該顏色可以是紅(RED)或黑(BLACK)。通過對任何一條從根到葉子的簡單路徑上各點的顏色進行約束，就能確保沒有一條路徑會比其他路徑長出2倍，因而是近似於平衡的。紅黑樹每個節點有5個屬性，c

演算法導論-紅黑樹基本概念

剛剛接觸到紅黑樹的時候，感覺很奇怪，二叉樹已經很好用了，為什麼要發明紅黑樹？？看到演算法導論的目錄才明白，二叉樹在執行查詢，刪除操作的時候，時間複雜度為O（h）,這時間複雜度與二叉樹的高度有關，如果二

演算法導論——紅黑樹插入演算法C++實現

一、概念紅黑樹是一棵二叉搜尋樹，它在每個結點上增加了一個儲存位來表示結點的顏色，可以是RED或BLACK。通過對任何一條從根到葉子的簡單路徑上各個結點的顏色進行約束，紅黑樹確保沒有一條路徑會比其他路徑長2倍，因而是近似於平衡的。二、定義一棵紅黑樹是滿足下面紅黑性

【資料結構與演算法】之紅黑樹 --- 第十四篇

樹是一種非線性資料結構，這種資料結構要比線性資料結構複雜的多，因此分為三篇部落格進行講解：第一篇：樹的基本概念及常用操作的Java實現（二叉樹為例）第二篇：二叉查詢樹第三篇：紅黑樹第三篇：紅黑樹開篇說明：對於紅黑樹的學習，近階段只需要掌握這種資料結構的思想、特點、適

紅黑樹學習筆記 — (1) 定義、插入、刪除

紅黑樹（RBT）本質上是一種二叉查詢樹（BST），但它在二叉查詢樹的基礎上額外添加了一個標記（顏色），同時具有一定的規則。這些規則使紅黑樹保證了一種平衡，插入、刪除、查詢的最壞時間複雜度都為 O(logn)。五個特性每個節點是黑色或紅色根節點（roo

演算法--我的紅黑樹學習過程

其他更多java基礎文章： java基礎學習(目錄) 學習資料：紅黑樹詳細分析，看了都說好紅黑樹刪除操作碼圖並茂紅黑樹紅黑樹從頭至尾插入和刪除結點的全程演示圖閱讀前提在研究集合類原始碼的時候，發現Map，Set裡面不少用到紅黑樹，為了能夠更順利的學習原始碼。我決定把紅黑樹知識惡

經典演算法：紅黑樹的C語言實現 ( 插入、刪除 )

紅黑樹這個東西可以說是傳說中的“牛刀”了，一般的小場合是用不上滴，但是我覺得還是很重要，所以花了將近三天，對照著演算法導論，把紅黑樹給實現出來了，有關紅黑樹的資料很多，大家可以在網上先搜一下，最好是能親自看看演算法導論，把其中的case之間的轉換弄清楚，弄清楚後看演算法就很簡

【演算法】紅黑樹的講解及插入刪除演算法實現原理

【轉】【經典】導讀：　　linux核心中的使用者態地址空間管理使用了紅黑樹(red-black tree)這種資料結構，我想一定有許多人在這種資料結構上感到困惑，我也曾經為此查閱了許多資料以便了解紅黑樹的原理。最近我在一個外國網站上看到一篇講解紅黑樹的文章，覺得相當不錯，不敢獨享，於是翻譯成中文供

學習之旅-紅黑樹之刪除

前人栽樹，後人乘涼。關於這樣紅黑樹的帖子已經很多。我就不再重複造輪子了。我自己發現一個刪除說的很好的部落格，連結：http://gengning938.blog.163.com/blog/static/1282253812011420103852696/ 我只是說說自己的理

紅黑樹之刪除節點

易到特定 1-1 enter 來看紅孩子簡單 code 排序紅黑樹之刪除節點上一篇文章中講了如何向紅黑樹中添加節點，也順便創建了一棵紅黑樹。今天寫寫怎樣從紅黑樹中刪除節點。相比於添加節點，刪除節點要復雜的多。不過我們慢慢梳理，還是能夠弄明白的。回顧一下紅黑樹的

紅黑樹的刪除

TP ID 由於 mage ima .com 17. 過程有一個紅黑樹的刪除共有12種情況，設要刪除的節點為Z: 1.Z為根且沒有孩子直接刪除，將根賦空 2.Z為根有一個紅孩子（由於第4條性質一定為紅孩子）將孩子顏色->黑，當做新的根，刪除節

紅黑樹學習

原博：點選開啟連結紅黑樹的插入：先按照二叉搜尋樹的方式插入，預設顏色為紅色（為什麼不是黑色？）然後調整，使整棵樹更加均衡 eg: 這是一顆剛插入元素4的紅黑樹當前結點4，當前結點的父結點是紅色，祖父結點的另一個子結點（叔叔結點）是紅色。做法：將當前節點的父

【演算法】紅黑樹插入資料的情況與實現（三）

大家如果有玩魔方，我相信是可以理解我說的東西的，轉魔方就是先把第一面轉出來，然後把第一面作為底面，然後根據遇見的情況來轉魔方（是有公式的）該系列到現在暫只有3篇文章：【演算法】紅黑樹（二叉樹）概念與查詢（一）：https://blog.csdn.net/lsr40/ar

【演算法】紅黑樹插入資料（變色，左旋、右旋）（二）

本人菜雞一隻，正在更新紅黑樹系列的文章。該系列到現在暫只有3篇文章：【演算法】紅黑樹（二叉樹）概念與查詢（一）：https://blog.csdn.net/lsr40/article/details/85230703 【演算法】紅黑樹插入資料（變色，左旋、右旋）（二

【演算法】紅黑樹（二叉樹）概念與查詢（一）

誒，演算法這個東西，其實沒那麼簡單，但是也沒那麼難。紅黑樹，其實已經有很多大佬都整理過了，而且文章部落格都寫得超好，我寫這篇文章的目的是：自己整理一次，這些知識才是自己的，否則永遠是別人的~ 該系列到現在暫只有3篇文章：【演算法】紅黑樹（二叉樹）概念與查詢（一）：h

資料結構與演算法：紅黑樹（Red Black Tree）

一、簡介紅黑樹（Red Black Tree）是一棵二叉查詢樹，在每個節點增加一個屬性表示節點顏色，值為紅色（Red）或者黑色（Black）。紅黑樹也是“平衡”樹中的一種，通過對任何一條從根到葉子的路徑上各個節點的顏色來進行約束，確保沒有一條路徑會比其他

演算法之紅黑樹簡單理解和定義

#include <stdio.h> #include <stdlib.h> #include <time.h> #define MAXSIZE 1000 typedef int ElemType; #define RED 0 #define BLACK

紅黑樹之刪除操作

。現在我們來看紅黑性質的恢復過程：如果Y指向的節點是個紅色節點，那麼直接刪除掉Y以後，紅黑性質不會被破壞。操作結束。如果Y指向的節點是個黑色節點，那麼就有幾條紅黑性質可能受到破壞了。首先是包含Y節點的所有路徑，黑高度都減少了一（第５條被破壞）。其次，如果Y的有紅色子節點，Y又有紅

【資料結構與演算法】紅黑樹常被問到的問題

1.stl中的set底層用的什麼資料結構？ 2.紅黑樹的資料結構怎麼定義的？ 3.紅黑樹有哪些性質？ 4.紅黑樹的各種操作的時間複雜度是多少？ 5.紅黑樹相比於BST和AVL樹有什麼優點？ 6.紅黑樹相對於雜湊表，在選擇使用的時候有什麼依據？ 7.如何擴充套件

演算法導論 紅黑樹 學習 刪除(四)

相關推薦

演算法導論紅黑樹學習刪除(四)