红黑树学习笔记

最新推荐文章于 2024-07-25 11:27:31 发布
最新推荐文章于 2024-07-25 11:27:31 发布
阅读量144 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42183401/article/details/106106398
版权
学习视频

https://www.bilibili.com/video/BV1Jp411R7Sb
白嫖至B站子空Kosora UP主

1. 复习一下二叉树

leetcode：第226题：翻转二叉树
在这里插入图片描述

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root != null) {
            TreeNode tmp = root.left;
            root.left = root.right;
            root.right = tmp;
            invertTree(root.left);
            invertTree(root.right);
        }
        return root;
    }
}
2. 复习二叉搜素树
// 节点类
public class AVLEntry<K, V> implements Map.Entry<K, V> {

    public K key;
    public V value;
    public AVLEntry<K, V> left;
    public AVLEntry<K, V> right;
    public int height = 1;

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V value) {
        this.value = value;
        return value;
    }

    public AVLEntry() {
    }

    public AVLEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public AVLEntry(K key, V value, AVLEntry<K, V> left, AVLEntry<K, V> right, int height) {
        this.key = key;
        this.value = value;
        this.left = left;
        this.right = right;
        this.height = height;
    }

    @Override
    public String toString() {
        return "AVLEntry{" +
                "key=" + key +
                ", value=" + value +
                '}';
    }
}


public class AVLMap<K, V> implements Iterable<AVLEntry<K, V>> {

    private int size;
    private AVLEntry<K, V> root;
    private Comparator<K> comp;

    @SuppressWarnings("unchecked")
    private int compare(K a, K b) {
        if (comp != null) {
            return comp.compare(a, b);
        }
        else {
            Comparable<K> c = (Comparable<K>) a;
            return c.compareTo(b);
        }
    }

    public AVLMap(Comparator<K> comp) {
        super();
        this.comp = comp;
    }

    public AVLMap() {
        super();
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0 ? true:false;
    }

    public V put(K key, V value) {
        V returnValue = value;
        if (root == null) {
            root = new AVLEntry<K, V>(key, value);
            size++;
        }
        else {
            AVLEntry<K, V> p = root;
            while (p != null) {
                int compareResult = compare(key, p.key);
                if (compareResult == 0) {
                    returnValue = p.getValue();
                    p.setValue(value);
                    break;
                }
                else if (compareResult < 0) {
                    if (p.left == null) {
                        p.left = new AVLEntry<K, V>(key, value);
                        size++;
                        break;
                    }
                    else {
                        p = p.left;
                    }
                }
                else {
                    if (p.right == null) {
                        p.right = new AVLEntry<K, V>(key, value);
                        size++;
                        break;
                    }
                    else {
                        p = p.right;
                    }
                }
            }
        }
        return returnValue;
    }

    @Override
    public Iterator<AVLEntry<K, V>> iterator() {
        return new AVLIterator<>(root);
    }

    private AVLEntry<K, V> getEntry(K key) {
        AVLEntry<K, V> p = root;
        while (p != null) {
            int compareResult = compare(key, p.key);
            if (compareResult == 0) {
                return p;
            }
            else if (compareResult < 0) {
                p = p.left;
            }
            else {
                p = p.right;
            }
        }
        return null;
    }

    public boolean containsKey(K key) {
        return getEntry(key) != null;
    }

    public V get(K key) {
        AVLEntry<K, V> p = getEntry(key);
        return p != null ? p.getValue() : null;
    }

    public boolean containsValue(V value) {
        Iterator<AVLEntry<K, V>> itr = this.iterator();
        while (itr.hasNext()) {
            if (itr.next().getValue().equals(value)) {
                return true;
            }
        }
        return false;
    }

    public AVLEntry<K, V> getFirstEntry(AVLEntry<K, V> p) {
        if (p == null) {
            return p;
        }
        while ((p.left != null)) {
            p = p.left;
        }
        return p;
    }

    public AVLEntry<K, V> getLastEntry(AVLEntry<K, V> p) {
        if (p == null) {
            return p;
        }
        while ((p.right != null)) {
            p = p.right;
        }
        return p;
    }

