红黑树---学习笔记(云课堂)

/**
 * 红黑树
 *
 * @createTime 2020年04月17日 10:16.
 */
public class RedBlackTree<T> {
    private Node<T> root;

    /**
     * 添加节点时：自平衡
     *
     * @param current
     */
    public void addSelfBalance(Node<T> current) {
        Node<T> parent;
        Node<T> grandfather;
        Node<T> uncle;
        //父节点不为空，并且父节点是红色
        while ((parent = current.getParent()) != null && parent.isColor()) {
            grandfather = parent.getParent();
            if (grandfather.getLeftChild() == parent) {
                uncle = grandfather.getRightChild();
                if (uncle != null) {
                    //TODO 情况1：当前节点的父节点和叔叔节点都是红色
                    if (uncle.isColor()) {
                        //变色
                        parent.setColor(false);
                        uncle.setColor(false);
                        grandfather.setColor(true);
                        current = grandfather;
                        continue;
                    } else {
                        if (current == parent.getRightChild()) {
                            //TODO 情况2：当前节点的父节点是红色，叔叔节点是黑色，且当前节点是父节点的右子节点
                            leftRotate(parent);//父节点围着当前节点左旋
                            //左旋后，父节点与当前节点互换
                            Node<T> temp = parent;
                            parent = current;
                            current = temp;
                        }
                        //TODO 情况3：当前节点的父节点是红色，叔叔是黑色，且当前节点是父节点的左子节点
                        parent.setColor(false);
                        grandfather.setColor(true);
                        rightRotate(grandfather);
                    }
                }
            } else {
                uncle = grandfather.getLeftChild();
                //TODO 情况1：当前节点的父节点和叔叔节点都是红色
                if (uncle != null) {
                    if (uncle.isColor()) {
                        //变色
                        parent.setColor(false);
                        uncle.setColor(false);
                        grandfather.setColor(true);
                        current = grandfather;
                        continue;
                    } else {
                        if (current == parent.getLeftChild()) {
                            //TODO 情况2：当前节点的父节点是红色，叔叔节点是黑色，且当前节点是父节点的左子节点
                            rightRotate(parent);//父节点围着当前节点右旋
                            //右旋后，父节点与当前节点互换
                            Node<T> temp = parent;
                            parent = current;
                            current = temp;
                        }
                        //TODO 情况3：当前节点的父节点是红色，叔叔是黑色，且当前节点是父节点的右子节点
                        parent.setColor(false);
                        grandfather.setColor(true);
                        leftRotate(grandfather);
                    }
                }
            }
        }
    }

    /**
     * 左旋
     *
     * @param x
     */
    private void leftRotate(Node x) {
        //TODO 第一步：把y的左子节点赋给x的右子节点
        Node y = x.getRightChild();
        x.setRightChild(y.getLeftChild());
        if (y.getLeftChild() != null) {
            y.getLeftChild().setParent(x);//y的左子节点的父节点变成x
        }
        //TODO 第二步：把y的父节点变成x的父节点
        y.setParent(x.getParent());
        if (x.getParent() == null) {//x是根节点
            root = y;
        } else {
            if (x == x.getParent().getLeftChild()) {//x是父节点的左子节点
                x.getParent().setLeftChild(y);
            } else {
                x.getParent().setRightChild(y);
            }
        }
        //TODO 第三步：把y的左在节点变成x
        y.setLeftChild(x);
        x.setParent(y);//x的父节点变成y
    }

    //右旋
    private void rightRotate(Node x) {
        Node y = x.getRightChild();
        //TODO 第一步：把y的右子节点赋给x的左子节点
        x.setLeftChild(y.getRightChild());
        if (y.getRightChild() != null) {
            y.getRightChild().setParent(x);//y右子节点的父节点变成x
        }
        //TODO 第二步：把y的父节点变成x的父节点
        y.setParent(x.getParent());
        if (x.getParent() == null) {//x是根节点
            root = y;
        } else {
            if (x == x.getParent().getLeftChild()) {//x是父节点的左子节点
                x.getParent().setLeftChild(y);
            } else {
                x.getParent().setRightChild(y);
            }
        }
        //TODO 第三步：把y的右子节点变成x
        y.setRightChild(x);
        x.setParent(y);//x的父节点变成为y
    }
}

5、红黑树的查找操作

5.1、基于二分查找

6、红黑树新增

6.1、4中情况

6.2、整体口诀

6.2.1、情况1

如果新增节点为黑色，就会破坏黑色完美平衡，所以所有情况，新增的节点颜色都是红色

6.2.3、情况3

GPU变色后，将G点变为新C点(将祖父节点作为新增节点C)

6.2.4、情况4---CPG三点一线

G点旋转，GP变色

6.2.5、情况4---CPG三角关系

将CPG三角关系转化为“三点一线”关系

红黑树在线测试演示：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

7、二叉树的平衡因子BF

BF：Balance Factor

定义：二叉树上节点的左子树高度减去右子树高度的值

BF的绝对值越大，说明这个树越不平衡

平衡因子是衡量二叉树的平衡性。

二叉树在线测试演示：https://www.cs.usfca.edu/~galles/visualization/BST.html

8、AVL树

AVL树在线测试演示：https://www.cs.usfca.edu/~galles/visualization/AVLtree.html

8.1、定义性质

定义：平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树

性质：是一棵空树或任何一个节点BF绝对值不超过1

AVL树是完美平衡的树，对查找非常的友好。使用二分查找。

8.2、自平衡

二叉树所有的自旋都是：父母围着子女转

8.2.1、第一步

沿当前新增节点的父节点方向，查找最近失衡节点（最近的BF>1节点）

8.2.2、第二步

以【最近失衡节点】为旋转节点进行一次或二次自旋

圆心：就是新增节点那个方向的子节点（比如下图中的0008就是圆心）

方式1：一次自旋

方式2：两次自旋

如果“方式1---一次自旋”达不到平衡，就需要进行两次自旋

两次自旋：第一次（按照一次自旋的方式，找到圆心，将圆心作为选择旋转节点），【如下图：0777围着0800旋转】

第二次（第一次旋转完后，再将最近失衡节点作为旋转节点）【如下图：0888围着0800旋转】

8.2.3、第三步

沿【最近失衡节点】的父节点向上游递归执行第一步、第二步操作

爵影子

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
红黑树---学习笔记(云课堂)

1、使用场景 1、JDK TreeSet、TreeMap、JDK1.8 HashMap 2、Java NIO编程Epoll底层数据结构使用了红黑树 3、c++红黑树广泛的使用在STL中2、定义红黑树是一种含有红黑节点并能自平衡的二叉查找树。 2.1、二叉查找树若左子树不空，则左子树上所有节点的值均小于它的根节点的值；若右子树...
复制链接

扫一扫