2-3查找树和红黑树

最新推荐文章于 2022-09-23 09:15:26 发布
最新推荐文章于 2022-09-23 09:15:26 发布
阅读量322 收藏
点赞数
文章标签： 2-3树 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39352109/article/details/103674035
版权

2-3查找树引入2-节点和3-节点，目的为了让树平衡。一颗完美平衡的2-3查找树的所有空链接到根节点的距离应该是相同的。

插入操作

插入操作和BST的插入操作有很大区别，BST的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链表上，但是2-3查找树如果也这么做的话，那么就会破坏平衡性。它是将新节点到叶子节点上。

根据叶子节点的类型不同，有不同的处理方式：

如果插入到2-节点上，那么直接变成3-节点。

如果插入到3-节点上，那么暂时先变成4-节点，转成三个2-节点，并将中间的节点加入上层节点，如果上层节点也变成了4-那就继续拆分。

 

 

性质：

2-3查找树的插入操作都是局部的，只变换相关节点。并不会影响全局有序性和平衡性。

2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。

红黑树

红黑树是一颗2-3树，他不需要分别定义2-，3-，而是在普通树的基础上，加上颜色，红树那么这个节点和上层节点表示3-，黑的表示普通树。

红黑树具有以下性质：

  • 红链接都为左链接；
  • 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。

画红黑树时可以将红链接画平。

 

public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {

    private static final boolean RED = true;
    private static final boolean BLACK = false;

    private boolean isRed(Node x) {
        if (x == null)
            return false;
        return x.color == RED;
    }
}

左旋转：

因为合法的红链接都为左链接，如果出现右链接为红链接，那么就需要进行左旋转操作。

public Node rotateLeft(Node h) {
    Node x = h.right;
    h.right = x.left;
    x.left = h;
    x.color = h.color;
    h.color = RED;
    x.N = h.N;
    recalculateSize(h);
    return x;
}

右旋转：

进行右旋转是为了转换两个连续的左红链接

public Node rotateRight(Node h) {
    Node x = h.left;
    h.left = x.right;
    x.right = h;
    x.color = h.color;
    h.color = RED;
    x.N = h.N;
    recalculateSize(h);
    return x;
}

 

CS-Notes

前言

符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。

符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。

有序符号表的键需要实现 Comparable 接口。

public interface UnorderedST<Key, Value> {

    int size();

    Value get(Key key);

    void put(Key key, Value value);

    void delete(Key key);
}Copy to clipboardErrorCopied
public interface OrderedST<Key extends Comparable<Key>, Value> {

    int size();

    void put(Key key, Value value);

    Value get(Key key);

    Key min();

    Key max();

    int rank(Key key);

    List<Key> keys(Key l, Key h);
}Copy to clipboardErrorCopied

初级实现

1. 链表实现无序符号表

