算法导论12通过继承二叉树实现红黑树

最新推荐文章于 2020-12-09 17:50:52 发布
最新推荐文章于 2020-12-09 17:50:52 发布
阅读量243 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34472273/article/details/79160385
版权

//Bitree.h

#ifndef __BITREE_HH__
#define __BITREE_HH__


template <typename T>
class node
{
public:
node<T> *p;
node<T> *left;
node<T> *right;
T key;
node(T key = T()):p(NULL),left(NULL),right(NULL),key(key){};
};


template <typename T>
class bitree
{
private:
node<T> *root;


public:
void Insert(T x);
void inordertraversal();
bitree():root(NULL){};
void Delete(T x);
node<T> *Serach(T x);
node<T> *MINMUM(node<T> *r);
node<T> *MAXMUM(node<T> *r);
void Transplant(node<T> *u, node<T> *v);
};


#include "Bitree.cpp"
#endif

//Bitree.cpp

#ifdef __BITREE_HH__


#include "Bitree.h"
#include <iostream>
#include <stack>
#include <stdlib.h>
using namespace std;


template <typename T>
node<T> *bitree<T>::MINMUM(node<T> *r)
{
node<T> *f;
f = r;
while(f->left != NULL)
f = f->left;
return f;
}
template <typename T>
node<T> *bitree<T>::MAXMUM(node<T> *r)
{
node<T> *f;
f = r;
while(f->right != NULL)
f = f->left;
return f;
}
template <typename T>
node<T> *bitree<T>::Serach(T x)
{
node<T> *t = root;
while(t != NULL)
{
if(x == t->key)
return t;
else if(x > t->key)
t = t->right;
else
t = t->left;
}
return NULL;
}
template <typename T>
void bitree<T>::Delete(T x)
{
node<T> *u,*y;
u = Serach(x);
if(u->left == NULL)
Transplant(u,u->right);
else if (u->right == NULL)
Transplant(u,u->left);
else
{
y = MINMUM(u->right);
if(y->p != u)
{
Transplant(y,y->right);
y->right = u->right;
y->right->p = y;
}
Transplant(u,y);
y->left = u->left;
y->left->p = y;
}
}


template <typename T>
void bitree<T>::Transplant(node<T> *u, node<T> *v)/*not update v.left v.right*/
{
if(u->p == NULL)
root = v;
else if(u == u->p->left)
u->p->left = v;
else
u->p->right = v;
if(v != NULL)
v->p = u->p;
}


template <typename T>
void bitree<T>::Insert(T x)
{
node<T> *t = root;
node<T> *f = NULL;
node<T> *n = new node<T>(x);
while(t != NULL)
{
f = t;
if(x > (t->key))
t = t->right;
else
t = t->left; 
}
if(f == NULL)
root = n;
else if(x > (f->key))
f->right = n;
else
f->left = n;
n->p = f;

}


template <typename T>
/* add an addition stack*/
void bitree<T>::inordertraversal()
{
stack<node<T>*> s;
node<T> *t = root;
while(t!=NULL || !s.empty())
{
while(t!=NULL)
{
s.push(t);
t = t->left;
}
if(!s.empty())
{
t = s.top();
s.pop();
cout<<t->key<<endl;
t = t->right;
}
}
}




#endif

//RBtree.h

#ifndef __RBTREE_HH__
#define __RBTREE_HH__


#include "Bitree.h"


template <typename T>
class RBnode:public node<T>
{
public:
RBnode<T> *p;
RBnode<T> *left, *right;
int color;//0 = black 1 = red
RBnode(T key = T()):node<T>(key),color(0){};
};


template <typename T>
class RBtree:public bitree<T>
{
private:
RBnode<T> *root;
RBnode<T> *nil;/*sentinel node*/
public:
void Leftrotate(RBnode<T> *a);
void Rightrotate(RBnode<T> *a);
void RBInsert(T x);
void RBInsertfix(RBnode<T> *a);
RBtree()//:nil(NULL),root(NULL)
{
root = NULL;
nil = new RBnode<T>(55);
};
void inordertraversal();
void Transplant(RBnode<T> *u, RBnode<T> *v);
void RBDelete(T x);
void RBDeletefix(RBnode<T> *x);
RBnode<T> *RBSerach(T x);
RBnode<T> *MINMUM(RBnode<T> *r);
};
#include "RBtree.cpp"
#endif

//RBtree.cpp

#ifdef __RBTREE_HH__


#include "RBtree.h"
using namespace std;


