红黑树详细介绍三

根据之前红黑树的原理和《算法导论》上面的伪代码,我用代码将增加和调整的代码实现了一下,如有不对请大家指正。代码可以结合前两篇文章看。

红黑树的详细介绍一

红黑树详细介绍二

/*
 * =====================================================================================
 *
 *       Filename:  rbtree->h
 *
 *    Description:  red black tree
 *
 *        Version:  1->0
 *        Created:  2014年05月05日 08时48分50秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  我叫程序猿XXX
 *        Company:
 *
 * =====================================================================================
 */
#ifndef __RBTREE__H
#define __RBTREE__H

#define bool int
#define successed 0
#define failed -1
#define BLACK 0
#define RED 1

typedef struct _rbtree_node{
        struct _rbtree_node *p;
        struct _rbtree_node *left;
        struct _rbtree_node *right;
        int key;
        int color;
}*p_rbtree_node;

struct _rbtree_node node;

p_rbtree_node getNode(p_rbtree_node x);
bool leftRotate(p_rbtree_node *root, p_rbtree_node x);
bool rightRotate(p_rbtree_node *root, p_rbtree_node x);
bool rbInert(p_rbtree_node *root, p_rbtree_node z);
bool rbInsertFixup(p_rbtree_node *root, p_rbtree_node z);
bool rbBuilt(void);
void rbDisplay(p_rbtree_node *root);
void Display(void);

#endif

rbtree.c

/*
 * =====================================================================================
 *
 *       Filename:  rbtree.c
 *
 *    Description:
 *
 *        Version:  1.0
 *        Created:  2014年05月05日 09时01分00秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  我叫程序猿XXX
 *        Company:
 *
 * =====================================================================================
 */
#include "rbtree.h"
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
p_rbtree_node nil = &node;
p_rbtree_node root;

p_rbtree_node getNode(p_rbtree_node x)
{
        x = NULL;
        x = (p_rbtree_node)malloc(sizeof(struct _rbtree_node));
        if (x == NULL)
        {
                return NULL;
        }
        memset(x, 0, sizeof(struct _rbtree_node));

        return x;
}

bool leftRotate(p_rbtree_node *root, p_rbtree_node x)
{
        p_rbtree_node y = NULL;
        y = x->right;   //set y
        x->right = y->left;
        if (y->left !=  nil)
                y->left->p = x;
        y->p = x->p;
        if (x->p == nil)
                *root = y;
        else if (x == x->p->left)
                x->p->left = y;
        else
                x->p->right = y;
        y->left = x;
        x->p = y;

        return successed;
}

bool rightRotate(p_rbtree_node *root, p_rbtree_node x)
{
        p_rbtree_node y = NULL;
        y = x->left;
        x->left = y->right;
        if (y->right != nil)
                y->right->p = x;
        y->p = x->p;
        if (x->p == nil)
                *root = y;
        else if (x == x->p->left)
                x->p->left = y;
        else
                x->p->right = y;
        y->right = x;
        x->p = y;

        return successed;
}

bool rbInsert(p_rbtree_node *root, p_rbtree_node z)
{
        p_rbtree_node y = nil;
        p_rbtree_node x = *root;
        while (x != nil)
        {
                y = x;
                if (z->key < x->key)
                        x = x->left;
                else
                        x = x->right;
        }
        z->p = y;
        if (y == nil)
        {
                *root = z;
        }
        else if (z->key < y->key)
                y->left = z;
        else
                y->right = z;
        z->left = nil;
        z->right = nil;
        z->color = RED;
        rbInsertFixup(root, z);

        return successed;
}

bool rbInsertFixup(p_rbtree_node *root, p_rbtree_node z)
{
        while (z->p->color == RED)
        {
                p_rbtree_node y = NULL;
                if (z->p == z->p->p->left)
                {
                        y = z->p->p->right;
                        if (y->color == RED)
                        {
                                z->p->color = BLACK;
                                y->color = BLACK;
                                z->p->p->color = RED;
                                z = z->p->p;
                        }
                        else if (z == z->p->right)
                        {
                                z = z->p;
                                leftRotate(root, z);
                        }
                        else
                        {
                                z->p->color = BLACK;
                                z->p->p->color = RED;
                                rightRotate(root, z->p->p);
                        }
                }
                else
                {
                        y = z->p->p->left;
                        if (y->color == RED)
                        {
                                z->p->color = BLACK;
                                y->color = BLACK;
                                z->p->p->color = RED;
                                z = z->p->p;
                        }
                        else if (z == z->p->left)
                        {
                                z = z->p;
                                rightRotate(root, z);
                        }
                        else
                        {
                                z->p->color = BLACK;
                                z->p->p->color = RED;
                                leftRotate(root, z->p->p);
                        }
                }
        }
        (*root)->color = BLACK;
        return successed;
}

