Java平衡树--红黑树,如何平衡化以及操作实现

Java 学习+面试指南:https://javaxiaobear.cn

我们前面介绍了2-3树,可以看到2-3树能保证在插入元素之后,树依然保持平衡状态,它的最坏情况下所有子结点都是2-结点,树的高度为lgN,相比于我们普通的二叉查找树,最坏情况下树的高度为N,确实保证了最坏情况下的时间复杂度,但是2-3树实现起来过于复杂,所以我们介绍一种2-3树思想的简单实现:红黑树。

红黑树主要是对2-3树进行编码,红黑树背后的基本思想是用标准的二叉查找树(完全由2-结点构成)和一些额外的信
息(替换3-结点)来表示2-3树。我们将树中的链接分为两种类型:

  • 红链接:将两个2-结点连接起来构成一个3-结点
  • 黑链接:2-3树中的普通链接

我们将3-结点表示为由由一条左斜的红色链接(两个2-结点其中之一是另一个的左子结点)相连的两个2-结点。这种表示法的一个优点是,我们无需修改就可以直接使用标准的二叉查找树的get方法。

1、红黑树的定义

红黑树是含有红黑链接并满足下列条件的二叉查找树:

  • 红链接均为左连接
  • 没有任何一个节点同时和两条红链接相连
  • 该树是完美黑色平衡的,即是任意空链接到根节点的路径上的黑链接数量相同

红黑树与2-3树的对应关系:

2、红黑树的API

因为每个结点都只会有一条指向自己的链接(从它的父结点指向它),我们可以在之前的Node结点中添加一个布尔类型的变量color来表示链接的颜色。如果指向它的链接是红色的,那么该变量的值为true,如果链接是黑色的,那么该变量的值为false。

API设计

类名 Node
构造方法 Node(Key key, Value value, Node left, Node right,boolean color):创建Node对象
成员变量 public Node left:记录左子结点
public Node right:记录右子结点
public Key key:存储键
public Value value:存储值
public boolean color:由其父结点指向它的链接的颜色

3、平衡化

在对红黑树进行一些增删改查的操作后,很有可能会出现红色的右链接或者两条连续红色的链接,而这些都不满足红黑树的定义,所以我们需要对这些情况通过旋转进行修复,让红黑树保持平衡。

1、左旋

当某个结点的左子结点为黑色,右子结点为红色,此时需要左旋。

前提:当前结点为h,它的右子结点为x;

左旋过程:

  1. 让x的左子结点变为h的右子结点:

    h.right=x.left;
    
  2. 让h成为x的左子结点:

    x.left=h;
    
  3. 让h的color属性变为x的color属性值:

    x.color=h.color;
    
  4. 让h的color属性变为RED:

    h.color=true;
    
2、右旋

当某个结点的左子结点是红色,且左子结点的左子结点也是红色,需要右旋

前提:当前结点为h,它的左子结点为x;

右旋过程:

  1. 让x的右子结点成为h的左子结点:

    h.left = x.right;
    
  2. 让h成为x的右子结点:

    x.right=h;
    
  3. 让x的color变为h的color属性值:

    x.color = h.color;
    
  4. 让h的color为RED;

4、操作

1、向单个2-结点中插入新键

一棵只含有一个键的红黑树只含有一个2-结点。插入另一个键后,我们马上就需要将他们旋转。

  • 如果新键小于当前结点的键,我们只需要新增一个红色结点即可,新的红黑树和单个3-结点完全等价。

  • 如果新键大于当前结点的键,那么新增的红色结点将会产生一条红色的右链接,此时我们需要通过左旋,把红色右链接变成左链接,插入操作才算完成。形成的新的红黑树依然和3-结点等价,其中含有两个键,一条红色链接。

2、向底部的2-结点插入新键

用和二叉查找树相同的方式向一棵红黑树中插入一个新键,会在树的底部新增一个结点(可以保证有序性),唯一区别的地方是我们会用红链接将新结点和它的父结点相连。如果它的父结点是一个2-结点,那么刚才讨论的两种方式仍然适用。

3、颜色反转

当一个结点的左子结点和右子结点的color都为RED时,也就是出现了临时的4-结点,此时只需要把左子结点和右子结点的颜色变为BLACK,同时让当前结点的颜色变为RED即可。

4、向一棵双键树(即一个3-结点)中插入新键

这种情况分为三种情况:

  1. 新键大于原树中的两个键

  2. 新键小于原树中的两个键

  3. 新键介于原树中两个键之间

5、根节点的颜色总是黑色

由于根结点不存在父结点,所以每次插入操作后,我们都需要把根结点的颜色设置为黑色。

6、向树底部的3-结点插入新键

假设在树的底部的一个3-结点下加入一个新的结点。前面我们所讲的3种情况都会出现。指向新结点的链接可能是:

  • 3-结点的右链接(此时我们只需要转换颜色即可)
  • 或是左链接(此时我们需要进行右旋转然后再转换)
  • 或是中链接(此时需要先左旋转然后再右旋转,最后转换颜色)。

颜色转换会使中间结点的颜色变红,相当于将它送入了父结点。这意味着父结点中继续插入一个新键,我们只需要使用相同的方法解决即可,直到遇到一个2-结点或者根结点为止。

5、API的设计

