数据结构之基数树（radix_tree）

最新推荐文章于 2024-06-13 10:40:41 发布
最新推荐文章于 2024-06-13 10:40:41 发布
阅读量3.2k 收藏 19
点赞数 2
分类专栏： 算法专题 【LeetCode】
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/Poisx/article/details/115433816
版权

数据结构之基数树（radix_tree）

基数树（radix_tree）

基数树数据结构是在字典树（trie_tree）的原理上优化过来的， 是更加合理的使用内存和查询的效率。

一，基数树数据的结构的介绍

基数树数据结构是字典树上进行可以前项压缩的数据优化的，基本和字典树数是一样的当是有区别的是进行内存优化的操作。基数树通常使用在ip地址保存操作。

1， 没有进行前项压缩的结构

在这里插入图片描述

2， 前项压缩的操作结构图

蓝色节点下面都黄色节点没有蓝色的节点就进行压缩的工作

在这里插入图片描述

二， 基数树应用场景介绍

应用用于IP 路由的映射关系中。长整型的哈希冲突问题解决 （nginx，redis，linux中都使用到了）

三，基数树实现

1， 在创建基数树预先分配A类地址的数前8位

预先分配字段是8的由来

类前缀长度前缀首字节
A类地址8位0xxxxxxx0~127
B类地址16位10xxxxxx xxxxxxxx128~191
C类地址24位110xxxxx xxxxxxxx xxxxxxxx192~223
D类地址不可用1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx224~-239
E类地址不可用1111xxxx xxxxxxxx xxxxxxxx xxxxxxxx240~255

对应代码

	uint32 mask = 0x80000000;
	
    uint32 preallocate = 8; //预先分配A类地址的数前8bit位
    while (preallocate--)
    {
        mask >>= 1;  // ip 地址掩码 是不同的
        mask |= 0x80000000;
        printf("mask = %u\n", mask);
    }

output

 mask = 2147483648 ==> 1000 0000 0000 0000 0000 0000 0000 0000
 mask = 3221225472 ==> 1100 0000 0000 0000 0000 0000 0000 0000
 mask = 3758096384 ==> 1110 0000 0000 0000 0000 0000 0000 0000
 mask = 4026531840 ==> 1111 0000 0000 0000 0000 0000 0000 0000
 mask = 4160749568 ==> 1111 1000 0000 0000 0000 0000 0000 0000
 mask = 4227858432 ==> 1111 1100 0000 0000 0000 0000 0000 0000
 mask = 4261412864 ==> 1111 1110 0000 0000 0000 0000 0000 0000
 mask = 4278190080 ==> 1111 1111 0000 0000 0000 0000 0000 0000
 mask = 4286578688 ==> 1111 1111 1000 0000 0000 0000 0000 0000


#include <stdio.h>
#include  <stdlib.h>
#include  <string.h>
#include <assert.h>

typedef unsigned int	uint32;
typedef signed int		int32;

/**
 * 默认地址
 */
#define default_ip "127.0.0.1"

// 基数树 应用场景ip地址映射
struct cradix_tree_node
{
    struct cradix_tree * left;
    struct cradix_tree * right;
    char * value; //实际的ip数据
}cradix_tree;

struct cradix_tree
{
    struct cradix_tree_node * root;
    uint32  size; //预先分配默认A类地址的数前8位
};


/**
 * 基数树插入ip的地址映射关系
 * @param tree_ptr
 * @param key
 * @param mask
 * @param value
 * @return
 */
void * cradix_tree_insert(struct cradix_tree * tree_ptr, uint32 key, uint32 mask, void * value)
{
    assert(tree_ptr != NULL);
    if (!tree_ptr)
    {
        return NULL;
    }

    struct cradix_tree_node * cur_node = tree_ptr->root;
    struct cradix_tree_node * next_node = tree_ptr->root;


    //uint32 mask = 0;
    uint32 bit = 0x80000000;
    while (bit & mask)
    {
        //找到合适的位置插入
        if (bit & key)
        {
            next_node = (struct cradix_tree_node *)cur_node->right;
        }
        else
        {
            next_node = (struct cradix_tree_node *)cur_node->left;
        }
        if (!next_node)
        {
            break;
        }
        cur_node = next_node;
        bit >>= 1; //高位
    }

    if (next_node)
    {
        if (cur_node->value)
        {
            cur_node->value = value;
            return next_node;
        }

        cur_node->value = value;
        return cur_node;
    }

    while (bit & mask)
    {
        next_node = malloc(sizeof(struct cradix_tree_node));
        assert(next_node != NULL);

        {
            next_node->left = NULL;
            next_node->right = NULL;
            next_node->value = NULL;
        }
        if (bit & key)
        {
            cur_node->right = (void *)next_node;
        }
        else
        {
            cur_node->left = (void *)next_node;
        }
        bit >>= 1;
        cur_node = next_node;
        next_node = NULL;
    }

    if (cur_node)
    {
        cur_node->value = value;
    }
    return cur_node;
}