template <typename T>
void RBtree<T>::RBDeletefix(RBnode<T> *x)
{
RBnode<T> *w;
while(x != root && x->color == 0)
{
if(x == x->p->left)
{
w = x->p->right;
if(w->color == 1)
{
w->color = 0;
x->p->color = 1;
Leftrotate(x->p);
w = x->p->right;
}
if(w->left->color == 0 && w->right->color == 0)
{
w->color = 1;
x = x->p;
}
else if(w->right->color == 0)
{
w->left->color = 0;
w->color = 1;
Rightrotate(w);
w = x->p->right;
}
w->color = x->p->color;
x->p->color = 0;
w->right->color = 0;
Leftrotate(x->p);
x = root;
}
else
{
w = x->p->left;
if(w->color == 1)
{
w->color = 0;
x->p->color = 1;
Rightrotate(x->p);
w = x->p->left;
}
if(w->left->color == 0 && w->right->color == 0)
{
w->color = 1;
x = x->p;
}
else if(w->left->color == 0)
{
w->right->color = 0;
w->color = 1;
Leftrotate(w);
w = x->p->left;
}
w->color = x->p->color;
x->p->color = 0;
w->left->color = 0;
Rightrotate(x->p);
x = root;
}
}
x->color = 0;
}
template <typename T>
void RBtree<T>::RBInsertfix(RBnode<T> *a)
{
RBnode<T> *y;
while(a->p->color == 1)
{
if(a->p == a->p->p->left)
{
y = a->p->p->right;
if(y->color == 1)
{
a->p->color = 0;
y->color = 0;
a->p->p->color = 1;
a = a->p->p;
}
else 
{
if (a == a->p->right)
{
a = a->p;
Leftrotate(a);
}
a->p->color = 0;
a->p->p->color = 1;
Rightrotate(a->p->p);
}
}
else //if(a->p == a->p->p->right)
{
y = a->p->p->left;
if(y->color == 1)
{
a->p->color = 0;
y->color = 0;
a->p->p->color = 1;
a = a->p->p;
}
else 
{
if (a == a->p->left)
{
a = a->p;
Rightrotate(a);
}
a->p->color = 0;
a->p->p->color = 1;
Rightrotate(a->p->p);
}
}
}
root->color = 0;
}
template <typename T>
void RBtree<T>::Leftrotate(RBnode<T> *a)
{
RBnode<T> *y = a->right;
a->right = y->left;
if(y->left != nil)
{
y->left->p = a;
}
y->p = a->p;
if(a->p == nil)
{
root = y;
}
else if (a == a->p->left)
a->p->left = y;
else
a->p->right = y;
y->left = a;
a->p = y;
}
template <typename T>
void RBtree<T>::Rightrotate(RBnode<T> *a)
{
RBnode<T> *y = a->left;
a->left = y->right;
if(y->right != nil)
{
y->right->p = a;
}
y->p = a->p;
if(a->p == nil)
{
root = y;
}
else if (a == a->p->left)
a->p->left = y;
else
a->p->right = y;
y->right = a;
a->p = y;
}
template <typename T>
void RBtree<T>::RBInsert(T x)
{
RBnode<T> *t = root;
RBnode<T> *f = NULL;//nil
//cout<<nil->color;
RBnode<T> *n = new RBnode<T>(x);
while(t != NULL && t != nil)
{
f = t;
if(x > (t->key))
t = t->right;
else
t = t->left; 
}
if(f == NULL)
{
//nil->color = 0;
root = n;
}
else if(x > (f->key))
f->right = n;
else
f->left = n;


if(f == NULL)
{
n->p = nil;
}
else
n->p = f;
n->left = nil;
n->right = nil;
n->color = 1;
RBInsertfix(n);
}
template <typename T>
RBnode<T> *RBtree<T>::MINMUM(RBnode<T> *r)
{
RBnode<T> *f;
f = r;
while(f->left != NULL && f->left != nil)
f = f->left;
return f;
}


template <typename T>
RBnode<T> *RBtree<T>::RBSerach(T x)
{
RBnode<T> *t = root;
while(t != NULL && t != nil)
{
if(x == t->key)
{
cout<<"find";
return t;
}
else if(x > t->key)
t = t->right;
else
t = t->left;
}
return NULL;
}