类名 RedBlackTree
构造方法 RedBlackTree():创建RedBlackTree对象
成员方法 1.private boolean isRed(Node x):判断当前结点的父指向链接是否为红色
2.private Node rotateLeft(Node h):左旋调整
3.private Node rotateRight(Node h):右旋调整
4.private void flipColors(Node h):颜色反转,相当于完成拆分4-结点
5.public void put(Key key, Value val):在整个树上完成插入操作
6.private Node put(Node h, Key key, Value val):在指定树中,完成插入操作,并返回添加元素后
新的树
7.public Value get(Key key):根据key,从树中找出对应的值
8.private Value get(Node x, Key key):从指定的树x中,找出key对应的值
9.public int size():获取树中元素的个数
成员变量 1.private Node root : 记录根结点
2.private int N:记录树中元素的个数
3.private static final boolean RED:红色链接标识
4.private static final boolean BLACK:黑色链接标识

6、代码实现

public class RedBlackTree<Key extends Comparable<Key>,Value> {

    /**
     * 根结点
     */
    private Node root;

    /**
     * 元素个数
     */
    private int size;

    /**
     * 红链接
     */
    private static final boolean RED = true;

    /**
     * 黑链接
     */
    private static final boolean BLACK = false;

    /**
     * 判断当前结点的父指向链接是否为红色
     * @param x
     * @return
     */
    private boolean isRed(Node x){
        if (x == null) {
            return false;
        }
        return x.color == RED;
    }

    /**
     * 左旋调整
     * @param h
     * @return
     */
    private Node rotateLeft(Node h){
        //找到当前节点的右子结点
        Node rightNode = h.right;
        //找到右子结点的左子结点
        Node left = rightNode.left;
        //让当前结点h的右子结点的左子结点成为当前结点的右子结点
        h.right = left;
        //让当前节点h变为rightNode的左子节点
        rightNode.left = h;
        //让当前结点h的color变成右子结点的color
        rightNode.color = h.color;
        //让当前结点的color变成RED
        h.color = RED;
        return rightNode;
    }

    /**
     * 右旋调整
     * @param h
     * @return
     */
    private Node rotateRight(Node h){
        //找到当前结点的左子结点
        Node leftNode = h.left;
        //找到leftNode的右子结点
        Node right = leftNode.right;
        //让right变成当前结点的左子结点
        h.left = right;
        //让当前节点变为leftNode的右子结点
        leftNode.right = h;
        //让当前结点h的color值变为左子结点的color值
        leftNode.color = h.color;
        //让当前结点的color变为RED
        h.color = RED;
        return leftNode;
    }

    /**
     * 颜色反转,相当于完成拆分4-结点
     * @param h
     */
    private void flipColors(Node h){
        //当前结点变为RED
        h.color = RED;
        //左右子结点的color变为BLACK
        h.left.color = BLACK;
        h.right.color = BLACK;
    }

    /**
     * 在整个树上完成插入操作
     * @param key
     * @param val
     */
    public void put(Key key, Value val){
        root = put(root,key,val);
        //让根节点颜色变为BLACK
        root.color = BLACK;
    }

    /**
     * 在指定树中,完成插入操作,并返回添加元素后新的树
     * @param h
     * @param key
     * @param val
     * @return
     */
    private Node put(Node h, Key key, Value val){
        //根结点
        if (h == null) {
            size++;
            return new Node(null,null,key,val,RED);
        }
        //比较当前节点的键与key
        int compare = key.compareTo(h.key);
        if(compare < 0){
            //往左子结点插入
            h.left = put(h.left,key,val);
        }else if(compare > 0){
            //往右子结点插入
            h.right = put(h.right,key,val);
        }else {
            //更新值
            h.value = val;
        }
        //如果当前结点的右链接是红色,左链接为黑色,需要左旋
        if(isRed(h.right) && !isRed(h.left)){
            h = rotateLeft(h);
        }
        //如果当前节点的左子结点以及左子结点的左子结点都是红链接,需要右旋
        if(isRed(h.right) && isRed(h.right.right)){
            h = rotateRight(h);
        }
        //颜色变换:当前节点的左右子结点都是红链接
        if(isRed(h.right) && isRed(h.left)){
            flipColors(h);
        }
        return h;
    }

    /**
     * 根据key,从树中找出对应的值
     * @param key
     * @return
     */
    public Value get(Key key){
        return get(root,key);
    }

    /**
     * 从指定的树x中,找出key对应的值
     * @param x
     * @param key
     * @return
     */
    private Value get(Node x, Key key){
        if (x == null) {
            return null;
        }
        int compare = key.compareTo(x.key);
        if(0 > compare){
            return get(x.left,key);
        }else if(0 < compare){
            return get(x.right,key);
        }else {
            return x.value;
        }
    }

    /**
     * 获取树中元素的个数
     * @return
     */
    public int size(){
        return size;
    }


    /**
     * 结点类
     */
    private class Node{
        public Node left;
        public Node right;
        public Key key;
        public Value value;
        public boolean color;

        public Node(Node left, Node right, Key key, Value value, boolean color) {
            this.left = left;
            this.right = right;
            this.key = key;
            this.value = value;
            this.color = color;
        }
    }
}
  • 测试类

    public class RedBlackTreeTest {
    
        public static void main(String[] args) {
            RedBlackTree<Integer, String> tree = new RedBlackTree<>();
            tree.put(1,"1111");
            tree.put(2,"2222");
            tree.put(3,"3333");
            tree.put(4,"4444");
            System.out.println(tree.size());
            tree.put(2,"666666");
            System.out.println(tree.get(2));
        }
    }
    

Java平衡树--红黑树,如何平衡化以及操作实现_第1张图片

你可能感兴趣的:(Java数据结构与算法,java,开发语言,红黑树,平衡树,数据结构与算法)