    private AVLEntry<K, V> deleteEntry(AVLEntry<K, V> p, K key) {
        if (p == null) {
            return null;
        }
        else {
            int compareResult = compare(key, p.key);
            if (compareResult == 0) {
                if (p.left == null && p.right == null) {
                    p = null;
                }
                else if (p.left != null && p.right == null) {
                    p = p.left;
                }
                else if (p.right != null && p.left == null) {
                    p = p.right;
                }
                else {
                    // 随机取右边最小值还是左边最大值代替该节点
                    if ((size & 1) == 0) {
                        AVLEntry<K, V> rightMin = getFirstEntry(p.right);
                        p.key = rightMin.key;
                        p.value = rightMin.value;
                        // 删掉右边最小值，因为它的值已经被存储
                        AVLEntry<K, V> newRight = deleteEntry(p.right, p.key);
                        p.right = newRight;
                    }
                    else {
                        AVLEntry<K, V> leftMax = getLastEntry(p.left);
                        p.key = leftMax.key;
                        p.value = leftMax.value;
                        // 删掉左边最大值，因为它的值已经被存储
                        AVLEntry<K, V> newLeft = deleteEntry(p.left, p.key);
                        // 因为子树结构可能被改变，所以要重新赋值子树？是不是多余拉?引用地址改变拉。所以要重新赋值
                        p.left = newLeft;
                    }
                }
            }
            else if (compareResult < 0) {
                AVLEntry<K, V> newLeft = deleteEntry(p.left, key);
                p.left = newLeft;
            }
            else {
                AVLEntry<K, V> newRight = deleteEntry(p.right, key);
                p.right = newRight;
            }
            return p;
        }
    }

    public V remove(K key) {
        AVLEntry<K, V> entry = getEntry(key);
        if (entry == null) {
            return null;
        }
        V oldValue = entry.getValue();
        root = deleteEntry(root, key);
        size--;
        return oldValue;
    }

    public void levelOrder() {
        Queue<AVLEntry<K, V>> queue = new LinkedList<AVLEntry<K, V>>();
        queue.offer(root);
        int preCount = 1;
        int pCount = 0;
        while (!queue.isEmpty()) {
            AVLEntry<K, V> p = queue.poll();
            System.out.print(p + " ");
            if (p.left != null) {
                queue.offer(p.left);
                pCount++;
            }
            if (p.right != null) {
                queue.offer(p.right);
                pCount++;
            }
            preCount--;
            if (preCount == 0) {
                preCount = pCount;
                pCount = 0;
                System.out.println();
            }
        }
    }

}

lintcode 第448题：二叉查找树的中序后继
在这里插入图片描述

public class Solution {
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        // p为空或者p就是最大的点返回null
        if (p == null || getLastNode(root) == p) {
            return null;
        }

        // p有右子树，则它的后继点为右子树的最小值
        if (p.right != null) {
            return getFirstNode(p.right);
        }

        // p没有右子树，则找到根节点到p店路径的最后一个左拐的点
        TreeNode parent = root;
        TreeNode tmp = root;
        while (parent != null) {
            if (parent == p) {
                break;
            }
            if (parent.val > p.val) {
                tmp = parent;
                parent = parent.left;
            }
            else {
                parent = parent.right;
            }
        }
        return tmp;

    }

    private TreeNode getFirstNode(TreeNode p) {
        while (p.left != null) {
            p = p.left;
        }
        return p;
    }

    private TreeNode getLastNode(TreeNode root) {
        while (root.right != null) {
            root = root.right;
        }
        return root;
    }
}
3. 复习AVL平衡二叉树

leetcode：1382题，将二叉搜索树变平衡
在这里插入图片描述

class Solution {

        private TreeNode root;
        public LinkedList<TreeNode> stack = new LinkedList<>();
        private HashMap<TreeNode, Integer> heightMap = new HashMap<>();

        public TreeNode balanceBST(TreeNode root) {
            Stack<TreeNode> stack = new Stack<>();
            stack.add(root);
            while (!stack.isEmpty()) {
                TreeNode p = stack.pop();
                put(new TreeNode(p.val));
                if (p.left != null) {
                    stack.add(p.left);
                }
                if (p.right != null) {
                    stack.add(p.right);
                }
            }
            return this.root;
        }

        private void put(TreeNode p) {
            if (root == null) {
                root = p;
                stack.push(root);
            }
            else {
                TreeNode parent = root;
                while (true) {
                    stack.push(parent);

                    if (p.val < parent.val) {
                        if (parent.left == null) {
                            parent.left = p;
                            stack.push(p);
                            break;
                        }
                        else {
                            parent = parent.left;
                        }
                    }
                    else {
                        if (parent.right == null) {
                            parent.right = p;
                            stack.push(p);
                            break;
                        }
                        else {
                            parent = parent.right;
                        }
                    }
                }
            }
            fixAfterInsertion(p);
        }