/**
 * 创建基数树
 * 预先分配A类地址的数前8bit位
 * @return
 */
struct cradix_tree * create_radix_tree()
{
    struct cradix_tree * tree_ptr = malloc(sizeof(struct cradix_tree));
    assert(tree_ptr != NULL);
    if (!tree_ptr)
    {
        return  NULL;
    }

    tree_ptr->root = NULL;
    tree_ptr->size = 8;
    tree_ptr->root = malloc(sizeof(struct cradix_tree_node));
    assert(tree_ptr->root != NULL);
    if(!tree_ptr->root)
    {
        return NULL;
    }
    {
        tree_ptr->root->left = NULL;
        tree_ptr->root->right = NULL;
        tree_ptr->root->value = NULL;
    }


    //建立基数树高度为 32为ip地址的树高度

    uint32 inc = 0x80000000; // 对应32位 1000 0000 0000 0000 0000 0000  0000 0000
    uint32 key = 0;
    uint32 mask = 0; //掩码

    uint32 preallocate = tree_ptr->size; //预先分配A类地址的数前8bit位
    while (preallocate--)
    {
        key = 0;
        mask >>= 1;  // ip 地址掩码 是不同的
        mask |= 0x80000000;
        // 1000 0000 0000 0000 0000 0000 0000 0000  0000 0000
        /**
           *   ip的掩码 A类地址[8bit]  B类地址[16bit] C类地址[24bit] D,E类型地址不可用
         *   | 类   | 前缀长度   |  前缀
         *   |A类地址|  8位      | 0xxxxxxx                                              |
         *   |B类地址| 16位      | 10xxxxxx   xxxxxxxx                                   |
         *   |C类地址| 24位      | 110xxxxx   xxxxxxxx   xxxxxxxx                        |
         *   |D类地址| 不可用     | 1110xxxx   xxxxxxxx   xxxxxxxx     xxxxxxxx           |
         *   |E类地址| 不可用     | 1111xxxx   xxxxxxxx   xxxxxxxx     xxxxxxxx  			|
         *   
         * mask 对应 就是 A类地址的前8位bit位（默认第32位是1在代码中）
            mask = 2147483648 ==> 1000 0000 0000 0000 0000 0000 0000 0000
            mask = 3221225472 ==> 1100 0000 0000 0000 0000 0000 0000 0000
            mask = 3758096384 ==> 1110 0000 0000 0000 0000 0000 0000 0000
            mask = 4026531840 ==> 1111 0000 0000 0000 0000 0000 0000 0000
            mask = 4160749568 ==> 1111 1000 0000 0000 0000 0000 0000 0000
            mask = 4227858432 ==> 1111 1100 0000 0000 0000 0000 0000 0000
            mask = 4261412864 ==> 1111 1110 0000 0000 0000 0000 0000 0000
            mask = 4278190080 ==> 1111 1111 0000 0000 0000 0000 0000 0000
            mask = 4286578688 ==> 1111 1111 1000 0000 0000 0000 0000 0000
         */
        //遍历从树的顶层向下遍历
        do
        {
            //插入当前节点的数据
            cradix_tree_insert(tree_ptr, key, mask, NULL);
            //这边看出来了吗？  就加到内存溢出 就变成'0'啊
            key += inc; // 举例  == [0x80000000 + 0x80000000] = [0x100000000]  但是无符号int类型放不下这个数据所以 就是 [0x00000000] 高位溢出
        } while (key);
        inc >>= 1;
    }

    return tree_ptr;
}

/**
 * 基数树的查找O(logn)
 * @param tree_ptr
 * @param key
 * @return
 */
