算法导论 红黑树 学习 插入(三)

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

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

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

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

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

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

代码由本人写成

转载请标明出处

 

现在说插入元素

红黑树的插入跟二叉树的插入差不多 首先是查找合适的位置

插入 insert

注意 插入节点的颜色肯定是红色的

插入后由于有颜色的限制 要进行调整 insertfix

伪代码见 算法导论


代码和插入步骤图如下:

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);
}
先不管插入后的颜色调整 来看看插入的步骤是怎么样的 

#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 PrinTree(std::shared_ptr<node> root);
 
 
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);
}
 
void PrinTree(std::shared_ptr<node> root) {
    if (root == nil) {
        return;
    }
    std::cout << root->value_ << " ";
    if (root->left_ != nil)
        PrinTree(root->left_);
    if (root->right_ != nil)
        PrinTree(root->right_);
}
 
int main()
{
    std::shared_ptr<node> root = CreateNode(black, 15);
    root->parent_ = nil;
 
    std::shared_ptr<node> x = root;
    std::shared_ptr<node> ins = CreateNode(black, 10);
    RBInsert(x, ins);
     
    ins = CreateNode(black, 20);
    RBInsert(x, ins);
 
    ins = CreateNode(black, 25);
    RBInsert(x, ins);
 
    ins = CreateNode(black, 12);
    RBInsert(x, ins);
 
    ins = CreateNode(black, 17);
    RBInsert(x, ins);
 
 
    PrinTree(root);
    std::cout << std::endl;
 
 
    return 0;
}

　　我们依次插入15 10 20 25 12 17


但是插入节点的时候，各个节点的颜色可能会破坏部分红黑树的性能

所以需要进行调节

分为三种情况

第一种情况

插入的红色节点Z 其父节点的兄弟节点即叔节点也是红色

那么将z节点的父节点和叔节点都改为黑色  z节点的父节点的父节点改为红色

Z节点设置为z节点的父节点的父节点 再次进行调整FIXUP


y是z的叔节点 红色 

那么 将 5号节点 、8号节点(y)改黑 7号改红 

z节点为7号节点 再次进行判断调整

 

第二种情况和第三种情况类似

z的叔节点y是黑色的 且z节点是右孩子

z的叔节点y是黑色的 且z节点是左孩子


调整的伪代码和代码如下:


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

下面是全部代码

// 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_ << std::endl;
	}

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


	if (root->right_ == nil) {
		std::cout << "right_:" << "nil" << std::endl;
	}
	else {
		std::cout << "right_:" << root->right_ << 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);
}

void TestInsert() {
	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);

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

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

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

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

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

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

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

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

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

	x = CreateNode(red, 20);
	RBInsert(root, x);
	PrinTree(root);
	std::cout << std::endl;
}

int main()
{
	TestInsert();

	return 0;
}




运行效果



