数据结构--红黑树

于 2017-08-09 19:42:34 发布
阅读量199 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/with_dream/article/details/77012542
版权

1、基本概念

红黑树是二叉查找树的一种，与平衡查找树类似，但红黑树的平衡性不像平衡树那样严格。

红黑树的特点：

  • 任何一个节点都有颜色，黑色或者红色
  • 根节点是黑色的
  • 父子节点之间不能出现两个连续的红节点
  • 任何一个节点向下遍历到其子孙的叶子节点，所经过的黑节点个数必须相等
  • 空节点被认为是黑色的

红黑树的基本操作插入、删除、遍历。内容操作和平衡树一样，左右旋转。
这里写图片描述

public class Test {
    private static Node root;
    private static final boolean RED = false;
    private static final boolean BLACK = true;
    static class Node{
        int data;
        Node left;
        Node right;
        Node parent;
        boolean color;

        public Node(int data) {
            this.data = data;
            this.color = BLACK;
        }
    }

    public static void main(String[] args) {
        int[] src = { 10, 40, 30, 60, 90, 70, 20, 50, 80 };

        for (int i = 0; i < src.length; i++)
            insert(src[i]);

        midTrav(root);
        System.out.println("\n-----------------------------------");
        Node node = searchNode(root, 30);
        System.out.println(node.data+"");
        remove(node);
        midTrav(root);
        System.out.println("\n-----------------------------------");
    }

    /*
    *      px                              px
     *     /                              /
     *    x                              y
     *   /  \      --(左旋)-.           / \
     *  lx   y                         x  ry
     *     /   \                      /  \
     *    ly   ry                    lx  ly
    * */
    private static void leftRotate(Node x) {
        Node y = x.right;

        // 将 “y的左孩子” 设为 “x的右孩子”；
        x.right = y.left;

        if(y.left != null)
            //将ly的父节点指向x
            y.left.parent = x;

        //将y的父节点指向px
        y.parent = x.parent;

        //为y指定父节点
        if(x.parent == null)
            root = y;//x的父节点为空 表示x为根节点
        else
            //如果x为左子树，则让y也为左子树
            if(x.parent.left == x)
                y.parent.left = y;
            else
                //如果x为右子树，则让y也为右子树
                y.parent.right = y;

        //将x的父节点指向y
        y.left = x;
        x.parent = y;
    }

    /*
     * 对红黑树的节点(y)进行右旋转
     *
     * 右旋示意图(对节点y进行左旋)：
     *            py                               py
     *           /                                /
     *          y                                x
     *         /  \      --(右旋)-.             /  \
     *        x   ry                          lx   y
     *       / \                                  / \
     *      lx  rx                               rx  ry
     *
     */
    private static void rightRotate(Node y) {
        Node x = y.left;

        y.left = x.right;
        if (x.right != null)
            x.right.parent = y;

        x.parent = y.parent;

        if (y.parent == null) {
            root = x;
        } else {
            if (y == y.parent.right)
                y.parent.right = x;
            else
                y.parent.left = x;
        }

        x.right = y;
        y.parent = x;
    }
    private static void remove(Node node) {
        Node child, parent;
        boolean color;

        // 被删除节点的"左右孩子都不为空"的情况。
        if ( (node.left!=null) && (node.right!=null) ) {
            // 被删节点的后继节点。(称为"取代节点")
            // 用它来取代"被删节点"的位置，然后再将"被删节点"去掉。
            Node replace = node;

            // 获取后继节点
            replace = replace.right;
            while (replace.left != null)
                replace = replace.left;

            // "node节点"不是根节点(只有根节点不存在父节点)
            if (node.parent!=null) {
                if (node.parent.left == node)
                    node.parent.left = replace;
                else
                    node.parent.right = replace;
            } else {
                // "node节点"是根节点，更新根节点。
                root = replace;
            }

            // child是"取代节点"的右孩子，也是需要"调整的节点"。
            // "取代节点"肯定不存在左孩子！因为它是一个后继节点。
            child = replace.right;
            parent = replace.parent;
            // 保存"取代节点"的颜色
            color = replace.color;

            // "被删除节点"是"它的后继节点的父节点"
            if (parent == node) {
                parent = replace;
            } else {
                // child不为空
                if (child!=null)
                    child.parent = parent;
                parent.left = child;

                replace.right = node.right;
                node.right.parent = replace;
            }

            replace.parent = node.parent;
            replace.color = node.color;
            replace.left = node.left;
            node.left.parent = replace;

            if (color == BLACK)
                removeFixUp(child, parent);

            node = null;
            return ;
        }

        if (node.left !=null) {
            child = node.left;
        } else {
            child = node.right;
        }

        parent = node.parent;
        // 保存"取代节点"的颜色
        color = node.color;

        if (child!=null)
            child.parent = parent;

        // "node节点"不是根节点
        if (parent!=null) {
            if (parent.left == node)
                parent.left = child;
            else
                parent.right = child;
        } else {
            root = child;
        }

        if (color == BLACK)
            removeFixUp(child, parent);
        node = null;
    }

