二叉树与红黑树

最新推荐文章于 2022-10-15 22:03:48 发布
最新推荐文章于 2022-10-15 22:03:48 发布
阅读量71 收藏
点赞数
分类专栏： Linux C/C++服务器/架构师
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41952309/article/details/116357897
版权

二叉树与红黑树

红黑树使用？

  • key-value 查找性能较快 O(logn)
  • 通过中序遍历 使用这两种方式

红黑树如何实现？

  • 二叉排序树 会退化成链表 查找效率变慢 由此引入红黑树概念 同样的节点进来要么覆盖要么丢弃

二叉排序树的实现代码

#include <stdio.h>
#include <stdlib.h>

// 二叉树定义

#if 0
//树的结构与业务没有分离  业务与算法未分离
struct bstree_node {
    int data;      // key 
    struct bstree_node *left; 
    struct bstree_node *right;

    // value
    long start;
    long end;
};

struct bstree {  //
    struct bstree_node *root;
};

struct bstree *tree; // 指向一棵树

#else

typedef int KEY_VALUE;

#define BSTREE_ENTRY(name, type) \
    struct name {   \
        struct type *left;      \
        struct type *right;     \
    }

// 协程 {就绪 等待 休眠}
struct bstree_node {
    BSTREE_ENTRY(, bstree_node) bst; //
    //BSTREE_ENTRY(, bstree_node) wait;
    //BSTREE_ENTRY(, bstree_node) sleep;
    KEY_VALUE key;
    // void *value; //不建议使用 

};
struct bstree {
    struct bstree_node *root;
};
#endif

struct bstree_node *bstree_create_node(KEY_VALUE key) {

    struct bstree_node *node = (struct bstree_node *)malloc(sizeof(struct bstree_node));
    
    if (node == NULL) {
        return NULL;
    } 
    node->key = key;
    node->bst.left = node->bst.right = NULL;

    return node;
}

int bstree_insert(struct bstree *tree, KEY_VALUE key) {

    if (tree == NULL) return -1;
    
    if (tree->root == NULL) {
        tree->root = bstree_create_node(key);
        return 0;
    }

    struct bstree_node *node = tree->root;
    struct bstree_node *tmp = tree->root;   // tmp 与node 一个指向父结点 一个指向子结点

    while (node != NULL) {
        tmp = node;
        if (key < node->key) {
            node = node->bst.left;
        } else if (key > node->key) {
            node = node->bst.right;
        } else {
            // 可处理 可不处理
            // ...
            return 1;
        }
    }
    // tmp --> bstree_node
    // node == NULL
    if (key < tmp->key) {
        tmp->bst.left = bstree_create_node(key);
    } else {
        tmp->bst.right = bstree_create_node(key);
    }

    return 0;
}

int bstree_traversal(struct bstree_node *node) {

    if (node == NULL) return 0;
    
    bstree_traversal(node->bst.left);
    printf("%4d", node->key);
    bstree_traversal(node->bst.right);

    return 0;
}

#define ARRAY_LENGTH 15

int main() {
    
    int key[ARRAY_LENGTH] = {24, 65, 29, 98, 67, 12, 35, 87, 65, 87, 43, 90, 34, 22, 80};

    struct bstree tree = {0};
    int i = 0;
    for (i = 0; i < ARRAY_LENGTH; i++) {
        bstree_insert(&tree, key[i]);
    }
    bstree_traversal(tree.root);
    printf("\n");

    return 0;
}

红黑树

定义

  • 每个结点是红的或者黑的

  • 根结点是黑的

  • 每个叶子结点是黑的，叶子结点都隐藏

  • 如果一个结点是红的，则它的两个儿子都是黑的

  • 对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-73aVIaVI-1619966632115)(E:\BaiduNetdiskDownload\image-20210501171904546.png)]

在插入一个结点以前，是一个红黑树，插入结点的颜色是红色更容易满足红黑树的性质 。

哪些条件下需要进行调整？插入结点的父结点是红色的。违背性质4的时候需要进行调整。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define RED				1
#define BLACK 			2

typedef int KEY_TYPE;

typedef struct _rbtree_node {
	unsigned char color;
	struct _rbtree_node *right;
	struct _rbtree_node *left;
	struct _rbtree_node *parent;
	KEY_TYPE key;
	void *value;
} rbtree_node;

typedef struct _rbtree {
	rbtree_node *root;
	rbtree_node *nil;
} rbtree;

rbtree_node *rbtree_mini(rbtree *T, rbtree_node *x) {
	while (x->left != T->nil) {
		x = x->left;
	}
	return x;
}

rbtree_node *rbtree_maxi(rbtree *T, rbtree_node *x) {
	while (x->right != T->nil) {
		x = x->right;
	}
	return x;
}