stecdeng
关注
专栏目录
算法导论学习---红黑树详解之插入(C语言实现)
荒野孤鹰
07-05 4459
前面我们学习二叉搜索树的时候发现在一些情况下其高度不是很均匀，甚至有时候会退化成一条长链,所以我们引用一些”平衡”的二叉搜索树。红黑树就是一种”平衡”的二叉搜索树，它通过在每个结点附加颜色位和路径上的一些约束条件可以保证在最坏的情况下基本动态集合操作的时间复杂度为O(nlgn).下面会总结红黑树的性质，然后分析红黑树的插入操作，并给出一份完整代码。先给出红黑树的结点定义：#define RED 1
算法导论中红黑树的实现
07-18
根据算法导论中红黑树的讲解，用C写了一个关于红黑树的建立，查询节点，插入，删除操作
算法导论——红黑树插入算法C++实现
xiaowang627的博客
05-07 6273
红黑树图文详解及其C++语言实现
算法导论习题练习——红黑树的插入和删除
热门推荐
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的节点为红色
《算法导论》第十三章——红黑树
T的博客
10-24 301
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！   红黑树是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn)。 13.1红黑树的性质   红黑树是一棵二叉搜索树，它在每个结点上增加了一份...
算法导论之红黑树的学习
superxlcr的博客
03-22 605
最近学习了二叉搜索树中的红黑树，感觉收获颇丰，在此写一篇文章小结一下学到的知识，顺便手写一下Java代码。 1.引言 先来讲讲什么是二叉搜索树，二叉搜索树有如下特点：他是以一颗二叉树（最多有两个子结点）来组织的，对于树中的某个节点，其左子树的所有元素均小于该节点，其右子树的元素均大于该节点。我们知道一颗有N个节点的二叉树的高度至少为lgN，然后在树上的操作都与其高度有关，因此限制树的高
《算法导论》学习（十六）----一文讲懂红黑树
最新发布
weixin_52042488的博客
09-28 1914
本文将主要讲解红黑树，给出了红黑树复杂的插入删除操作的讲解
实现算法导论第三版中红黑树插入算法
dreamcs的专栏
05-15 726
#include #include #include #include #include enum RBNODE_COLOR { RBNODE_COLOR_RED = 0, RBNODE_COLOR_BLACK }; struct RBNode { RBNode * p; RBNode * left; RBNode * right; int key; enum
【算法导论】红黑树详解之插入
yygr的博客
02-11 2068
https://blog.csdn.net/cyp331203/article/details/42677833         红黑树是建立在二叉查找树的基础之上的，关于二叉查找树可以参看【算法导论】二叉搜索树的插入和删除和【算法导论】二叉树的前中后序非递归遍历实现。对于高度为h的二叉查找树而言，它的SEARCH、INSERT、DELETE、MINIMUM、MAXIMUM等操作的时间复杂度均为O(h)。所以
算法导论 红黑树 学习 插入(三) 图文
weixin_30635053的博客
02-14 56
学习算法 还是建议看看算法导论 算法导论第三版 如果不看数学推导 仅看伪代码 难度还是适中 本系列只是记录我的学习心得 和伪代码转化代码的过程 深入学习 还是建议大家看看算法书籍 教程更加系统。 本文参考算法导论第13章节 红黑树 代码由本人写成 转载请标明出处 现在说插入元素 红黑树的插入跟二叉树的插入差不多 首先是查找合适的位置 插入 insert 注意 插入节点的颜...
算法导论的红黑树的C++实现源码
03-29
在《算法导论》这本书中，红黑树是重要的章节之一，因为它提供了高效的数据存储和检索方法。下面我们将详细探讨红黑树的特性、C++实现的关键点以及测试验证的方法。 红黑树的主要特性： 1. 每个节点要么是红色，...
c++ 计算cpu占用率
stecdeng的专栏
02-20 8780
计算CPU占用率就是获取系统总的内核时间 用户时间及空闲时间 其中空闲时间就是内核空转 所以内核时间包含空闲时间 然后计算 运行时间 = 内核时间 加 用户时间 减去 空闲时间 间隔时间 =  内核时间 加 用户时间 cpu使用率% = 运行时间 / 间隔时间 ; 无论单个进程cpu占用率还是系统整个cpu占用路 都是如此原理 核心代码就是如下几段
无盘工作站原理分析
stecdeng的专栏
02-26 6107
无盘系统就是用户使用的客户端机器没有硬盘 客户端向硬盘读写的内容均是通过网路从服务器获取 从而减少人力维护成本。而服务器更改配置和更新客户端的配置与硬盘中的内容，也只需要更改服务器上的镜像文件，提升维护效率。 由于我没接触过无盘的具体底层开发 以下只是我对无盘的猜测理解 1 无盘的启动 有硬盘的客户机 从机器上电后，启动BIOS，开始BIOS自检。通过自检后，bios找到硬盘上的
C语言版STL
stecdeng的专栏
04-20 4764
找到一个C语言实现的STL，目测似乎比C++版本的容易理解。没有太多不常用的技巧和难以理解的宏。而且贴心的提供了build in windows 的编译方式，为不同平台的学习者调试学习提供了便利。 而且也可以学习下C语言的设计模式。有空学习下。   libcstl是使用标准C编写的通用的数据结构和常用算法的库, 它模仿STL的接口形式, 包括序列容器,关联容器,容器适配器,迭代器,函数,
2016年，你读过的最好的IT技术书有哪几本？
stecdeng的专栏
02-14 2682
def 程序员 原文 https://www.zhihu.com/question/54350343 陈硕   等  54 人赞同了该回答 1 知乎 陈硕大牛的 服务器多线程编程muduo 输的好不好可能更多的在于适合不适合 尤其是技术书籍 如果你已经具有C++基础 对野指针和内存泄漏有自己的心得和疑惑 如果你已经具有网络编程基础 对实
主机性能监控之wmi 获取系统信息及内存性能信息
stecdeng的专栏
02-20 2105
欢迎转帖 请保持文本完整并注明出处   这里参考了http://www.cnblogs.com/lxcsmallcity/archive/2009/10/11/1580803.html  使用了PYTHON 和 vc 进行了调用WMI的代码编写 通过搜索和查看MSDN 可以找到WMI的基本用法 其实主要是WMI接口的初始化 使用 释放的过程 然后就是查找MSDN
状态机学习 解析四则运算式 语法分析
stecdeng的专栏
02-20 1543
将四则运算拆分成一个个数字和符号后 就进行运算分析 使用以下语法规则:(参考《自编编程语言》) expression： #pragma once #include #include #include enum TokenType { BAD_TOKEN, NUM_TOKEN, ADD_TOKEN, SUB_T
磁盘保护原理简介
stecdeng的专栏
03-03 1484
磁盘保护确保用户在正常使用电脑的情况下，所有保护分区的操作在重启系统后都会恢复，达到预防病毒、保护数据的目的。 用户的角度来看，可能会觉得很神奇。想实现这个功能，其实需要一个磁盘过滤程序，对磁盘的操作进行过滤和区分操作。 写入操作。应用程序操作某个文件，对文件进行写入改动操作，最后会对应到，写入改动硬盘上的某些扇区。而磁盘保护程序会过滤检测到这些扇区操作，将写入转移到其它位置，而不是真正写入到
红黑树算法详解：插入、删除与旋转
"红黑树算法(算法导论) 详解 【for_wind】" 红黑树是一种自平衡的二叉查找树（BST），由鲁道夫·贝尔在1972年提出，其名称来源于节点可能的颜色：红色或黑色。红黑树的主要目标是保持树的平衡，从而在插入、删除和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值