bool rbBuilt()
{
        node.p = NULL;
        node.left = NULL;
        node.right = NULL;
        node.key = -1;
        node.color = BLACK;
        root = nil;
        p_rbtree_node n1 = getNode(n1);
        n1->key = 1;
        rbInsert(&root, n1);

        p_rbtree_node n2 = getNode(n2);
        n2->key = 2;
        rbInsert(&root, n2);

        p_rbtree_node n4 = getNode(n4);
        n4->key = 4;
        rbInsert(&root, n4);

        p_rbtree_node n5 = getNode(n5);
        n5->key = 5;
        rbInsert(&root, n5);

        p_rbtree_node n7 = getNode(n7);
        n7->key = 7;
        rbInsert(&root, n7);

        p_rbtree_node n8 = getNode(n8);
        n8->key = 8;
        rbInsert(&root, n8);

        p_rbtree_node n11 = getNode(n11);
        n11->key = 11;
        rbInsert(&root, n11);

        p_rbtree_node n14 = getNode(n14);
        n14->key = 14;
        rbInsert(&root, n14);

        p_rbtree_node n15 = getNode(n15);
        n15->key = 15;
        rbInsert(&root, n15);

        return successed;
}

void rbDisplay(p_rbtree_node *root)
{
        if (*root == nil)
                return;
        rbDisplay(&((*root)->left));
        if ((*root)->color == RED)
                printf("key=%d, color=RED\n", (*root)->key);
        else
                printf("key=%d, color=BLACK\n", (*root)->key);
        rbDisplay(&((*root)->right));
}

void rbMidDisplay(p_rbtree_node *root)
{
        if (*root == nil)
                return;
        if ((*root)->color == RED)
                printf("key=%d, color=RED\n", (*root)->key);
        else
                printf("key=%d, color=BLACK\n", (*root)->key);
        rbMidDisplay(&((*root)->left));
        rbMidDisplay(&((*root)->right));
}

void Display(void)
{
        rbDisplay(&root);
        rbMidDisplay(&root);
}

test.c 测试文件

*
 * =====================================================================================
 *
 *       Filename:  test.c
 *
 *    Description:
 *
 *        Version:  1.0
 *        Created:  2014年05月05日 11时34分19秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  我叫程序猿XXX
 *        Company:
 *
 * =====================================================================================
 */
#include "rbtree.h"
#include <stdio.h>

int main(void)
{
        rbBuilt();
        Display();
        return 0;
}

代码的运行截图如下:

代码是通过先序和中序遍历得出的结果。

我的编译系统是Linux,编译环境是gcc 版本 4.8.2 20131212 (Red Hat 4.8.2-7) (GCC) 。后面将删除代码添加上。如果代码中有任何不对的地方,请大家指出,我好及时修改,谢谢大家。

红黑树详细介绍三

时间: 2024-08-07 08:40:08

红黑树详细介绍三的相关文章

红黑树详细介绍二

删除 RB-TRANSPLANT(T,u,v)函数是将u子树用v来代替,在替换的时候分为了三种情况,如果u就是root结点则直接替换u,如果树里面还包含有其它结点,则将u的左右子树转移到v的左右子树上面. RB-TRANSPLANT(T,u,v) if u.p == T.nil T.root = v else if u == u.p.left u.p.left = v else u.p.right = v v.p = u.p 删除代码 RB-DELETE(T,z) y = z y-origina

算法---红黑树实现介绍(一)

一.概述 红黑树是一种经典的存储结构,就其本身来说是一个二叉查找树,只是在这个基础上,树的节点增加了一个属性用于表示颜色(红或黑).通过限制从根节点到叶子的各个路径的节点着色的限制,来保证不会有哪个路径会比其它的路径长度超过2倍,从而红黑树是接近平衡的. 一直以来没有把红黑树完全理解,总觉得太难,望而生畏,最近下决心要弄清楚,也是花了很长时间,不过总算是明白了.记录下来以便更好的理解. 二.红黑树的特点 作为红黑树,需要有这5个限制,如下: 1)树中的每个节点,要么是红色,要么是黑色 2)树的根

算法--红黑树实现介绍(二)