template <typename T>
void RBtree<T>::RBDelete(T x)
{
RBnode<T> *u, *y;
RBnode<T> *z;// = new RBnode<T>;
z = RBSerach(x);
y = z;
int y_original_color = z->color;
if(z->left == nil)
{
u = z->right;
Transplant(z,z->right);
}
else if (z->right == nil)
{
u = z->left;
Transplant(z,z->left);
}
else
{
y = MINMUM(z->right);
y_original_color = y->color;
u = y->right;
if(y->p == z)
{
u->p = y;
}
else
{
Transplant(y,y->right);
y->right = z->right;
y->right->p = y;
}
Transplant(z,y);
y->left = z->left;
y->left->p = y;
y->color = z->color;
}
if(y_original_color == 0)
{
RBDeletefix(u);
cout<<"fix";
}
}


template <typename T>
void RBtree<T>::Transplant(RBnode<T> *u, RBnode<T> *v)
{
if(u->p == nil)
root = v;
else if (u == u->p->left)
u->p->left = v;
else
u->p->right = v;
v->p = u->p;
}


template <typename T>
/* add an addition stack*/
void RBtree<T>::inordertraversal()
{
stack<RBnode<T>*> s;
RBnode<T> *t = root;
while((t != NULL || !s.empty()))
{
while(t != NULL)// && t != nil)
{
s.push(t);
t = t->left;
}
if(!s.empty())
{
t = s.top();
s.pop();
cout<<t->key<< t->color<<endl;
t = t->right;
}
}
}


#endif

//main.cpp

#include <iostream>
#include <stack>
#include <stdlib.h>
using namespace std;


#include "/home/yuxiaolei/Desktop/Introduction_to_algorithms/12/RBtree.h"
#include "Bitree.h"


int main()
{
bitree<int> bt;
RBtree<int> RB;
//node<int> *s;
//srand(time(NULL));
int x[10] = {5,8,2,4,6,7,1,9,3,0};
int y[5] = {5,8,2,4,6};
int z[6] = {5,8,2,4,6,9};
for(int i = 0; i < 6; ++i)
{
RB.RBInsert(z[i]);
}
RB.inordertraversal();
RB.RBDelete(8);
RB.inordertraversal();
return 0;
}