rbtree_node *rbtree_successor(rbtree *T, rbtree_node *x) {
	rbtree_node *y = x->parent;

	if (x->right != T->nil) {
		return rbtree_mini(T, x->right);
	}

	while ((y != T->nil) && (x == y->right)) {
		x = y;
		y = y->parent;
	}
	return y;
}


void rbtree_left_rotate(rbtree *T, rbtree_node *x) {

	rbtree_node *y = x->right;  // x  --> y  ,  y --> x,   right --> left,  left --> right

	x->right = y->left; //1 1
	if (y->left != T->nil) { //1 2
		y->left->parent = x;
	}

	y->parent = x->parent; //1 3
	if (x->parent == T->nil) { //1 4
		T->root = y;
	} else if (x == x->parent->left) {
		x->parent->left = y;
	} else {
		x->parent->right = y;
	}

	y->left = x; //1 5
	x->parent = y; //1 6
}


void rbtree_right_rotate(rbtree *T, rbtree_node *y) {

	rbtree_node *x = y->left;

	y->left = x->right;
	if (x->right != T->nil) {
		x->right->parent = y;
	}

	x->parent = y->parent;
	if (y->parent == T->nil) {
		T->root = x;
	} else if (y == y->parent->right) {
		y->parent->right = x;
	} else {
		y->parent->left = x;
	}

	x->right = y;
	y->parent = x;
}

void rbtree_insert_fixup(rbtree *T, rbtree_node *z) {

	while (z->parent->color == RED) { //z ---> RED
		if (z->parent == z->parent->parent->left) {
			rbtree_node *y = z->parent->parent->right;
			if (y->color == RED) {
				z->parent->color = BLACK;
				y->color = BLACK;
				z->parent->parent->color = RED;

				z = z->parent->parent; //z --> RED
			} else {

				if (z == z->parent->right) {
					z = z->parent;
					rbtree_left_rotate(T, z);
				}

				z->parent->color = BLACK;
				z->parent->parent->color = RED;
				rbtree_right_rotate(T, z->parent->parent);
			}
		}else {
			rbtree_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; //z --> RED
			} else {
				if (z == z->parent->left) {
					z = z->parent;
					rbtree_right_rotate(T, z);
				}

				z->parent->color = BLACK;
				z->parent->parent->color = RED;
				rbtree_left_rotate(T, z->parent->parent);
			}
		}
		
	}

	T->root->color = BLACK;
}


void rbtree_insert(rbtree *T, rbtree_node *z) {

	rbtree_node *y = T->nil;
	rbtree_node *x = T->root;

	while (x != T->nil) {
		y = x;
		if (z->key < x->key) {
			x = x->left;
		} else if (z->key > x->key) {
			x = x->right;
		} else { //Exist
			return ;
		}
	}

	z->parent = y;
	if (y == T->nil) {
		T->root = z;
	} else if (z->key < y->key) {
		y->left = z;
	} else {
		y->right = z;
	}

	z->left = T->nil;
	z->right = T->nil;
	z->color = RED;

	rbtree_insert_fixup(T, z);
}

void rbtree_delete_fixup(rbtree *T, rbtree_node *x) {

	while ((x != T->root) && (x->color == BLACK)) {
		if (x == x->parent->left) {

			rbtree_node *w= x->parent->right;
			if (w->color == RED) {
				w->color = BLACK;
				x->parent->color = RED;

				rbtree_left_rotate(T, 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;
					rbtree_right_rotate(T, w);
					w = x->parent->right;
				}

				w->color = x->parent->color;
				x->parent->color = BLACK;
				w->right->color = BLACK;
				rbtree_left_rotate(T, x->parent);

				x = T->root;
			}

		} else {

			rbtree_node *w = x->parent->left;
			if (w->color == RED) {
				w->color = BLACK;
				x->parent->color = RED;
				rbtree_right_rotate(T, x->parent);
				w = x->parent->left;
			}

			if ((w->left->color == BLACK) && (w->right->color == BLACK)) {
				w->color = RED;
				x = x->parent;
			} else {

				if (w->left->color == BLACK) {
					w->right->color = BLACK;
					w->color = RED;
					rbtree_left_rotate(T, w);
					w = x->parent->left;
				}

				w->color = x->parent->color;
				x->parent->color = BLACK;
				w->left->color = BLACK;
				rbtree_right_rotate(T, x->parent);

				x = T->root;
			}

		}
	}

	x->color = BLACK;
}

rbtree_node *rbtree_delete(rbtree *T, rbtree_node *z) {

	rbtree_node *y = T->nil;
	rbtree_node *x = T->nil;

	if ((z->left == T->nil) || (z->right == T->nil)) {
		y = z;
	} else {
		y = rbtree_successor(T, z);
	}

	if (y->left != T->nil) {
		x = y->left;
	} else if (y->right != T->nil) {
		x = y->right;
	}

	x->parent = y->parent;
	if (y->parent == T->nil) {
		T->root = x;
	} else if (y == y->parent->left) {
		y->parent->left = x;
	} else {
		y->parent->right = x;
	}

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

	if (y->color == BLACK) {
		rbtree_delete_fixup(T, x);
	}

	return y;
}