    private static void removeFixUp(Node node, Node parent) {
        Node other;

        while ((node==null || node.color==BLACK) && (node != root)) {
            if (parent.left == node) {
                other = parent.right;
                if (other.color == RED) {
                    // Case 1: x的兄弟w是红色的
                    other.color = BLACK;
                    parent.color = RED;
                    leftRotate(parent);
                    other = parent.right;
                }

                if ((other.left==null || other.left.color==BLACK) &&
                        (other.right==null || other.right.color==BLACK)) {
                    // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的
                    other.color = RED;
                    node = parent;
                    parent = node.parent;
                } else {
                    if (other.right==null || other.right.color==BLACK) {
                        // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。
                        other.left.color = BLACK;
                        other.color = RED;
                        rightRotate(other);
                        other = parent.right;
                    }
                    // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                    other.color = parent.color;
                    parent.color = BLACK;
                    other.right.color = BLACK;
                    leftRotate(parent);
                    node = root;
                    break;
                }
            } else {

                other = parent.left;
                if (other.color == RED) {
                    // Case 1: x的兄弟w是红色的
                    other.color = BLACK;
                    parent.color = RED;
                    rightRotate(parent);
                    other = parent.left;
                }

                if ((other.left==null || other.left.color==BLACK) &&
                        (other.right==null || other.right.color==BLACK)) {
                    // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的
                    other.color = RED;
                    node = parent;
                    parent = node.parent;
                } else {

                    if (other.left==null || other.left.color==BLACK) {
                        // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。
                        other.right.color = BLACK;
                        other.color = RED;
                        leftRotate(other);
                        other = parent.left;
                    }

                    // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                    other.color = parent.color;
                    parent.color = BLACK;
                    other.left.color = BLACK;
                    rightRotate(parent);
                    node = root;
                    break;
                }
            }
        }

        if (node!=null)
            node.color = BLACK;
    }

    //插入操作
    public static void insert(int data){
        Node y = null;
        Node x = root;

        //找到叶子节点
        while(x != null) {
            y = x;

            if(data > x.data)
                x = x.right;
            else if(data < x.data)
                x = x.left;
            else
                return;
        }
        //插入
        Node node = new Node(data);
        node.parent = y;
        if(y == null)
            root = node;
        else
            if(node.data > y.data)
                y.right = node;
            else
                y.left = node;

        node.color = RED;
        //修正红黑树
        insertFixUp(node);
    }