char * cradix_tree_find(struct cradix_tree * tree_ptr, uint32 key)
{
    assert(tree_ptr != NULL);
    if (!tree_ptr)
    {
        return NULL;
    }
    uint32 bit = 0x80000000;
    struct cradix_tree_node * cur_node = tree_ptr->root;
    void * ptr = NULL;
    while (cur_node)
    {
        if (cur_node->value)
        {
            ptr = cur_node->value;
        }
        if (key & bit)
        {
            cur_node = (struct cradix_tree_node *)cur_node->right;
        }
        else
        {
            cur_node = (struct cradix_tree_node *)cur_node->left;
        }
        bit >>= 1;
    }
    if (!ptr)
    {
        return default_ip;
    }
    return ptr;
}

/**
 * 递归释放基数树的节点的内存
 * @param tree_ptr
 */
void cradix_tree_node_destroy(struct cradix_tree_node *tree_ptr)
{
    if (!tree_ptr)
    {
        return;
    }
    cradix_tree_node_destroy((struct cradix_tree_node *)tree_ptr->left);
    if (tree_ptr->left)
    {
        free(tree_ptr->left);
        tree_ptr->left = NULL;
    }
    cradix_tree_node_destroy((struct cradix_tree_node *)tree_ptr->right);
    if (tree_ptr->right)
    {
        free(tree_ptr->right);
        tree_ptr->right = NULL;
    }
}

/**
 * 释放基数树内存
 * @param tree_ptr
 */
void cradix_tree_destroy(struct cradix_tree** tree_ptr)
{
    assert(tree_ptr != NULL);
    if (!tree_ptr)
    {
        return ;
    }

    cradix_tree_node_destroy((struct cradix_tree_node *)(*tree_ptr)->root);

    if ((*tree_ptr))
    {
        if ((*tree_ptr)->root)
        {
            free((*tree_ptr)->root);
            (*tree_ptr)->root = NULL;
        }
        free((*tree_ptr));
        (*tree_ptr) = NULL;

    }
}

/**
 * 测试数据结构
 */
struct ip_proxy {
    uint32  ip; // ip-> uint32
    uint32  mask; // 掩码
    char *  value; //映射的数据
};

/**2^0 = 1;
 * 2^1 = 2;
 * 2^2 = 4
 * 2^3 = 8
 * 2^4 = 16
 * 2^5 = 32
 * 2^6 = 64
 * 2^7 = 128
 *
 *
 * 测试数据
 *
 */
struct ip_proxy ip_data[] =
{         // 128 + 64 + 32 +15 = 96+15 +128 = 111+128 = 239  === 255 - 16 = 239
        { 4009754624/*1110 1111 0000 0000 0000 0000 0000 0000 == 239.0.0.0*/,  4278190080 /*1111 1111 0000 0000 0000 0000 0000 0000 === 255.0.0.0*/, "192.168.1.90"},
        { 4093640704,  4278190080, "192.168.1.91"},
        { 4160749568,  4278190080, "192.168.1.93"},
        { 4244635648, 4278190080, "wangyang"},
        { 3841982464, 4278190080, "shanghui"},
        { 2566914048, 4278190080, "beijing"}
};



//void show(struct cradix_tree_node * tree)
//{
//    if (!tree)
//    {
//        return;
//    }
//    printf(" vlaue %s\n", tree->value);
//    show(tree->left);
//    show(tree->right);
//}