Yoxla
关注
真c++ 从二叉树到红黑树（2）之二叉树基类
天翔龙闪
05-23 317
此文章为从二叉树到红黑树系列文章的第二节，主要介绍介绍二叉树抽象基类的基本组成。为后续BST，AVL和RedBlack做好铺垫
java 继承树设计_设计继承二叉树类的二叉搜索树类
weixin_30151565的博客
02-19 123
我在c＃中创建了一个二叉搜索树类 . 我是通过从二叉树类派生来创建类的，因为二叉搜索树是一种二叉树 . 所以我将在二叉树类中包含大多数常用方法，并在二叉搜索树中共享它们 .现在：BinaryTree类有两个方法“AddToLeft”和“AddToRight”方法，这两个方法必须能够在这个类之外访问，即在Main方法中将节点添加到二叉树中 . 所以我把它们公之于众 . 并且这两个方法也应该可以在二进...
二叉树
网瘾少年沐安涂
11-16 1969
参考博客浅谈数据结构-二叉树 二叉树的好处（应用） 用递归方法建立二叉树 数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现 Java中二叉树存储结构实现 二叉树的好处（应用） 二叉树可以解决什么问题 二叉树（binary tree）-重要性目录 特点 特殊二叉树及其特点 二叉树性质 二叉树遍历 二叉树建立 二叉树作用 特点二叉树是
《算法导论》第十三章——红黑树
T的博客
10-24 299
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！   红黑树是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn)。 13.1红黑树的性质   红黑树是一棵二叉搜索树，它在每个结点上增加了一份...
算法导论学习--红黑树详解之删除(含完整红黑树代码)
荒野孤鹰
07-06 6384
前面我们讨论了红黑树的插入的实现，基本思想是分类讨论；然后分情况讨论以后我们发现插入操作调整函数只需要处理三种情况，并不是太复杂。但是删除操作会更复杂一点，因为二叉搜索树的删除操作本身就分成了多种情况，这样在执行删除操作后要处理的情况会更多；下面对于删除操作我们仍旧采取分类讨论的方法，将所有的情况梳理清楚后，就可以理解红黑树的删除调整函数的实质了。 下面先放出红黑树删除函数的代码：//红黑树删除函
[算法导论笔记]--红黑树
Alfeim的博客
04-27 264
一.什么是红黑树 红黑树是一棵二叉搜索树，其在每个结点上增加了一个存储位来表示颜色，可以是红(red)或者黑(black)。通过任何一条从"根到叶子的简单路径"上的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的。红黑树是一种平衡二叉树。 红黑树的基本性质 (1)每个结点要么是红色的，要么是黑色的(废话..) (2)根结点是黑色的 (3)叶子结点是黑色的(也可...
算法导论.rar
05-07
2. **数据结构**：数组、链表、栈、队列、树（二叉树、平衡树、红黑树）、图等基本数据结构的定义、操作和应用，数据结构的选择对算法效率有着重要影响。 3. **动态规划**：通过解决子问题来构建全局最优解的方法，...
算法导论 - 红黑树及红黑树平衡的详细解析个人理解
有问题 ! 请留言 !
01-17 1275
算法导论 - 红黑树及红黑树平衡的详细解析个人理解 红黑树一种数据结构,效率极高,插入和删除的操作的时间复杂度都是logn,虽然红黑树对于前端来说基本很少用到,但是作为一个目标是全栈的程序员来说,算法的学习是很必要的,so … 图是"借的",字都是自己打的,也依据了自己的理解 数组 链表 数组特点是元素在内存中紧挨着存储，因而优点是定位快（O(1)），缺点是插入删除慢（O(n)）；而链表则不...
深入理解二叉树（超详细）
Kalton的博客
09-17 2万+
二叉树（Binary Tree） 回顾 在前面的文章 — 二叉树前奏中，我们对于二叉树的一些基本概念进行了回顾，同时对比了线性结构与树形结构，总结了一些常见的二叉树的性质，像二叉树，真二叉树，完全二叉树，以及满二叉树等等，但是，我们仅仅是在概念上对于二叉树有所了解，并没有进行编码工作，今天来完善一下这一步的操作 直接进入二叉树的设计与编码，如果你对于二叉树的概念以及性质不了解的话，可以回去翻翻 二叉树前奏，熟悉一下，因为编码实际上就是对于二叉树性质的一个体现 设计 属性与节点 首先，我们的二叉树是用来存放元
二叉查找树深度讲解
TheSevenSky
07-22 3697
* 二叉查找树(BST)(自己动手写API系列三)* 这次的教学可能会比较长一点 所以也希望大家可以耐心看 下面的代码里面会贴一些讲解 觉得烦也没事 最下面我会把全部的代码贴出来 你可以拿纯净的 然后这次的语言我还是 选择用java 如果不会Java的 不着急要代码 你也可以耐心看学习 用你学过的语言去实现以下 毕竟语言只是工具 好了 先看一下类名 public clas...
红黑树总结&C++代码实现
cat_of_landlord的博客
12-09 409
目录红黑树特性旋转左旋右旋插入算法 学红黑树的时候感觉很有意思,所以自己手打了一棵红黑树,这一篇粗浅写一下对红黑树插入删除过程中调整操作的归纳和理解. 红黑树特性 红黑树是一种保证动态平衡的BST，避免了BST退化成线性表。STL中的红黑树也是继承于BST的。因此红黑树的查找和删除等操作与BST类似。 满足以下条件的BST是红黑树： 每个结点要么红要么黑 根节点为黑色 所有扩充结点的外部节点为空，且视为黑色 若一个结点为红，则他的两个子结点为黑（不允许连续红） 结点到其子孙外部结点的每条简单路径都包含相同
二叉树的详解与实现
热门推荐
注意路标
08-18 16万+
简介 二叉树的相关概念，如，树高度，节点层数，节点度数，路径，叶节点，分支节点，根节点，父节点，左节点，右节点，兄弟节点，祖先节点，子孙节点，左子树，右子树等基本概念，不再赘述。 二叉树分类 1、完全二叉树 若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 一维数组可以作为完全二叉树...
5153-微信小程序个人日程安排微信小程序的实现+ssm（源码+数据库+lun文）.zip
最新发布
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
旅行智能推荐系统.zip
09-15
本项目旨在开发一个智能旅行推荐系统。该系统利用Yelp数据集，采用混合的内容推荐和协同过滤方法为用户提供个性化的旅行建议。通过整合React前端和fla后sk端技术，系统提供了一个无缝的用户体验，能够分析用户偏好和行为，并根据这些信息进行定制化的推荐。此外，该系统具有适应性，随着用户交互的持续进行，能够不断完善推荐结果。整体而言，这是一个结合了先进推荐算法和现代化Web技术的先进项目，旨在为用户提供更加智能和个性化的旅行建议。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
算法导论课后习题详解
2. **数据结构**：数据结构是算法的基础，可能包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）以及哈希表等。课后题可能涉及这些数据结构的操作和优化。 3. **排序与搜索**：排序算法如冒泡排序、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值