红黑树-《算法导论》学习笔记十二

最新推荐文章于 2022-09-24 16:57:38 发布
最新推荐文章于 2022-09-24 16:57:38 发布
阅读量326 收藏
点赞数
分类专栏： 数据结构&算法 文章标签： 红黑树 算法导论 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012785877/article/details/70149407
版权

红黑树是一种二叉搜索树，它在每个结点上增加了一个存储为来表示结点的颜色，或红或黑，通过从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其它路径长出2倍，近似平衡的。

树种每个结点包含5个属性：color、key、left、right、parent，如果一个结点没有子结点或父结点，则该结点相应指针属性值指向空（这里的空不是空指针，而是定义一个空结点，结点颜色为黑色），一颗红黑树是满足几个特殊性质的二叉搜索树：

  • 每个结点或是红色的，或是黑色的
  • 根结点是黑色的
  • 每个叶结点（亦即空结点）为黑色的
  • 如果一个结点是红色的，则它的两个子结点都是黑色的
  • 对每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点（经过的黑色结点数为黑高）

与二叉搜索树相似，红黑树也有一些操作接口：

  • 遍历
  • 寻找结点中序遍历的后继:tree_minimum
  • 寻找结点中序遍历的前驱:tree_maximum
  • 结点左右旋转（红黑树不同于二叉搜索树的操作），用来平衡黑高
    • 左旋：结点的父结点的左孩子指向结点的右孩子，右孩子的左孩子变为结点的右孩子，右孩子变为它的父结点
    • 右旋：结点的父结点的右孩子指向结点的左孩子，做孩子的右孩子变为结点的左孩子，左孩子变为它的父结点
  • 插入，插入一个新结点时，考虑如果插入黑色结点，破坏了原树的红黑性质（黑高），要进行重新平衡
  • 删除，删除了一个结点后，考虑如果删除的是黑色结点，或删除了结点，后继提升到删除节点的位置后，平衡红黑性质

———-插入

  1. 如果结点的父结点为黑色，表示没插入这个结点前满足红黑树
    性质，且插入这个红色结点后，也不影响红黑树黑高，故保持当前位置

  2. 如果结点的父结点为红色，那么判断插入结点与父结点，以及父结点的
    父结点，叔结点，这四个结点是否组成一个倒立的”v”字形：

    (1). 如果是倒立”v”，则插入结点的父结点为红色，破坏了红黑树的：红
    色结点的左右孩子都为黑色的性质，故父结点一定要变为黑色;
    那么将父结点变为黑色;

    判断叔结点若为红色，则将叔结点变为黑色，父结点的父结点变为红色，
    插入结点的指针指向父结点的父结点，再次从步骤1判断（因为经过变换，
    从插入结点的父结点的父结点开始的子数都满足红黑树性质，只需要将
    父结点的父结点单独当作一个新插入它的父结点的子结点再进行处理即可）;

    否则叔结点为黑色，则直接将父结点的父结点变为红色，但是这样做之后，
    父结点因为变为黑色，而叔结点还是黑色，两个子树路径的黑高相差1,要
    维持黑高相等，则将父结点的父结点的父结点向叔结点相同的方向旋转（
    可以针对这种情况画图，会发现这样旋转后，两个黑高不一样的子树分开了，
    ，且满足红黑树性质）。

    (2). 如果不是倒立”v”，即插入结点的父结点所处子树为某方向上的子树，但插入
    结点又是父结点另一方的孩子结点，则只需要进行一下旋转，就将结点变为
    倒立的”v”形状，继续从步骤1开始作为倒立”v”子树判断。

  3. 将根结点变为黑色