int main(int argc, char *argv[])
{

    struct cradix_tree * tree_ptr = create_radix_tree();
    if (!tree_ptr)
    {
        return -1;
    }

    for (int i = 0; i < (sizeof(ip_data) / sizeof(struct ip_proxy)); ++i)
    {
        cradix_tree_insert(tree_ptr, ip_data[i].ip, ip_data[i].mask, ip_data[i].value);
    }
    ///show(tree_ptr->root);
    for (int i = 0; i < (sizeof(ip_data) / sizeof(struct ip_proxy)); ++i)
    {
        printf("ip mask  = %u, ip_proxy = %s, new_ip_proxy = %s\n", ip_data[i].ip, ip_data[i].value, cradix_tree_find(tree_ptr, ip_data[i].ip) );
    }
    //默认代理ip地址
    printf("not ip mask  = %u, ip_proxy = %s, new_ip_proxy = %s\n", 23432, "", cradix_tree_find(tree_ptr, 23432) );
    cradix_tree_destroy(&tree_ptr);
    return EXIT_SUCCESS;

总结：

源码地址:https://github.com/chensongpoixs/cleet_code

chen_song_
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基数树(radix tree)
weixin_36145588的博客
10-27 7437
作用 基数树（radix tree）是将long整数与指针键值相关联的机制，它存储有效率，并且可快速查询，用于整数值与指针的映射，对于长整型数据的映射，如何解决Hash冲突和Hash表大小的设计是一个很头疼的问题，利用radix树可以根据一个长整型（比如一个长ID）快速查找到其对应的对象指针。这比用hash映射来的简单，也更节省空间，使用hash映射hash函数难以设计，不恰当的hash函数可能增大
查找——图文翔解RadixTree（基数树）
热门推荐
菜鸟的自留地-mooyang
06-08 3万+
基数树 对于长整型数据的映射，如何解决Hash冲突和Hash表大小的设计是一个很头疼的问题。 radix树就是针对这种稀疏的长整型数据查找，能快速且节省空间地完成映射。借助于Radix树，我们可以实现对于长整型数据类型的路由。利用radix树可以根据一个长整型（比如一个长ID）快速查找到其对应的对象指针。这比用hash映射来的简单，也更节省空间，使用hash映射hash函数难以设计
中南月赛F ZZY and his little friends
weixin_33862188的博客
10-02 156
Problem F: ZZY and his little friends Time Limit: 5 SecMemory Limit: 256 MBSubmit: 137Solved: 70[Submit][Status][Web Board] Description zzy养了一只小怪兽和N只凹凸曼，单挑的话每只凹凸曼都不是小怪兽的对手，所以必须由两只凹凸曼合作来和小...
Linux Radix tree简介
最新发布
小立仔
06-13 1239
Linux Radix tree简介以及对应的API简介
基数树简介
Dablelv 的博客专栏。
03-31 1139
基数树（Radix Trie）也叫基数特里树或压缩前缀树，是一种多叉树，一种更节省空间的 Trie（前缀树）。基数树中作为唯一子结点的每个结点都与其父结点合并，每个内部结点的子结点数最多为基数树的基数 r，r 为正整数且等于2^n(n>=1)。这使得基数树更适用于对于较小的集合（尤其是字符串很长的情况下）和有很长相同前缀的字符串集合。不像一般的 Trie，基数树的边可以是一个或者多个元素。
Radix Tree用法
chi's blog
12-04 835
对于长整型数据的映射，如何解决Hash冲突和Hash表大小的设计是一个很头疼的问题。radix树就是针对这种稀疏的长整型数据查找，能快速且节省空间地完成映射。借助于Radix树，我们可以 实现对于长整型数据类型的路由。利用radix树可以根据一个长整型（比如一个长ID）快速查找到其对应的对象指针。这比用hash映射来的简单，也更节省空间，使用hash映射hash函数难以设计，不恰当的hash函数可能增大冲突，或浪费空间。
nginx源码分析--基数树
qq_62309585的博客
12-02 421
1.pool是内存池指针 preallocate：预分配的基数树节点树 如果传递的值为-1，那么将会根据当前操作系统中一个页面的大小来预分配基数树节点。这个函数是这四个函数中最简单的一个，就是根据key值查询，如果找到返回value值，没有找到返回NGX_RADIX_NO_VALUE。ngx_radix_tree_t基数树要求存储的每个节点都必须以32位整型作为区别任意两个节点的唯一标识。决定节点位置的方法很简单，先。数树是不管树的形态是否平衡的，因因此，它插入节点、删除节点的速度要比红黑树快得多。
路由查找之Radix Tree
weixin_33713707的博客
06-20 1375
什么是Radix Tree   在计算机科学中，基数树，或称Patricia trie/tree，或crit bit tree，压缩前缀树，是一种更节省空间的Trie（前缀树）。对于基数树的每个节点，如果该节点是唯一的子树的话，就和父节点合并。   golang的web框架echo和gin都使用了radix tree作为路由查找的算法，我们以gin的实现来分析一下。   在gin的路由中，每一个...
利用Radix tree基树进行IP地址的匹配
02-12 969
一 基树概念Radix tree（也称为基树trie或紧凑trie）是一种空间优化的trie数据结构，用于存储关联数组，其中键是字符序列（例如，字符串或字节数组）。在基数树中，树中的每个节点表示一个或多个键的公共前缀，节点之间的边缘表示该前缀的扩展。由于它们的前缀共享，基数树可能比常规尝试更节省空间，特别是对于具有许多键共享公共前缀的数据集。注意：有的地方区分了Radix tree和Trie Tr...
radix tree
破木吉他
05-12 2013
  最近看了看代码，研究了一下Linux内核中诸多数据结构中的radix tree。radix tree数据结构在Linux内核中实现的很精致，没怎么看的明白！今天先来简单记录一下这段时间的一些测试和想法。 获取实例代码 https://github.com/JeCortex/jecortech/tree/master/Tree/Radix 主要实现： 1，虚拟块设备，/dev目录下标准块...
radix-tree:Compact Prefix树（基数）的Java实现
05-24
基数树，也称为Compact Prefix树，是一种高效的数据结构，主要用于存储和检索具有共同前缀的键。在Java编程中，实现基数树可以提供快速的查找、插入和删除操作，尤其适用于大规模数据集。这种数据结构在DNS缓存、IP...
radix-tree:用 C 编写的基于指针的基数树
06-17
基数树 此存储库包含纯 C 中基数树的实现 取自设计和启动代码
radixtree基数树
06-12
基数树源码
Linux 内核数据结构：Radix 树
01-09
正如你所知道的， Linux 内核通过许多不同库以及函数提供各种数据结构以及算法。这个部分我们将介绍其中一个数据结构 Radix tree。Linux 内核中有两个文件与 radix tree 的实现和 API 相关： 　　include/linux/radix-tree.h 　　lib/radix-tree.c 　　首先说明一下什么是 radix tree ，Radix tree 是一个 压缩 trie， trie 是一种通过保存关联数组（associative array）来提供 关键字-值（key-value） 存储与查找的数据结构。通常关键字是字符串，不过也可以是其他数据类型。
radix-tree:PHP基数树实现
03-20
在实际项目中，可以使用现有的PHP基数树库，如`pcre-radixtree`或`php-radix-tree`，它们提供了丰富的API和优化功能，可以帮助开发者快速集成和使用基数树。 总之，PHP中的基数树实现是一项高效的技术，它能够有效...
C++ 实现基数树 radix tree内含源码以及说明书可以自己运行复现.zip
05-07
在IT领域，基数树（Radix Tree）是一种高效的数据结构，尤其在处理字符串搜索和存储时展现出优秀的性能。本项目提供了C++实现基数树的源码及说明书，旨在帮助学习者理解和运用这种数据结构。以下是关于基数树及其C++...
Trie Tree和Radix Tree
走在前往架构师的路上
06-13 5595
前言 在实际应用场景中，很多时候我们会用到字典集的查找。通过一个键值key，去拿到它对应的值对象。这种方法确实很高效，很快，但是这里有个问题，当字典集储存的键值很多的情况时，毫无疑问，这里会消耗掉大量的内存空间。这个在我们做基数计数的统计应用时，这个空间会膨胀地特别厉害。本节笔者将要谈论的是对于基数统计来说，使用上更为适用的1种数据结构Trie Tree以及它的衍生优化版Radix Tree。 ...
了解基数树
ych9527的博客
07-10 454
基数树 形态 性质 基数树其实就是多层哈希映射，解决整形与指针之间的映射关系 当某一层的位置有映射时，才选择多扩建一层哈希映射 可以根据需要开辟空间，而不是直接将空间开辟好 优点 提高访问的效率，不需要像哈希表一样进行内存 如果想要产生可以在一定 消耗 比如，有范围 1~200万范围的数据需要进行映射，如果用普通的一维数组进行哈希映射，那么在一开始，就需要开辟巨大的空间，如果采用基数树，则可以先开辟一段小的空间，当发生了冲突的时候，再选择开辟空间，进行二次映射 ...
Redis-基树数源码原理分析
哆啦A梦
01-17 234
 1、Rax是Redis内部比较特殊的一种数据结构，它是有序字典树，按照key进行排序，支持快速定位、插入、删除操作。它与zset排序不同，zset是按照score排序，而Rax是按照key进行排序。   集中数据结构的特点如下图所示                         咱们可以将英语字典开成一棵radix tree，key是每个单词，value是对应的解释；也可以应用到时间...
自适应基数树的存储结构
09-06
自适应基数树（ART）的存储结构采用了不同大小的中间节点和叶子节点。不同节点存储key的数目和索引方式不同。目前主要有存储4个、16个、48个和256个key的节点。这种存储结构的设计旨在提高CPU缓存行命中率，降低内存开销，并且可以利用一些指令优化。通过灵活的节点大小和索引方式的选择，自适应基数树能够在性能（树高）和空间占用（内存开销）之间取得平衡。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Go中实现的自适应基数树-Golang开发](https://download.csdn.net/download/weixin_42116705/19095237)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [数据结构 -- 自适应基数树(ARTree)](https://blog.csdn.net/yi_wen/article/details/119805160)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值