一.概述 在前一篇中我们回顾了红黑树的特点及添加的处理,可以得知红黑树首先是一个二叉查找树,在此基础上通过增加节点颜色的约束来使得红黑树近似平衡.当我们添加或者删除节点时,我们需要对树进行调整以使其重新满足红黑树.这涉及到节点颜色的变化及部分节点的旋转.关于节点的旋转,以及添加时的处理我们已经介绍完了,所以本文重点介绍红黑树的删除. 二.红黑树的特点 在介绍删除时,我们还是再来回顾一下红黑树的五个特点,如下: 1)节点的颜色是红色或者黑色 2)树的根节点为黑色 3)树的叶子节点为黑色 4)如果一

红黑树(1) - 介绍

1.红黑树性质 红黑树是一种自平衡二叉查找树(BST),其中的每个节点都遵守下面的规则: 性质1. 节点是红色或黑色 性质2. 根节点是黑色 性质3. 所有叶子都是黑色(叶子是NIL节点) 性质4. 如果一个节点是红的,则它的两个儿子都是黑的. (即不可能存在相邻的连个红色节点.红色节点不能有红色父节点或红色孩子节点) 性质5. 从任一节点到其叶子的所有简单路径都包含相同数目的黑色节点. 2.红黑树结论 结论1: 红黑树的这五个性质强调了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的

红黑树(一)之 原理和算法详细介绍---转帖

目录1 红黑树的介绍2 红黑树的应用3 红黑树的时间复杂度和相关证明4 红黑树的基本操作(一) 左旋和右旋5 红黑树的基本操作(二) 添加6 红黑树的基本操作(三) 删除 作者:Sky Wang    于 2013-08-08 概述:R-B Tree,又称为"红黑树".本文参考了<算法导论>中红黑树相关知识,加之自己的理解,然后以图文的形式对红黑树进行说明.本文的主要内容包括:红黑树的特性,红黑树的时间复杂度和它的证明,红黑树的左旋.右旋.插入.删除等操作. 请尊重版权,转

【转】红黑树(一)原理与算法详细介绍

讲的通俗易懂,忍不住内心的欢喜,独乐乐不如众乐乐,下面贴出博文及地址: 概要 目录1 红黑树的介绍2 红黑树的应用3 红黑树的时间复杂度和相关证明4 红黑树的基本操作(一) 左旋和右旋5 红黑树的基本操作(二) 添加6 红黑树的基本操作(三) 删除 [转]  作者:Sky Wang :http://www.cnblogs.com/skywang12345/p/3245399.html 更多内容: 数据结构与算法系列 目录 (01) 红黑树(一)之 原理和算法详细介绍(02) 红黑树(二)之 C语

红黑树(一)之原理和算法的详细分析【转】

本文转载自:http://www.cnblogs.com/skywang12345/p/3245399.html R-B Tree简介 R-B Tree,全称是Red-Black Tree,又称为“红黑树”,它一种特殊的二叉查找树.红黑树的每个节点上都有存储位表示节点的颜色,可以是红(Red)或黑(Black). 红黑树的特性:(1)每个节点或者是黑色,或者是红色.(2)根节点是黑色.(3)每个叶子节点(NIL)是黑色. [注意:这里叶子节点,是指为空(NIL或NULL)的叶子节点!](4)如果

马程序员学习笔记——红黑树解析三

---------------------- ASP.Net+Unity开发..Net培训.期待与您交流! ---------------------- 六.树的前序.中序.后序 前序遍历(根左右): 1.访问根节点 2.前序遍历左子树 3.前序遍历右子树 中序遍历(左根右): 1.中序遍历左子树 2.访问根节点 3.中序遍历右子树 后序遍历(左右根): 1.后序遍历左子树 2.后序遍历右子树 3.访问根节点 扩展:已知前序.中序遍历,求后序遍历? 例: 前序遍历: GDAFEMHZ 中序遍历:

最详细的红黑树解析

红黑树 红黑树(英语:Red–black tree)是一种自平衡二叉查找树,是在计算机科学中用到的一种数据结构,典型的用途是实现关联数组.它是在1972年由鲁道夫·贝尔发明的,他称之为"对称二叉B树",它现代的名字是在Leo J. Guibas和Robert Sedgewick于1978年写的一篇论文中获得的.它是复杂的,但它的操作有着良好的最坏情况运行时间,并且在实践中是高效的:它可以在O(log n)时间内做查找,插入和删除,这里的n是树中元素的数目. 用途和好处 红黑树和AVL树