———-删除

  1. 以指针p指向待删除结点node，p_color记录node颜色

  2. 判断node的左右孩子
    (1). 如果左孩子为空
    寻找node的右孩子，记为q（不管是否指向空）
    用q结点替换node结点

    (2). 但如果右孩子为空
    寻找node的左孩子，记为q（不管是否指向空）
    用q结点替换node结点

    (3). 否则左右孩子都不为空
    寻找node的中序遍历后继(tree_minimum())，p指向它;

    p_color记录后继的颜色;

    q指向p的右结点（不管是否为空）;

    判断p的父结点是否为node:是，则， q的父结点设为p（只有当q为空结点时有用）/否，则，用p的右结点替换p(rb_transplant(tree, p, p->right))，用p结点接管node结点右子树（p->right = node->right, p->right->parent = p）;

    用p结点替换node结点(rb_transplant(tree, node, p));

    p结点接管node结点左子树(p->left = node->left,p->left->parent = p);

    p结点的颜色设置为node结点的颜色

  3. 判断p_color的颜色如果为黑色，表示删除结点后，黑高可能-1,
    要修复红黑树，从结点q处开始修复红黑树，根据q的颜色来修复

  4. 循环.直到q结点不为根结点以及p结点的颜色不为黑色

    (1). 如果node的兄弟结点为红色
    （因为node结点替换了删除结点，黑高-1,与兄弟结点子树黑高差1）
    设置兄弟结点为黑色，父结点设置为红色，从父结点开始向node一侧旋转，兄弟结点成为新的子树根结点，因为兄弟结点为黑色，则经过兄弟结点到node结点的子树黑高+1,平衡，但对于兄弟结点的父结点的子树，黑高又可能不平衡，node指针指向兄弟结点，继续步骤4

    (2). 如果node的兄弟结点为黑色，且兄弟结点的左右孩子均为黑色
    （因为node结点替换了删除结点，黑高-1,与兄弟结点子树黑高差1）
    设置兄弟结点颜色为红色，兄弟结点子树黑高-1,达到平衡，但父结点以上的子树可能受影响，node指针指向父结点，继续步骤4

    (3). 如果node的兄弟结点为黑色，且兄弟结点的靠近node一侧的孩子结点颜色为红色，另一侧的孩子结点为黑色
    （因为node结点替换了删除结点，黑高-1,与兄弟结点子树黑高差1）
    兄弟结点靠近node一侧的孩子结点设置为黑色，兄弟结点设置为红色，从兄弟结点开始进行向远离node一侧旋转，兄弟结点的孩子结点成为它的父结点，原兄弟结点的左右子树黑高不变，但node结点所处子树因为替换删除结点，黑高-1，还是没有平衡，node指针指向新的兄弟结点的孩子结点，继续4

    (4). 如果node的兄弟结点为黑色，且兄弟结点的远离node一侧的孩子结点颜色为红色，另一侧颜色未知
    （因为node结点替换了删除结点，黑高-1,与兄弟结点子树黑高差1）
    兄弟结点设置为node父结点的颜色，父结点设置为黑色，兄弟结点为红色的设置为黑色，然后从node父结点开始进行向node一侧旋转，旋转前，可以思考，父结点若为红色，旋转后不改变子树黑高，若父结点为黑色，旋转后也不会改变黑高经过一轮变换后，node结点的父结点的父结点左右子树黑高一样，且经过node替换后-1的黑高，因为变换，又+1,本子树在整个红黑树中没有破坏黑高一致性，故将node指针指向整个树的根结点，跳出循环

  5. 设置node指针的结点颜色为黑色

代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>

//#define COLOR_RED   1;
//#define COLOR_BLACK 2;



typedef enum color {
    COLOR_RED,
    COLOR_BLACK
}color;

typedef struct rbTreeNode {
    int key;
    color color;
    struct rbTreeNode *parent;
    struct rbTreeNode *left;
    struct rbTreeNode *right;
}rbTreeNode;

typedef struct rbTree {
    int node_num;
    int height;
    rbTreeNode *root;
    rbTreeNode *null;
}rbTree;

void print_tree( rbTree * );

rbTreeNode *tree_minimum(
    rbTreeNode *root,
    rbTreeNode *null )
{
    while ( root->left != null ) {
        root = root->left;
    }

    return root;
}

rbTreeNode *tree_maximum(
    rbTreeNode *root,
    rbTreeNode *null )
{
    while ( root->right != null ) {
        root = root->right;
    }

    return root;
}