        private int getHeight(TreeNode p) {
            return heightMap.containsKey(p) ? heightMap.get(p) : 0;
        }

        private void fixAfterInsertion(TreeNode p) {
            TreeNode parent = root;
            while (!stack.isEmpty()) {
                parent = stack.pop();
                int newHeight = Math.max(getHeight(parent.left), getHeight(parent.right)) + 1;
                if (heightMap.containsKey(parent) && getHeight(parent) > 1 && newHeight == getHeight(parent)) {
                    stack.clear();
                    return;
                }
                heightMap.put(parent, newHeight);
                int d = getHeight(parent.left) - getHeight(parent.right);
                if (Math.abs(d) <= 1) {
                    continue;
                }
                else {
                    if (d == 2) {
                        if (p.val - parent.left.val < 0) {
                            parent = rotateRight(parent);
                        }
                        else {
                            parent = rotateLeftRight(parent);
                        }
                    }
                    else {
                        if (p.val - parent.right.val > 0) {
                            parent = rotateLeft(parent);
                        }
                        else {
                            parent = rotateRightLeft(parent);
                        }
                    }
                    if (!stack.isEmpty()) {
                        if (p.val - stack.peek().val < 0) {
                            stack.peek().left = parent;
                        }
                        else {
                            stack.peek().right = parent;
                        }
                    }
                }
            }
            root = parent;
        }

        private TreeNode rotateRight(TreeNode parent) {
            TreeNode left = parent.left;
            parent.left = left.right;
            left.right = parent;
            heightMap.put(parent, Math.max(getHeight(parent.left), getHeight(parent.right)) + 1);
            heightMap.put(left, Math.max(getHeight(left.left), heightMap.get(parent)) + 1);
            return left;
        }

        private TreeNode rotateLeft(TreeNode parent) {
            TreeNode right = parent.right;
            parent.right = right.left;
            right.left = parent;
            heightMap.put(parent, Math.max(getHeight(parent.left), getHeight(parent.right)) + 1);
            heightMap.put(right, Math.max(getHeight(right.right), heightMap.get(parent)) + 1);
            return right;
        }

        private TreeNode rotateLeftRight(TreeNode parent) {
            parent.left = rotateLeft(parent.left);
            parent = rotateRight(parent);
            return parent;
        }

        private TreeNode rotateRightLeft(TreeNode parent) {
            parent.right = rotateRight(parent.right);
            parent = rotateLeft(parent);
            return parent;
        }

}
4. 学习红黑树
  • 1 每个节点要么是红的，要么是黑的
  • 2 根节点是黑的
  • 3 定义NULL为黑色
  • 4 如果某个子节点是红色，那么它的两个儿子都是黑色，且父节点也必定是黑色
  • 5 对于任一节点而言，它到叶节点的每一条路劲都包含相同数目的黑色节点，通常称为黑高，BlackHeight
  • RBT是一个BST
  • 任意一棵以黑色节点为根的子树也必定是一棵红黑树
    在这里插入图片描述

结论：

  • 红黑树不像AVL一样，永远保持绝对平衡
  • 相对平衡
  • 若H(left) >= H(right)，则：H(left) <= 2 * H(right) + 1, 但BH(left) == BH(right)， H(left) < H(right)同理
  • 定理：N个节点的RBT，最大高度是2log(N + 1)
  • 严格证明参考CLRS
  • 查询效率AVL略好于RBT
  • 插入删除效率RBT高于AVL
插入原则
  • 若插入的节点为黑色，肯定违反性质5
  • 只能插入红色节点，可能违反性质4，继续调整
  • 每将节点进行染色、旋转操作，我们需要考虑：
    *是否会引起左右子树BH不一致
    *有无可能继续破环性质4的可能
    在这里插入图片描述
  1. 无需调整
  • 越界
  • X是根节点
  • 父节点P的颜色为黑，必定满足性质4
  • 最后一步：将根节点root染黑
  1. case1
  • 条件： P为G的左孩子，Y为红色，X可左可右
  • 处理方式： P、Y染黑，G染红，X回溯至G
  • 条件简称： 红左父、红叔、红左右子
  • 处理方式简称： 父叔都变黑、爷变红、子变爷
    在这里插入图片描述
    因为回溯到了G点，G是一个红色节点，所以它可以变成其他任意情况