    private static void insertFixUp(Node node) {
        Node parent, gparent;

        while ((parent=node.parent)!=null && parent.color==RED) {
            gparent = parent.parent;

            //一、若“父节点”是“祖父节点的左孩子”
            if(parent == gparent.left) {
                // Case 1条件：父节点和叔叔节点是红色 则父节点、叔叔节点都为黑，祖父节点为红
                Node uncle = gparent.right;
                if ((uncle!=null) && uncle.color==RED) {
                    uncle.color = BLACK;
                    parent.color = BLACK;
                    gparent.color = RED;
                    node = gparent;
                    continue;
                }

                // Case 2条件：叔叔是黑色，且当前节点是右孩子，进行左转换
                if (parent.right == node) {
                    Node tmp;
                    leftRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // Case 3条件：叔叔是黑色，且当前节点是左孩子。将父节点为根的子树右旋转
                parent.color = BLACK;
                gparent.color = RED;
                rightRotate(gparent);
            } else {
                //二、若“z的父节点”是“z的祖父节点的右孩子”
                // Case 1条件：叔叔节点是红色
                Node uncle = gparent.left;
                if ((uncle!=null) && uncle.color==RED) {
                    uncle.color = BLACK;
                    parent.color = BLACK;
                    gparent.color = RED;
                    node = gparent;
                    continue;
                }

                // Case 2条件：叔叔是黑色，且当前节点是左孩子
                if (parent.left == node) {
                    Node tmp;
                    rightRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // Case 3条件：叔叔是黑色，且当前节点是右孩子。
                parent.color = BLACK;
                gparent.color = RED;
                leftRotate(gparent);
            }
        }

        root.color = BLACK;
    }

    //中序遍历
    public static void midTrav(Node node){
        if(node == null)
            return;

        midTrav(node.left);
        System.out.print(node.data + "    ");
        midTrav(node.right);
    }

    //查找
    public static Node searchNode(Node node, int data){
        while(node != null)
            if(data > node.data)
                node = node.right;
            else if(data < node.data)
                node = node.left;
            else
                return node;

        return node;
    }
}

如果需要存储多个相同数据，Node中可以添加一个count字段，存放数量

参考：
http://www.cnblogs.com/skywang12345/p/3624343.html
http://blog.csdn.net/tcorpion/article/details/54968644

with_dream
关注
专栏目录
数据结构-红黑树.zip
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家...总的来说，红黑树是数据结构中的重要组成部分，尤其在需要高效存储和检索大量有序数据的场合。通过理解和掌握红黑树的原理和实现，能提升编程能力，优化程序性能。
数据结构-红黑树（全篇）
10-17
红黑树代码资源
数据结构-Java实现一个简单的红黑树RedBlackTree
最新发布
09-25
数据结构-Java实现一个简单的红黑树RedBlackTree，代码通过内部类和枚举来实现了一个简单的红黑树，包括了红黑树的插入、查找以及部分辅助函数。
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
- 转换操作：在插入和删除过程中，可能需要将红黑树转换成其他数据结构，如AVL树，以满足特定需求。 在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的...
算法--直插排序
with_dream的博客
08-05 840
直插排序就是将一个记录插入到已经排好序的有序列表中。 如arr[3, 2, 1]进行排序。 首先将arr[1]赋给变量tmp，再用arr[0]与tmp比较。如果arr[0]>tmp,使arr[0]的值右移，空出来的位置放tmp也就是arr[1]public static void main(String[] args) { int[] src = { 3,2,1,4,5,6,7,16,1
数据结构--图
with_dream的博客
07-29 598
1、基本概念图是一种多对多的关系的数据结构 1.2 图的定义 1.2.1 无向边 若顶点viv_i到vjv_j之间的边没有方向，这条边称为无向边。如果任意两个顶点之间的边都是无向边，则该图称为无向图。 G=(V, {E})   V={A, B, C}   E={(A,B), (B,C), (C,A)}1.2.2 有向边 若顶点viv_i到vjv_j之间的边有方向，这条边称为有向边，也成为
数据结构--有序表查找
with_dream的博客
08-02 489
对于已经排好序的表，有1、折半查找在有序表中，取中间的记录进行比较，如果相同，匹配成功。如果比中间值小，就在中间记录的左半区进行查找，如果大，就在右半区。public static int binarySearch(int key){ int height = src.length-1; int low = 0; int mid = 0; while(low <= he
数据结构--散列
with_dream的博客
08-04 487
1、基本概念1.1 散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置 f(key) 其中f称为散列函数或哈希函数1.2 采用散列技术将记录存储在一块连续的存储空间，这块连续的存储空间称为散列表或哈希表1.3 散列技术最适合的技术是查找与给定值相等的记录1.4 冲突：如果两个关键字key1≠\neqkey2，但是却有 f(key1)=f(key
数据结构--顺序表查找
with_dream的博客
08-01 446
1、常规的方法int src[] = {0, 1, 2, 3, 4}; public int search(int key){ for (int i = 0; i < src.length; i++) if (src[i] == key) return i; }2、优化1方法中，for循环会每次判断数组是否会越界，可以对这个方面进行优化。int src
数据结构--串
with_dream的博客
07-27 360
1、基本概念串是由零个或多个字符组成的有限序列，又名字符串。 1.1 串大小的比较 给定两个串 s=”a0a_0a1a_1…ana_n” t=”b0b_0b1b_1…bmb_m” 当满足以下条件之一，s<t (1)n<m 且 aia_i=bib_i (i=0,1…n) 如s=”hap” ，t=”happy” (2)存在某个值k<=min(m,n) 使得 aia_i=bib_i (
数据结构--平衡二叉树
with_dream的博客
08-04 288
1、基本概念平衡二叉树(AVL树)是一种二叉排序树，其中每个节点的左子树和右子树的高度最多相差1 平衡因子：二叉树的左子树深度减去右子树的深度 只有-1，0，1三个值 最小不平衡子树：距离插入节点最近，且平衡因子的绝对值大于1的节点为根节点2、实现在构建二叉排序树的过程中，每当插入一个节点，先检查是否因插入的新数据破坏了平衡性 若是 找出最小不平衡子树。在保持排序二叉树特性的情况下，调整最小不平
数据结构--线索二叉树
with_dream的博客
08-08 269
1、基本概念普通的二叉树如果有n个节点，则有2n个指针域，有n-1条分支。那么有2n-(n-1)个指针域是空的。 如果想知道某个节点的前驱和后继，需要每次进行中序遍历，经常需要节点的前驱后继的话，效率不高。 可以使用空闲的指针域，分别指向节点的前驱和后继以提高效率。 如D的前驱是H，后继是I2、实现static class Node{ int data; b
数据结构--二叉排序树
with_dream的博客
08-03 267
1、基本概念二叉排序树又称二叉查找树，它是一颗空树或者具有以下特征的二叉树： 若左子树不为空，则左子树上所有节点的值都小于根结构的值 若右子树不为空，则右子树上所有节点的值都大于根结构的值 它的左右子树也分别是二叉排序树2、具体操作static class Node{ int data; Node left, right; public Node(int data){
算法复杂度分析
with_dream的博客
07-25 242
1、算法复杂度的衡量 内存（Memory） 时间（Time） 指令的数量（Number of Steps） 特定操作的数量 磁盘访问数量 网络包数量 渐进复杂度（Asymptotic Complexity） 2、算法的时间复杂度算法的时间复杂度一般分析的都是渐进复杂度，即输入的数据规模趋于无穷大算法分析的种类 最坏情况（Worst Case）：任意输入规模的最大运行时间。（Usually） 平均情
数据结构--表
with_dream的博客
07-25 217
1、基本概念形如A0A_0,A1A_1,A2A_2…AN-1成为一般表，如果表的大小为0成为空表 对于空表以外的任何表，Ai-1为Ai的前驱,Ai+1为Ai的后驱,A0A_0没有前驱,AN-1没有后驱 线性表分为顺序表和链表2、顺序表顺序表的物理内存是连续的。在存、读取数据时，不管是在哪个位置，时间复杂度都是O(1)。而在插入或者删除时，时间复杂度都是O(n)。比较适合存取数据，不适合经常插入和
算法--希尔排序
with_dream的博客
08-05 186
1、基本概念希尔排序是基于直插排序，也称为缩小增量排序。 把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。2、实现public static void main(String[] args) { int[] src = { 3,2,1,4,5,6,7,16,15,14,13,12,11
算法--堆排序
with_dream的博客
08-06 183
1、基本概念堆是二叉树的一种，堆中每个节点都大于其左右子节点称为大顶堆，如果每个节点都小于其左右节点的值则为小顶堆。使用完全二叉树实现的堆有如下性质 1.2 思路 将待排序的序列构造成大顶堆，此时最大值就是堆的根元素。将它与末尾元素交换，然后将剩余的n-1个元素重新构造成大顶堆，然后再与n-1个元素交换。 2、实现：public static void main(String[] ar
算法导论：数据结构篇--红黑树详解
总结来说，《算法导论》中的红黑树章节是理解数据结构中的高级主题，特别是动态数据结构实现的重要部分，它为高效的搜索和排序算法提供了基础，是所有希望深入学习计算机科学和算法设计的学生和专业人士的必备参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值