rbtree_node *rbtree_search(rbtree *T, KEY_TYPE key) {

	rbtree_node *node = T->root;
	while (node != T->nil) {
		if (key < node->key) {
			node = node->left;
		} else if (key > node->key) {
			node = node->right;
		} else {
			return node;
		}	
	}
	return T->nil;
}


void rbtree_traversal(rbtree *T, rbtree_node *node) {
	if (node != T->nil) {
		rbtree_traversal(T, node->left);
		printf("key:%d, color:%d\n", node->key, node->color);
		rbtree_traversal(T, node->right);
	}
}

int main() {

	int keyArray[20] = {24,25,13,35,23, 26,67,47,38,98, 20,19,17,49,12, 21,9,18,14,15};

	rbtree *T = (rbtree *)malloc(sizeof(rbtree));
	if (T == NULL) {
		printf("malloc failed\n");
		return -1;
	}
	
	T->nil = (rbtree_node*)malloc(sizeof(rbtree_node));
	T->nil->color = BLACK;
	T->root = T->nil;

	rbtree_node *node = T->nil;
	int i = 0;
	for (i = 0;i < 20;i ++) {
		node = (rbtree_node*)malloc(sizeof(rbtree_node));
		node->key = keyArray[i];
		node->value = NULL;

		rbtree_insert(T, node);
		
	}

	rbtree_traversal(T, T->root);
	printf("............................................\n");

	for (i = 0;i < 20;i ++) {

		rbtree_node *node = rbtree_search(T, keyArray[i]);
		rbtree_node *cur = rbtree_delete(T, node);
		free(cur);

		rbtree_traversal(T, T->root);
		printf("----------------------------------------\n");
	}
	
	return 0;
}
卧栏听风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树，红黑树，B树，B+树等总结
风铃的博客
07-21 1389
目录 树 1、定义 2、特点 3、相关术语的概念 二叉树 1、定义 2、图示 ​ 3、二叉树与度为2的有序树的区别： 4、二叉树性质 5、满二叉树 ​6、完全二叉树： 7、 二叉树的删除算法规则 二叉搜索树 AVL树 红黑树 1、定义 2、红黑树性质 3、2-3-4树到红黑树的转换 4、树的旋转 5、红黑树的插入 哈夫曼树 概念1：什么是路径？ 概念2：什么是路径长度？ 概念3：什么是 结点的带权路径长度？ 概念4：什么是 树的带权路径长度？ 创建一个.
二叉树之红黑树
9527的专栏
10-09 322
1. 排序二叉树     排序二叉树是一种特殊结构的二叉树，可以非常方便地对树中所有节点进行排序和检索。 排序二叉树要么是一棵空二叉树，要么是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；它的左、右子树也分别为排序二叉树。 图 1 显示了一棵排序二叉树：  
二叉树与红黑树见解
Ge_yangwen的博客
10-15 1605
红黑树是一种自平衡的二叉查找树，是一种高效的查找树。红黑树具有良好的效率，它可在 O(logN) 时间内完成查找、增加、删除等操作1。大家应该都学过平衡二叉树(AVLTree)，了解到AVL树的性质，其实平衡二叉树最大的作用就是查找,AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。AVL树的效率就是高在这个地方。如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；
二叉树、红黑树介绍
weixin_42252757的博客
11-07 782
红黑树介绍 一.红黑树的性质： 1）.每个节点是红的或黑的 2）.根节点一定黑的 3）.每个叶节点是黑的 4）.如果一个节点是红的,则它的两个儿子都是黑的 5）对每个节点，从该节点到其子孙节点的所有路径上的包含相同数目的黑节点。 ...
二叉树、红黑树 详解
王林的博客
06-10 743
树的特点：二叉树就是度不超过2的树（每个节点最多有两个子节点）一个二叉树，如果每一个层的节点树都达到最大值，则这个二叉树就是满二叉树。每一层节点个数为：2的k次方-1；k为层数；叶节点只能出现在最下层和次下层，并且最下面一层的节点都集中在该层最左边的若干位置的二叉树；之前我们学习过二叉查找树，发现它的查询效率比单纯的链表和数组的查询效率要高很多，大部分情况下，确实是这样的，但不幸的是，在最坏情况下，二叉查找树的性能还是很糟糕。 我们会发现，如果我们要查找1这个元素，查找的效率依旧会很低。...
树与二叉树
JasonCaine的博客
09-06 162
*个人学习笔记* 树与二叉树 1. 二叉树的性质 性质1：在二叉树的第i层上至多有2^(i-1)个结点(i&gt;=1)。 性质2：深度为k的二叉树上至多含2^k-1个结点(k&gt;=1)。 性质3：对任何一棵二叉树T，设叶子结点数为n0，度为2的结点数为n2，那么，n0=n2+1。 性质4：具有n个结点的完全二叉树的深度为log2n+1。 性质5：对有n个结点的完全二叉树...
平衡二叉树-红黑树的实现
05-12
平衡二叉树-红黑树的实现
数据结构之红黑树详解
12-31
它的统计性能要好于平衡二叉树（AVL树），因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的...
红黑树&二叉树
06-01
红黑树和二叉树是数据结构中的重要概念，它们在计算机科学中有着广泛的应用，尤其是在算法和数据存储方面。二叉树是最基础的树形数据结构，而红黑树则是一种自平衡的二叉查找树，能有效地保证操作的时间复杂度。 ...
红黑树简单实现
07-06
在查询方面，红黑树的查询效率与二叉查找树相同，因为它们都依赖于节点的排序特性。查询时，从根节点开始，根据节点值与目标值的比较，沿着左子树或右子树向下搜索。 总的来说，红黑树的实现涉及到数据结构、算法和...
二叉树、B树、B+树、红黑树
02-26
四、红黑树 本质：自平衡二叉树 在二叉查找树基础上，添加以下性质 节点是红色或黑色 根节点是黑色 每个为空的叶子节点是黑色的 每个红色节点的两个子节点都是黑色 从任一节点到其每个叶子节点的所有路径都包含...
红黑树与平衡二叉树_百图详解红黑树
热门推荐
做的过程自我总结
02-06 1万+
之前在公司组内分享了红黑树的工作原理，今天把它整理下发出来，希望能对大家有所帮助，对自己也算是一个知识点的总结。 这篇文章算是我写博客写公众号以来画图最多的一篇文章了，没有之一，我希望尽可能多地用图片来形象地描述红黑树的各种操作的前后变换原理，帮助大家来理解红黑树的工作原理，下面，多图预警开始了。 在讲红黑树之前，我们首先来了解下下面几个概念：二叉树，排序二叉树以及平衡二叉树。 二叉树 二叉树指的是每个节点最多只能有两个字数的有序树。通常左边的子树称为左子树，右边的子树称为右子树。这里说的有序树..
数据结构--知识点16--搜索算法(二叉树)
ANingL的博客
09-06 2985
文章目录一、树的概念1、特点2、树的术语3、树的种类4、树的存储与表示5、常见的树的应用场景二、二叉树1、概念2、性质 一、树的概念 树是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构 1、特点 每个节点有零个或多个子节点 没有父节点的节点称为根节点 每一个非根节点有且只有一个父节点 除了根节点外，每个子节点可以分为**多个不相交(因为都只有一个父节点)**的子树 2、树的术语 节点的度：一个节点含有的子树的个数称为该节点的度 树的度：一棵树中，最大的节点的度称为树的度 叶节点或终端节点
二叉树和红黑树
放羊的大飞
03-31 412
一、二叉树 1.每个节点最多有两个子节点(度不大于2) 2.满二叉树：深度为k，有2^k-1个节点 3.完全二叉树：在满二叉树的基础上右边缺几个口。深度为k，最少2^(k-1)个节点，最多2^k - 1个节点 4.节点的度：子树的个数。度为0的叫叶子节点，度不为0的叫分支节点 5.先序遍历(根左右)、中序遍历(左根右)、后序遍历(左右根)、层次遍历(队列实...
数据结构 - 二叉树、红黑树
qq_33419463的博客
05-24 823
目录 一：二叉树 二：满二叉树 三：完全二叉树 四：堆 五：二叉查找树（BST） 六：平衡二叉树 七：红黑树 一：二叉树 二叉树是一种数据结构，其每个结点最多有两个子树的树结构。也就是每个节点下面有两个分叉，通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 最上面的节点称为根节点，相...
红黑树（C语言实现）
qq_49723651的博客
06-29 4711
红黑树c语言实现
C语言实现红黑树，详解红黑树旋转，插入删除问题
weixin_42209544的博客
09-09 318
c语言实现红黑树，对于红黑树旋转，插入删除问题进行梳理
【创新未发表】Matlab实现黏菌优化算法SMA-Kmean-Transformer-LSTM负荷预测算法研究.rar
最新发布
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
平衡二叉树 与 红黑树的区别
05-14
平衡二叉树与红黑树都是自平衡二叉查找树，它们的目的都是为了保证在最坏情况下，树的高度不会超过O(logN)，从而保证树的查找、插入、删除等操作的时间复杂度为O(logN)。 不同之处在于： 1. 平衡二叉树的自平衡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值