public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {

    private Node first;

    private class Node {
        Key key;
        Value value;
        Node next;

        Node(Key key, Value value, Node next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    @Override
    public int size() {
        int cnt = 0;
        Node cur = first;
        while (cur != null) {
            cnt++;
            cur = cur.next;
        }
        return cnt;
    }

    @Override
    public void put(Key key, Value value) {
        Node cur = first;
        // 如果在链表中找到节点的键等于 key 就更新这个节点的值为 value
        while (cur != null) {
            if (cur.key.equals(key)) {
                cur.value = value;
                return;
            }
            cur = cur.next;
        }
        // 否则使用头插法插入一个新节点
        first = new Node(key, value, first);
    }

    @Override
    public void delete(Key key) {
        if (first == null)
            return;
        if (first.key.equals(key))
            first = first.next;
        Node pre = first, cur = first.next;
        while (cur != null) {
            if (cur.key.equals(key)) {
                pre.next = cur.next;
                return;
            }
            pre = pre.next;
            cur = cur.next;
        }
    }

    @Override
    public Value get(Key key) {
        Node cur = first;
        while (cur != null) {
            if (cur.key.equals(key))
                return cur.value;
            cur = cur.next;
        }
        return null;
    }
}Copy to clipboardErrorCopied

2. 二分查找实现有序符号表

使用一对平行数组，一个存储键一个存储值。

二分查找的 rank() 方法至关重要，当键在表中时，它能够知道该键的位置；当键不在表中时，它也能知道在何处插入新键。

二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。

public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {

    private Key[] keys;
    private Value[] values;
    private int N = 0;

    public BinarySearchOrderedST(int capacity) {
        keys = (Key[]) new Comparable[capacity];
        values = (Value[]) new Object[capacity];
    }

    @Override
    public int size() {
        return N;
    }

    @Override
    public int rank(Key key) {
        int l = 0, h = N - 1;
        while (l <= h) {
            int m = l + (h - l) / 2;
            int cmp = key.compareTo(keys[m]);
            if (cmp == 0)
                return m;
            else if (cmp < 0)
                h = m - 1;
            else
                l = m + 1;
        }
        return l;
    }

    @Override
    public List<Key> keys(Key l, Key h) {
        int index = rank(l);
        List<Key> list = new ArrayList<>();
        while (keys[index].compareTo(h) <= 0) {
            list.add(keys[index]);
            index++;
        }
        return list;
    }

    @Override
    public void put(Key key, Value value) {
        int index = rank(key);
        // 如果找到已经存在的节点键为 key，就更新这个节点的值为 value
        if (index < N && keys[index].compareTo(key) == 0) {
            values[index] = value;
            return;
        }
        // 否则在数组中插入新的节点，需要先将插入位置之后的元素都向后移动一个位置
        for (int j = N; j > index; j--) {
            keys[j] = keys[j - 1];
            values[j] = values[j - 1];
        }
        keys[index] = key;
        values[index] = value;
        N++;
    }

    @Override
    public Value get(Key key) {
        int index = rank(key);
        if (index < N && keys[index].compareTo(key) == 0)
            return values[index];
        return null;
    }

    @Override
    public Key min() {
        return keys[0];
    }

    @Override
    public Key max() {
        return keys[N - 1];
    }
}Copy to clipboardErrorCopied

二叉查找树

二叉树 是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。

 

二叉查找树 （BST）是一颗二叉树，并且每个节点的值都大于等于其左子树中的所有节点的值而小于等于右子树的所有节点的值。

BST 有一个重要性质，就是它的中序遍历结果递增排序。

 

基本数据结构：

public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {

    protected Node root;

    protected class Node {
        Key key;
        Value val;
        Node left;
        Node right;
        // 以该节点为根的子树节点总数
        int N;
        // 红黑树中使用
        boolean color;

        Node(Key key, Value val, int N) {
            this.key = key;
            this.val = val;
            this.N = N;
        }
    }

    @Override
    public int size() {
        return size(root);
    }

    private int size(Node x) {
        if (x == null)
            return 0;
        return x.N;
    }

    protected void recalculateSize(Node x) {
        x.N = size(x.left) + size(x.right) + 1;
    }
}Copy to clipboardErrorCopied

为了方便绘图，下文中二叉树的空链接不画出来。

1. get()

  • 如果树是空的，则查找未命中；
  • 如果被查找的键和根节点的键相等，查找命中；
  • 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
@Override
public Value get(Key key) {
    return get(root, key);
}

private Value get(Node x, Key key) {
    if (x == null)
        return null;
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        return x.val;
    else if (cmp < 0)
        return get(x.left, key);
    else
        return get(x.right, key);
}Copy to clipboardErrorCopied

2. put()

当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接指向该节点，使得该节点正确地链接到树中。

 

 @Override
public void put(Key key, Value value) {
    root = put(root, key, value);
}

private Node put(Node x, Key key, Value value) {
    if (x == null)
        return new Node(key, value, 1);
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        x.val = value;
    else if (cmp < 0)
        x.left = put(x.left, key, value);
    else
        x.right = put(x.right, key, value);
    recalculateSize(x);
    return x;
}Copy to clipboardErrorCopied

3. 分析

二叉查找树的算法运行时间取决于树的形状，而树的形状又取决于键被插入的先后顺序。

最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。

 

在最坏的情况下，树的高度为 N。

 

4. floor()

floor(key)：小于等于键的最大键

  • 如果键小于根节点的键，那么 floor(key) 一定在左子树中；
  • 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就返回，否则根节点就是 floor(key)。
public Key floor(Key key) {
    Node x = floor(root, key);
    if (x == null)
        return null;
    return x.key;
}

private Node floor(Node x, Key key) {
    if (x == null)
        return null;
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        return x;
    if (cmp < 0)
        return floor(x.left, key);
    Node t = floor(x.right, key);
    return t != null ? t : x;
}Copy to clipboardErrorCopied

5. rank()

rank(key) 返回 key 的排名。

  • 如果键和根节点的键相等，返回左子树的节点数；
  • 如果小于，递归计算在左子树中的排名；
  • 如果大于，递归计算在右子树中的排名，加上左子树的节点数，再加上 1（根节点）。
@Override
public int rank(Key key) {
    return rank(key, root);
}

private int rank(Key key, Node x) {
    if (x == null)
        return 0;
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        return size(x.left);
    else if (cmp < 0)
        return rank(key, x.left);
    else
        return 1 + size(x.left) + rank(key, x.right);
}Copy to clipboardErrorCopied

6. min()

@Override
public Key min() {
    return min(root).key;
}

private Node min(Node x) {
    if (x == null)
        return null;
    if (x.left == null)
        return x;
    return min(x.left);
}Copy to clipboardErrorCopied

7. deleteMin()

令指向最小节点的链接指向最小节点的右子树。

 

public void deleteMin() {
    root = deleteMin(root);
}

public Node deleteMin(Node x) {
    if (x.left == null)
        return x.right;
    x.left = deleteMin(x.left);
    recalculateSize(x);
    return x;
}Copy to clipboardErrorCopied

8. delete()

  • 如果待删除的节点只有一个子树， 那么只需要让指向待删除节点的链接指向唯一的子树即可；
  • 否则，让右子树的最小节点替换该节点。

 

public void delete(Key key) {
    root = delete(root, key);
}
private Node delete(Node x, Key key) {
    if (x == null)
        return null;
    int cmp = key.compareTo(x.key);
    if (cmp < 0)
        x.left = delete(x.left, key);
    else if (cmp > 0)
        x.right = delete(x.right, key);
    else {
        if (x.right == null)
            return x.left;
        if (x.left == null)
            return x.right;
        Node t = x;
        x = min(t.right);
        x.right = deleteMin(t.right);
        x.left = t.left;
    }
    recalculateSize(x);
    return x;
}Copy to clipboardErrorCopied

9. keys()

利用二叉查找树中序遍历的结果为递增的特点。

@Override
public List<Key> keys(Key l, Key h) {
    return keys(root, l, h);
}

private List<Key> keys(Node x, Key l, Key h) {
    List<Key> list = new ArrayList<>();
    if (x == null)
        return list;
    int cmpL = l.compareTo(x.key);
    int cmpH = h.compareTo(x.key);
    if (cmpL < 0)
        list.addAll(keys(x.left, l, h));
    if (cmpL <= 0 && cmpH >= 0)
        list.add(x.key);
    if (cmpH > 0)
        list.addAll(keys(x.right, l, h));
    return list;
}Copy to clipboardErrorCopied

10. 分析

二叉查找树所有操作在最坏的情况下所需要的时间都和树的高度成正比。

2-3 查找树

2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。

 

1. 插入操作

插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。

根据叶子节点的类型不同，有不同的处理方式：

  • 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。

 

  • 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。

 

2. 性质

2-3 查找树插入操作的变换都是局部的，除了相关的节点和链接之外不必修改或者检查树的其它部分，而这些局部变换不会影响树的全局有序性和平衡性。

2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。

红黑树

红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。

 

红黑树具有以下性质：

  • 红链接都为左链接；
  • 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。

画红黑树时可以将红链接画平。

 

public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {

    private static final boolean RED = true;
    private static final boolean BLACK = false;

    private boolean isRed(Node x) {
        if (x == null)
            return false;
        return x.color == RED;
    }
}Copy to clipboardErrorCopied

1. 左旋转

因为合法的红链接都为左链接，如果出现右链接为红链接，那么就需要进行左旋转操作。

 

public Node rotateLeft(Node h) {
    Node x = h.right;
    h.right = x.left;
    x.left = h;
    x.color = h.color;
    h.color = RED;
    x.N = h.N;
    recalculateSize(h);
    return x;
}Copy to clipboardErrorCopied

2. 右旋转

进行右旋转是为了转换两个连续的左红链接，这会在之后的插入过程中探讨。

 

public Node rotateRight(Node h) {
    Node x = h.left;
    h.left = x.right;
    x.right = h;
    x.color = h.color;
    h.color = RED;
    x.N = h.N;
    recalculateSize(h);
    return x;
}Copy to clipboardErrorCopied

3. 颜色转换

一个 4- 节点在红黑树中表现为一个节点的左右子节点都是红色的。分裂 4- 节点除了需要将子节点的颜色由红变黑之外，同时需要将父节点的颜色由黑变红，从 2-3 树的角度看就是将中间节点移到上层节点。

 

void flipColors(Node h) {
    h.color = RED;
    h.left.color = BLACK;
    h.right.color = BLACK;
}

 

插入：

先将一个节点按照二叉查找树插入到正确位置，然后在进行如下颜色操作：

如果右子节点是红色的，而左子节点是黑色的，进行左旋转。

如果左子节点是红色的，左子节点的左子节点也是红色的进行右旋转

如果左右子节点都是红色的，进行颜色转换变成黑色。

@Override
public void put(Key key, Value value) {
    root = put(root, key, value);
    root.color = BLACK;
}

private Node put(Node x, Key key, Value value) {
    if (x == null) {
        Node node = new Node(key, value, 1);
        node.color = RED;
        return node;
    }
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        x.val = value;
    else if (cmp < 0)
        x.left = put(x.left, key, value);
    else
        x.right = put(x.right, key, value);

    if (isRed(x.right) && !isRed(x.left))
        x = rotateLeft(x);
    if (isRed(x.left) && isRed(x.left.left))
        x = rotateRight(x);
    if (isRed(x.left) && isRed(x.right))
        flipColors(x);

    recalculateSize(x);
    return x;
}

分析

根节点一定是黑色，因为ge根节点没有上层节点，也就没有上层节点的左连接指向根节点构成红树。

一颗大小为N的 红黑树的高度不会超过2logN ,最坏的情况下是它所对应的2-3树，构成最左边的全部是3-，其余的是2-。

操作大多数是对数级别。

 

liqiluan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图解红黑树之2-3查找树
TonyaBaSy
05-08 2510
树结构树结构有下面的几个缺点 空间：占空间较多相对于线性结构 创建：构造起来比较麻烦 维护：对于平衡树，结构修改（增、删）后又需要平衡 那么，既然这样为什么还要用树结构呢。原因很简单，它的插入和删除操作所使用的时间非常短。红黑树可以在O(log n)的时间内做查找、插入和删除操作。2-3查找树直接接受“红黑树”还是有些难以下咽的，红黑树跟2-3查找树有着千丝万缕的联系，因此这里从简单轻松的2-3查找
从2-3树理解红黑树
02-25
2-3树和红黑树是两种重要的自平衡二叉查找树（AVL树）类型，它们在数据结构和算法领域扮演着重要角色，尤其在高效的数据存储和检索方面。2-3树是一种特殊的树形数据结构，而红黑树则是一种对2-3树进行颜色编码以实现...
查找树（三）：红黑树（red black tree）
Ju的博客
09-02 651
目录：1. 红黑树（red black tree）2. 插入操作2.1 情况32.2 情况42.2.1 单旋转2.2.2 双旋转3. 删除操作3.1 情况1（X是黑色，X的兄弟是红色）3.2 情况2（X是黑色，X的兄弟是黑色）3.2.1 X的父节点为红色3.2.2 X的父节点为黑色 1. 红黑树（red black tree） 关于自平衡的二叉查找树，AVL树是比较经典的一种，前面也对其实现原理做了比较详细的介绍。当然，相关的数据结构肯定不止这一种，历史上AVL树流行的另一种变种是红黑树。 红黑树通过给节
2-3查找树 红黑树
sabot_v的博客
11-12 196
目录一. 2-3查找树1. 概述2. 插入方法 一. 2-3查找树 1. 概述 为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键。确切的说，我们将一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点，它含有两个键和三条链。2-结点和3-结点中的每条链都对应着其中保存的键所分割产生的一个区间。 2-3树其每个非叶节点都有两个或三个子女，而且所有叶都在统一层上。2-3树不是二叉树，其节点可拥有3个孩子。不过，2-3树与满二叉树相似。高为h的
五、高级数据结构和算法：2-3查找树、红黑树
小脑斧的博客
06-18 274
2-3树的原理和红黑树插入、删除等功能的实现
2-3树与红黑树
dianju8374的博客
09-26 162
第一次接触红黑树是在关于hashMap，上来就扔五个特性，说满足这五个特点的二分搜索树就是红黑树。 （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！] （4）如果一个节点是红色的，则它的子节点必须是黑...
AVL-红黑树-前缀树
05-16
AVL树、红黑树和前缀树是数据结构与算法中的重要概念，它们在高效地存储和检索数据方面有着广泛的应用。以下是关于这三种数据结构的详细解释： 1. AVL树： AVL树是一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E...
红黑树-基于Java实现的红黑树数据结构.zip
最新发布
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer在1972年提出，它的设计目标是兼顾查找、插入和删除等操作的高效性。红黑树的每个节点都带有颜色属性，可以是红色或黑色，通过颜色规则确保了树的平衡，...
二分搜索树-二叉查找树 .docx
03-13
不过，为了保持性能，需要对插入和删除操作进行平衡调整，比如使用AVL树或红黑树等自平衡二分搜索树。 在链表实现的二分搜索树中，每个节点包含键值、指向左右子节点的指针以及可能存在的额外信息。由于二分搜索树...
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
2. 重新着色和旋转，以恢复红黑树的性质。 3. 对于删除操作，首先要找到待删除节点，然后根据节点是否有子节点以及子节点的颜色进行不同的处理，可能需要进行替换、颜色转换和旋转操作。 C语言实现红黑树时，需要...
红黑树、二叉搜索树的实现和性能比较
03-12
实现红黑树、二叉搜索树相关算法：插入（红黑树涉及树的调整：左旋、右旋等），删除，搜索（指定Key值节点）。 另外，红黑树实现计算树黑高的算法。
数据结构之二叉查找树(Binary Search Tree)和红黑树(Red Black Tree)
刘跃辉的博客
09-23 5921
二叉查找树又可以称之为 : 二叉搜索树 , 二叉排序树 , 它或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势 , 下图中这棵树，就是一棵典型的二叉查找树。
2-3查找树与红黑树
sunlilan的博客
11-18 278
二叉查找树一种能够将链表插入的灵活性与有序数组查找的高效性结合起来的符号表实现。public class BST<Key extends Comparable<Key>,Value>{ private class Node{ Key key; Value val; Node left,right; int N; //以该结点为根
平衡树(查找树、红黑树)
一名小白的博客
08-16 247
15-平衡树(查找树、红黑树) 一、2-3查找树 为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键。确切的说，我们将一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点，它含有两个键和三条链。2-结点和3-结点中的每条链都对应着其中保存的键所分割产生的一个区间。 1.1 2-3查找树的定义 一棵2-3查找树要么为空，要么满足满足下面两个要求： 2-结点： 含有一个键(及其对应的值)和两条链，左链指向的2-3树中的键，都小于该结点的键
二叉查找树和红黑树（转载）
song_chengbo的博客
05-30 338
转载地址：https://mp.weixin.qq.com/s/-8JFh5iLr88XA4AJ9mMf6g ———————————— ———————————— 二叉查找树（BST）具备什么特性呢？ 1.左子树...
二叉查找树与红黑树原理和程序全面介绍
www.keything.net
12-08 4997
转载请注明出处http://blog.csdn.net/yankai0219/article/details/8273542 学习方法：我主要是参考算法导论以及Nginx中rbtree.h和rbtree.c两部分内容来学习红黑树的。网上有很多关于红黑树的介绍，不可否认，有很多文章讲的很详细，但是我想经典毕竟是经典，去阅读算法导论，将会使你更加明白红黑树的原理。一句话，读算法导论，
二叉查找树之红黑树（RBTree)
qq_52109814的博客
11-13 581
红黑树概念 红黑树是一种含有红黑两种结点并且能够自平衡的二叉查找树。 划重点：红黑结点，自平衡，二叉查找树。 红黑树也是二叉查找树的一种，实现这一点并不难，它主要困难在自平衡的处理。 红黑树的性质： （它在每个节点增加了一个存储位来记录节点的颜色，red或black） 每个节点要么是黑色，要么是红色。 根节点是黑色 每个叶节点是黑色 每个红色结点的两个子节点一定都是黑色（不会出现连续的两个红色结点） 任意一结点到每个叶节点的路径上都包含数量的黑结点 如果一个节点是黑节点，那么它一定有两个子节点 红黑
数据结构——平衡树【2-3查找树、红黑树】
龍弟-idea的博客
01-17 441
查找树的定义: 一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点（含有两个键和三条链）。 2- 结点： 含有一个键( 及其对应的值 ) 和两条链，左链接指向 2-3 树中的键都小于该结点，右链接指向的 2-3 树中的键都大于该结点。3-结点： 含有两个键 ( 及其对应的值 ) 和三条链，左链接指向的 2-3 树中的键都小于该结点，中链接指向的 2-3 树中的键都位于该结点的两个键之间，右链接指向的2-3 树中的键都大于该结点。 查找 将二叉查找树的查找算...
从二叉查找树、2-3树彻底理解红黑树
热门推荐
勿在浮沙筑高台
06-26 2万+
从二叉查找树、2-3树彻底理解红黑树 引言 在学习红黑树的时候，看了很多文章，发现都没有讲明白红黑树的原理，只是简单列了红黑树的几条规则，就开始讲解红黑树的插入，让人一直不知其所以然。也很难深刻的理解红黑树。 最后翻起了《算法》这本书，仔细了解了二叉树查找树、2-3树、红黑树，才明白了红黑树不是平白无故产生的，而是符合科学的发展观念是循序渐进，站在巨人的肩旁上发展起来的。 这也是我们从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值