void left_rotate(
    rbTree *tree,
    rbTreeNode *node )
{
    rbTreeNode *p = node->right;
    node->right = p->left;

    if ( p->left != tree->null )
        p->left->parent = node;

    p->parent = node->parent;

    if ( node->parent == tree->null )
        tree->root = p;
    else if ( node == node->parent->left )
        node->parent->left = p;
    else
        node->parent->right = p;

    p->left = node;
    node->parent = p;
}
void right_rotate(
    rbTree *tree,
    rbTreeNode *node )
{
    rbTreeNode *p = node->left;
    node->left = p->right;

    if ( p->right != tree->null )
        p->right->parent = node;

    p->parent = node->parent;

    if ( node->parent == tree->null )
        tree->root = p;
    else if ( node == node->parent->right )
        node->parent->right = p;
    else
        node->parent->left = p;

    p->right = node;
    node->parent = p;
}
void rb_insert_fixup(
    rbTree *tree,
    rbTreeNode *node )
{
    rbTreeNode *p = tree->null;

    while ( node->parent->color == COLOR_RED ) {
        if ( node->parent == node->parent->parent->left ) {

            p = node->parent->parent->right;
            if ( p->color == COLOR_RED ) {
                node->parent->color = COLOR_BLACK;
                p->color = COLOR_BLACK;
                node->parent->parent->color = COLOR_RED;
                node = node->parent->parent;
            } else if ( node == node->parent->right ) {
                node = node->parent;
                left_rotate( tree, node );
            } else {
                node->parent->color = COLOR_BLACK;
                node->parent->parent->color = COLOR_RED;
                right_rotate( tree, node->parent->parent );
            }

        } else {

            p = node->parent->parent->left;
            if ( p->color == COLOR_RED ) {
                node->parent->color = COLOR_BLACK;
                p->color = COLOR_BLACK;
                node->parent->parent->color = COLOR_RED;
                node = node->parent->parent;
            } else if ( node == node->parent->left ) {
                node = node->parent;
                right_rotate( tree, node );
            } else {
                node->parent->color = COLOR_BLACK;
                node->parent->parent->color = COLOR_RED;
                left_rotate( tree, node->parent->parent );
            }

        }
    }

    tree->root->color = COLOR_BLACK;
}
void rb_insert(
    rbTree *tree,
    rbTreeNode *node )
{
    rbTreeNode *p = tree->null;
    rbTreeNode *q = tree->root;

    while ( q != tree->null ) {
        p = q;
        if ( node->key < q->key )
            q = q->left;
        else
            q = q->right;
    }

    node->parent = p;

    if ( p == tree->null )
        tree->root = node;
    else if ( node->key < p->key )
        p->left = node;
    else
        p->right = node;

    node->left = tree->null;
    node->right = tree->null;
    node->color = COLOR_RED;
    rb_insert_fixup( tree, node );
}
void rb_transplant(
    rbTree *tree,
    rbTreeNode *node_a,
    rbTreeNode *node_b )
{
    if ( node_a->parent == tree->null )
        tree->root = node_b;
    else if ( node_a == node_a->parent->left )
        node_a->parent->left = node_b;
    else
        node_a->parent->right = node_b;

    node_b->parent = node_a->parent;
    free( node_a );
}
void rb_delete_fixup(
    rbTree *tree,
    rbTreeNode *node )
{
    rbTreeNode *p = tree->null;

    while ( node != tree->null && node->color == COLOR_BLACK ) {
        if ( node == node->parent->left ) {
            p = node->parent->right;
            if ( p->color == COLOR_RED ) {
                p->color = COLOR_BLACK;
                node->parent->color = COLOR_RED;
                left_rotate( tree, node->parent );
                p = node->parent->right;
            } else if ( p->left->color == COLOR_BLACK
                && p->right->color == COLOR_BLACK ) {
                p->color = COLOR_RED;
                node = node->parent;
            } else if ( p->right->color == COLOR_BLACK ) {
                p->left->color = COLOR_BLACK;
                p->color = COLOR_RED;
                right_rotate( tree, p );
                p = node->parent->right;
            } else {
                p->color = node->parent->color;
                node->parent->color = COLOR_BLACK;
                left_rotate( tree, node->parent );
                node = tree->root;
            }
        } else {
            p = node->parent->left;
            if ( p->color == COLOR_RED ) {
                p->color = COLOR_BLACK;
                node->parent->color = COLOR_RED;
                right_rotate( tree, node->parent );
                p = node->parent->left;
            } else if ( p->left->color == COLOR_BLACK
                && p->right->color == COLOR_BLACK ) {
                p->color = COLOR_RED;
                node = node->parent;
            } else if ( p->left->color == COLOR_BLACK ) {
                p->right->color = COLOR_BLACK;
                p->color = COLOR_RED;
                left_rotate( tree, p );
                p = node->parent->left;
            } else {
                p->color = node->parent->color;
                node->parent->color = COLOR_BLACK;
                right_rotate( tree, node->parent );
                node = tree->root;
            }
        }
    }
    node->color = COLOR_BLACK;
}
void rb_delete(
    rbTree *tree,
    rbTreeNode *node )
{
    rbTreeNode *p = node;
    rbTreeNode *q = tree->null;
    color origin_color = p->color;

    if ( node->left == tree->null ) {
        q = node->right;
        rb_transplant( tree, node, node->right );
    } else if ( node->right == tree->null ) {
        q = node->left;
        rb_transplant( tree, node, node->left );
    } else {
        p = tree_minimum( node->right, tree->null );
        origin_color = p->color;
        q = p->right;

        if ( p->parent == node )
            q->parent = p;
        else {
            rb_transplant( tree, p, p->right );
            p->right = node->right;
            p->right->parent = p;
        }

        rb_transplant( tree, node, p );
        p->left = node->left;
        p->left->parent = p;
        p->color = node->color;
    }

    if ( origin_color == COLOR_BLACK )
        rb_delete_fixup( tree, q );
}
int random_num()
{
    int a = 1;
    int b = 100;

    return rand() % ( b - a ) + a;
}
void postorder_tree_free(
    rbTreeNode *root,
    rbTreeNode *null )
{
    if ( root != null ) {
        postorder_tree_free( root->left, null );
        postorder_tree_free( root->right, null );
        free( root );
    }
}
void inorder_tree_walk(
    rbTreeNode *root,
    rbTreeNode *null )
{
    if ( root != null ) {
        inorder_tree_walk( root->left, null );
        printf("%d(%d) ", root->key, root->color);
        inorder_tree_walk( root->right, null );
    }
}
void preorder_tree_walk(
    rbTreeNode *root,
    rbTreeNode *null )
{
    if ( root != null ) {
        printf("%d(%d) ", root->key, root->color);
        preorder_tree_walk( root->left, null );
        preorder_tree_walk( root->right, null );
    }
}
void postorder_tree_walk(
    rbTreeNode *root,
    rbTreeNode *null )
{
    if ( root != null ) {
        postorder_tree_walk( root->left, null );
        postorder_tree_walk( root->right, null );
        printf("%d(%d) ", root->key, root->color);
    }
}
void print_tree(
    rbTree *tree )
{
    printf("中序:");
    inorder_tree_walk( tree->root, tree->null );
    printf("\n");
    printf("前序:");
    preorder_tree_walk( tree->root, tree->null );
    printf("\n");
    printf("后序:");
    postorder_tree_walk( tree->root, tree->null );
    printf("\n\n");
}
rbTreeNode *tree_search_recursion(
    rbTreeNode *root,
    int key,
    rbTreeNode *null)
{
    if ( root == null || key == root->key ) {
        return root;
    }

    if ( key < root->key )
        return tree_search_recursion( root->left, key, null );
    else
        return tree_search_recursion( root->right, key, null );
}