２.　case２

  • 条件: P为G的左孩子,Y为黑色,X为有孩子
  • 处理方式: 左旋P,X指向P,转换为case3
  • 条件简称: 红左父,黑叔,红右子
  • 处理方式简称: 左旋父, 子变父, 变为case3
    在这里插入图片描述
    case2只能转化为case3, case2不会引起BH增加
  1. case3
  • 条件: P为G的左孩子,Y为黑色,X为左孩子
  • 处理方式: P染黑,G染红,右旋G,结束
  • 条件简称: 红左父,黑叔,红左子
  • 处理方式简称: 父变黑,爷变红,右旋爷
    在这里插入图片描述
    case3无需转化,也不会引起BH增加
    RBT插入效率优于AVL
    AVL查询效率优于RBT

这是P为G的左孩子情况，右孩子对称即可．
在这里插入图片描述

删除原则

删除是先根据二叉搜索树的特点将该节点的后继节点的值替换该节点,然后删除该后继节点

  • 删除红色节点,不会影响BH,也不会影响BH,也不会违反性质4,无需调整

  • 删除黑色节点,节点所在子树的BH–,需要调整
    在这里插入图片描述

  • 需要删除的节点为红色,直接删除

  • 其它无需调整的情况为:
    当前X为根节点,无论root什么颜色,都将root染黑,rootOver
    当前X为红色,将X染黑,结束,redOver

  • 删除左孩子X,分为4种情况
    在这里插入图片描述
    先记到这里拉…

Asia_Wyz
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树学习小记
beginend
01-05 366
红黑树的形态 红黑树是一棵带拓展节点的平衡二叉树，即某个节点若没有左儿子，则新建一个拓展节点作为左儿子。右儿子同理。拓展节点称为外部节点，其余节点称为内部节点。 每个节点被染成红色或黑色。其中 根节点必然是黑色。 外部节点必然是黑色。 内部节点可以是红色或黑色。 需要满足的性质： 每个红色节点的两个儿子必然都是黑色节点，即不存在两个相邻的红色节点。 对于任意一个节点，从它出发到其子树内的所有外部节点的路径上的黑点数量均相同。 称从节点 XXX 出发，到其子树内任意一个外部节点路径上的黑点数量为 XX
红黑树原理学习笔记
jue_1xin的专栏
04-30 140
1.红黑树简介 2.红黑树性质 3.左旋右旋 4.插入操作 5.删除操作 6.线程安全 7.应用 参考资料 《算法导论第二版》 红黑树原理源码讲解（java），全B站讲解最细致版本，看完月薪最少涨5k！_哔哩哔哩_bilibili ...
Java学习笔记整理
05-21
这些学习笔记将带你深入了解Java的核心概念，特别是面向对象编程和集合框架。以下是对每个文件内容的详细阐述： 1. **Day0804_HashMap的基本使用.docx**：HashMap是Java集合框架中的一个重要组件，它提供了键值对的...
ConcurrentHashMap集合源码学习笔记
01-20
ConcurrentHashMap是基于散列表实现的，存储的是Key/Value对，底层使用数组+链表+红黑树+CAS算法实现的，数组是存储元素并且查找快，链表是为了解决哈希冲突而存在的，红黑树是为了解决链表中查询速度慢而使用的。...
codewhy学习笔记
05-22
3. 树结构：二叉树、平衡树（AVL树、红黑树）、B树、B+树等，它们在数据库索引、文件系统等方面有广泛应用。 4. 图算法：Dijkstra最短路径算法、Floyd-Warshall所有对最短路径算法、Prim最小生成树算法、Kruskal...
数据结构与算法学习笔记（十），左偏红黑树
06-01
笔记而已，不要太较真，有错误请立即指出。 类： 节点类 红黑树类 函数： 左旋，右旋，反转颜色，添加，查找。
cpp-算法学习笔记
08-16
4. **树算法**：包括二叉树操作（如插入、删除、遍历）、AVL树、红黑树等，这些在数据结构设计和实现中扮演重要角色。 5. **动态规划**：这是一种解决最优化问题的策略，通过构建状态转移方程，可以避免重复计算，...
cf场+线性dp
xxx_jsu的博客
07-23 272
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 168
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 113
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 172
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
2766. 重新放置石块 Medium
珞米的博客
07-24 453
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 489
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
算法-KMP字符串匹配
xx_xb的博客
07-23 199
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 865
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 252
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
贪心加暴力枚举
wniuniu_的博客
07-24 159
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
《算法导论》学习笔记：基础知识与算法入门
第 11 章：红黑树 1. 红黑树是一种自平衡的二叉搜索树，它通过引入约束条件，保证了树的平衡性，使得其查找、插入和删除操作的时间复杂度都为O(logn)。 2. 红黑树的平衡性能够较好地保持，是一种常用的数据结构。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值