rbTreeNode *tree_search(
    rbTreeNode *root,
    int key,
    rbTreeNode *null )
{
    while ( root != null && key != root->key ) {
        if ( key < root->key )
            root = root->left;
        else
            root = root->right;
    }

    return root;
}
// 找前驱 即中序遍历的前一个位置值
rbTreeNode *tree_predecessor(
    rbTreeNode *node,
    rbTreeNode *null )
{
    if ( node->left != null )
        return tree_maximum( node->left, null );

    rbTreeNode *p = node->parent;

    while ( p != null && node == p->left ) {
        node = p;
        p = p->parent;
    }

    return p;
}
// 找后继 即中序遍历的后一个位置值
rbTreeNode *tree_successor(
    rbTreeNode *node,
    rbTreeNode *null )
{
    if ( node->right != null )
        return tree_minimum( node->right, null );

    rbTreeNode *p = node->parent;

    while ( p != null && node == p->right ) {
        node = p;
        p = p->parent;
    }

    return p;
}
void free_tree(
    rbTree *tree )
{
    rbTreeNode *root = tree->root;

    postorder_tree_free( root, tree->null );

    free( tree );
}
int main(
    int argc,
    char **argv )
{
    srand((int)time(NULL));

    int i = 10;
    int len = 10;
    int arr[10] = {10,4,15,14,5, 2,8,13,1,19};

    rbTree *tree = ( rbTree * )malloc( sizeof(rbTree) );
    tree->node_num = 0;
    tree->height = 0;
    tree->null = ( rbTreeNode * )malloc( sizeof(rbTreeNode) );
    tree->null->color = COLOR_BLACK;
    tree->root = tree->null;

    for ( i = 0; i < len; i++ ) {
        rbTreeNode *node =
            ( rbTreeNode * )malloc( sizeof(rbTreeNode) );
        //node->key = random_num();
        node->key = arr[i];
        node->parent = tree->null;
        node->left = tree->null;
        node->right = tree->null;
        rb_insert( tree, node );
        printf("insert %d successfully\n", arr[i]);
    }

    print_tree( tree );

    rbTreeNode *delete_node = tree_search( tree->root, 4, tree->null );

    if ( delete_node != tree->null ) {
        rb_delete( tree, delete_node );
    }
    printf("\n删除%d的节点后遍历顺序为:\n", 4);
    print_tree( tree );
    printf("\n");

    delete_node = tree_search( tree->root, 15, tree->null );
    if ( delete_node != tree->null ) {
        rb_delete( tree, delete_node );
    }
    printf("\n删除%d的节点后中序遍历顺序为:\n", 15);
    print_tree( tree );
    printf("\n");

    free_tree( tree );

    return 0;
}
lkness
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树的高度
gottawangzi的博客
08-14 1万+
     在复习红黑树的特性时，产生了这样的一个疑问,红黑树的高度是多少呢？在Java8，HashMap所使用的拉链法散列表中，如果储存元素的键值与原来储存元素的键值发生了Hash冲突，如果val值不一样，会将该元素存放在红黑树的数据结构中。     红黑树查找一个元素所需要的时间最坏是2lgN，插入一个元素最坏情况所需要的时间是2lgN，查找命中所需要的平均时间是lgN，插入一个元素所需要的平...
红黑树
crazy的博客
10-04 745
1、 》》说明：红黑树（red-black tree）是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本 动态集合操作的时间复杂度为O( lg n)。 2、红黑树的性质 》》 1）、红黑树是一种二叉搜索树，它在每个结点上增加一个存储位来表示结点的颜色，可以是 RED或者 BLACK 。通过对任何一条从根到叶子的简单路径上各个结点...
红黑树详解
sparky的博客
11-05 593
文章目录红黑树的性质黑高（不包含它本身）红黑树的插入红黑树的高度 红黑树的性质 红黑树必须是一棵二叉排序树 黑高（不包含它本身） 红黑树的插入 在插入一个结点的时候，左友根、跟叶黑、黑路同同这三条特性是不会变的 所以如果新结点不是根结点的话，每一次新插入一个新结点后只需要看有没有违背“不红红”这个特性 每一个新插入的非根结点都要染成红色：为了保证 ‘’黑路同‘’ 的特性。红结点不会增加黑路的长度 LL型： 将新插入结点的父结点右旋，转到新结点的爷爷结点上，爷结点相应的就降低
红黑树 学习笔记1 - 基本性质
rsy56640的博客
03-21 298
本系列为算法导论 第13章 红黑树 学习笔记 RB_Tree是一颗BST，满足： 1. 结点颜色为红或黑。 2. 根结点为黑色。 3. 每个叶结 (NIL) 点是黑色。 4. 不存在2个连续的红色结点 5. 对于任一结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。 先做一些人为的约定： \quad 树根的高度为1； \quad 叶结点指的是 NILNILN...
红黑树原理详解
selfsongs
08-04 2171
STL源码剖析—红黑树原理详解上 https://blog.csdn.net/Hackbuteer1/article/details/7740956 1、黑父 如下图所示，如果新节点的父结点为黑色结点，那么插入一个红点将不会影响红黑树的平衡，此时插入操作完成。红黑树比AVL树优秀的地方之一在于黑父的情况比较常见，从而使红黑树需要旋转的几率相对AVL树来说会少一些。 2、红父 如果新节点的父结点为红色，这时就需要进行一系列操作以保证整棵树红黑性质。如下图所示，由于父结点为红色，此时可以判定，祖父结点必定为黑
算法导论授课教案学习笔记
01-31
这份"算法导论授课教案学习笔记"是针对该书的深入学习资源，包括了教学教案、课后作业及解答，对于正在学习算法的学生来说，无疑是一份极其宝贵的参考资料。 教程部分可能涵盖以下知识点： 1. **算法基础**：介绍...
[麻省理工学院-算法导论].Introduction.to.Algorithms.-.Lecture.Notes
11-22
7. **数据结构**：包括数组、链表、栈、队列、树（二叉树、平衡树如AVL树、红黑树）、哈希表等，这些是算法实现的基础工具。 8. **复杂度分析**：了解算法的时间复杂度和空间复杂度，如大O表示法，有助于评估算法的...
MIT算法导论公开课的课程笔记（个人总结）
08-30
这份压缩包中的“MIT算法导论公开课之课程笔记”无疑是学习者宝贵的参考资料，它涵盖了课程的精华内容，可以帮助我们更好地理解和掌握算法的核心概念。 算法在计算机科学中扮演着至关重要的角色，它们是解决问题和...
MIT算法导论公开课之课程笔记 平衡搜索树.rar
07-06
在MIT的算法导论课程中，学生将深入学习这些数据结构的原理、操作以及性能分析。通过理解平衡搜索树的工作机制，可以设计出更高效的数据存储和检索解决方案，这对于软件工程师、数据库管理员以及其他涉及数据处理的...
麻省理工-算法导论资料~~~
09-07
"麻省理工-算法导论Lecture.Notes.rar"是一个压缩包，其中包含了多个PDF文件，很可能是MIT课程中的讲义或笔记，涵盖了算法导论课程的关键内容。 在这些文件名中，我们可以推测出压缩包内可能包含的课程主题： 1. ...
数据结构---红黑树
池海
04-23 911
红黑树本质是二叉搜索树的一个变种，它在每个节点上增加了一个存储位来表示节点的颜色，可以是红或者黑。通过对任何一条根节点到叶子结点的路径上各个节点的颜色进行约束，确保没有任何一条路径会比其它路径长出2倍，从而达到近似于平衡。 红黑树包含五大特性： 每个节点要么是黑色，要么是红色 根节点一定是黑色 每个叶子结点(NIL)一定是黑色 每个红色节点的两个子节点一定是黑色，即不能有两个红色节点相连 任意一...
红黑树的定义（上篇）
最新发布
u012345683的博客
09-24 1375
每个节点都有一种颜色，不是红色就是黑色；树的根节点是黑色；树中不存在两个相邻的红色节点（红色节点的父节点和孩子节点中都不能含有红色节点）；从任意节点出发到其任何后代节点的每条路径中包含的黑色节点的数量相同。注意：为了更好的进行插入和删除操作，我们将所以的叶子节点的左右孩子节点设置为黑色的null节点，即逻辑空节点，但是在代码遍历的时候可以访问到。
算法——红黑树
MKhaha20930079的博客
02-12 501
定义 近似平衡的二叉搜索树   二叉搜索树可能退化成链表，也就有了“平衡”搜索树，树高h=O(log(n))，保证了树高，也就保证了基本操作时间复杂度的稳定性。红黑树是一种“平衡”二叉搜索树。当然不是严格平衡，“红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的”。 性质或者说定义 每个结点或者是红色的，或者是黑色的。 根结点是黑色的。 每个叶结点（叶结点即指树尾端NIL结点）是黑色...
红黑树真的没你想的那么难
一个学渣走向android之路
07-06 1万+
概述 TreeMap是红黑树的java实现，红黑树能保证增、删、查等基本操作的时间复杂度为O(lgN)。 首先我们来看一张TreeMap的继承体系图： 还是比较直观的，这里来简单说一下继承体系中不常见的接口NavigableMap和SortedMap，这两个接口见名知意。先说NavigableMap接口，NavigableMap接口声明了一些列具有导航功能的方法，比如： /...
算法导论 红黑树(附带黑高度)
苦海无涯闯进来
05-12 2090
1
快速理解红黑树原理
热门推荐
jjc120074203的博客
01-31 3万+
红黑树 红黑树 其实就是一个二叉树。 常用的二叉树类型 简单说二叉树概念： 二叉树 又称度为至多二的树。 平衡二叉树 平衡二叉树又称 AVL 树 特点：一个根节点的左右个子树的高度差不超过1 平衡二叉树 非平衡二叉树 高度差已经大于1 了。 平衡树解决的问题就是 能够最大限度的增加访问的每个节点的的平均性 。保证每个节点被访问的次数平衡。 完全二叉树
《算法导论》学习笔记：基础知识与算法入门
第四部分：高级设计和分析技术 第 12 章：贪心算法 1. 贪心算法是一种常用的算法思想，它每次都选择当前看起来最好的选择，希望最终能够得到全局最优解。 2. 贪心算法的适用范围比较广泛，但需要合理设计问题的模型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值