高级数据结构与算法 | 基数树（Radix Tree）

最新推荐文章于 2024-05-06 14:39:05 发布
最新推荐文章于 2024-05-06 14:39:05 发布
阅读量1.2k 收藏 19
点赞数 8
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 radix tree 数据库 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35423154/article/details/130119383
版权

文章目录

RadixTree

基本概念

概念

如果对 Trie 不太了解，可以看看我的往期博客：

https://oreki.blog.csdn.net/article/details/109076473

Radix Tree是一种基于 Trie（字典树）的数据结构，旨在解决字符串搜索和匹配的问题。它最早由 Fredkin 在 1960 年提出，并在之后被广泛应用于各种应用领域。其最大的特点就是在 Trie 的基础上，加入了路径压缩的逻辑，通过合并前缀的方式大大的减少了 Trie 中的节点冗余问题，不仅提高了查询效率，还减少了存储空间的使用。

Radix Tree VS Trie Tree

那么，Radix Tree 是如何做到合并前缀的呢？在 Radix Tree 中每个节点存储的不再是一个字符，而是字符串的前缀，当插入/删除节点时，会通过合并/分裂前缀的方式，来尽可能的压缩树的高度，下面给出几个例子来进行对比。

下面来分别对比一下在 Radix/Trie 中，插入和删除的流程

插入：

初始状态

image-20230402233052316

初始状态

插入 abcd，此时 Radix Tree 会将前缀保存到同一个节点中。而 Trie 一个节点只能保存一个字符。

img

插入 abcd

接着插入 abce，此时 Radix Tree 会获取找到匹配到最大前缀的节点 abcd，保留最大前缀，并将 d 和新插入的 e 存储到子节点中。

image-20230402233226662

插入 abce

接着插入字符串 aecb。此时找到具有最大前缀的节点 abc，将其拆分为前缀 a，后缀 bc，将 bc 作为 a 的子节点，并继承其原有子节点，同时将新插入的字符串 ecb 存储到 a 的子节点中。

image-20230402233330307

插入 aecb

插入 aecd，此时找到最大前缀节点 ecb，保留匹配前缀 ec，将剩余字符 b 和新插入节点 d 作为子节点。

img

插入 aecd

删除：

基于上面的树，接着进行删除，首先删除 abcd。此时由于 d 被删除，整下 bc 和 e 节点为单路径，此时将其合并为 bce。

image-20230402233550741

删除 abcd

删除 abce，同理，此时 a 仅剩下单路径，将其与 ec 合并为 aec。

img

删除 abce

删除 aecb，合并 aec 与剩余路径 d，变为 aecd。

image-20230402233928027

删除 aecb

接着删除 aecd，此时两树为空。

image-20230402233915793

删除 aecd

应用场景

由于 RadixTree 具有高效的字符串匹配能力以及空间效率，其被广泛应用于字符串搜索、匹配的场景，比较常见的几个用法如：

  • 路由表、DNS 等网络设备的查找和匹配。
  • 编译器中预定义符号和关键词查找。
  • Linux 的进程、线程管理，Page Cache 的搜索。
  • 自然语言处理

实现

上面介绍了原理，下面用 C++ 来简单实现一个 Radix Tree 的 demo。

数据结构

首先定义 RadixTreeNode，我们需要用一个 string 来存储字符串前缀，用一个 bool 变量来标识当前路径是否构成一个完整的字符串，再用一个哈希表来存储所有的子节点（这里不用数组的原因是删除一个节点时，需要偏移多个节点，且查找时需要遍历数组）。

class RadixTreeNode {
public:
  explicit RadixTreeNode(const string &word = "", bool is_end = false)
      : word(word), is_end(is_end) {}

  unordered_set<shared_ptr<RadixTreeNode>> children;
  string word;
  bool is_end;
};

接着定义 RadixTree，首先我们需要存储一个 root 节点的指针，由于 C++ 中没有 GC 机制，为了避免内存泄漏，这里统一用智能指针来进行管理。这里实现了基本的插入、删除、查找函数，以及递归调用的辅助函数。

class RadixTree {
public:
  RadixTree() : root(make_shared<RadixTreeNode>()){};

  virtual ~RadixTree() = default;

  RadixTree(const RadixTree &) = delete;
  RadixTree &operator=(const RadixTree &) = delete;

  void insert(const string &str);

  void erase(const string &str);

  bool search(const string &str);

private:
  shared_ptr<RadixTreeNode> root;
  
  void insert_helper(const string &str, shared_ptr<RadixTreeNode> node);
  
  shared_ptr<RadixTreeNode> erase_helper(const string &str,
                                         shared_ptr<RadixTreeNode> node);
                                         
  bool search_helper(const string &str, shared_ptr<RadixTreeNode> node);

插入

  1. 如果插入的是空字符串，则直接将根节点标记为完整字符串，否则继续往下。
  2. 遍历当前节点的子节点，共有以下三种情况：
    • 节点没有子节点：将字符串的内容直接作为新的子节点插入。
    • 子节点中有能够匹配到前缀的节点：
      • 当前节点的内容与字符串完全匹配：将当前前缀标记为完整字符串。
      • 当前节点的内容是字符串的前缀：此时将字符串拆分为公共前缀和剩余字符，用剩余字符与该子节点继续递归进行查找，寻找合适的插入位置，继续回到流程 2。
      • 当前节点的内容和字符串具有公共前缀：此时将当前节点的内容拆分为公共前缀，剩余后缀两部分。当前节点保留前缀内容，将后缀作为子节点插入，此时如果字符串还有剩余字符，则将其也作为子节点一同插入。
    • 子节点中没有与之具有公共前缀的节点：将字符串的内容直接作为新的子节点插入。
void insert(const string &str) {
  if (str.empty()) {
    root->is_end = true;
  } else {
    insert_helper(str, root);
  }
}

void insert_helper(const string &str, shared_ptr<RadixTreeNode> node) {
  // 如果当前没有子节点，则直接作为新的子节点
  if (node->children.empty()) {
    auto new_node = make_shared<RadixTreeNode>(str, true);
    node->children.insert(new_node);
    return;
  }

  bool is_match = false;
  for (auto current : node->children) {
    int i = 0;
    for (; i < str.size() && i < current->word.size(); i++) {
      if (str[i] != current->word[i]) {
        break;
      }
    }
    if (i != 0) {
      is_match = true;
      // 情况一：当前节点的内容与字符串完全匹配，则直接将该前缀标记为完整
      if (i == str.size() && i == current->word.size()) {
        current->is_end = true;
      } else if (i != current->word.size()) {
        // 如果当前节点的内容是字符串的部分前缀，则进行分裂
        auto new_node = make_shared<RadixTreeNode>(current->word.substr(i),
                                                   current->is_end);

        current->word = current->word.substr(0, i);
        current->is_end = (i == str.size()) ? true : false;
        current->children.swap(new_node->children);
        current->children.insert(new_node);

        if (i != str.size()) {
          auto new_node2 = make_shared<RadixTreeNode>(str.substr(i), true);
          current->children.insert(new_node2);
        }
      } else {
        // 如果当前节点已匹配完，则继续往子节点匹配
        insert_helper(str.substr(i), current);
      }
      if (is_match) {
        return;
      }
    }
  }
  // 如果没有找到，则直接插入
  auto new_node = make_shared<RadixTreeNode>(str, true);
  node->children.insert(new_node);
}

删除

  1. 如果删除的是空字符串，则直接将 root 标记为非完整字符串。
  2. 遍历当前节点的子节点：
    • 当前节点的内容与字符串完全匹配：
      • 当前节点有子节点：将当前节点标记为非完整字符串。
      • 当前节点没子节点：直接删除该节点。此时如果在删除了该节点后，当前节点的父节点仅剩下一个子节点，并且父节点中存储一个不完整字符串，此时可以将当前节点和父节点合并，用于压缩路径。
    • 当前节点的内容是字符串的前缀：将字符串拆分为公共前缀和剩余后缀，用后缀继续向下递归查找到合适的位置进行删除。
    • 字符串是当前节点内容的前缀：该字符串一定不在树中，删除结束。
void erase(const string &str) {
  if (str.empty()) {
    root->is_end = false;
  } else {
    erase_helper(str, root);
  }
}

shared_ptr<RadixTreeNode> erase_helper(const string &str,
                                       shared_ptr<RadixTreeNode> node) {
  bool is_match = false;
  for (auto current : node->children) {
    int i = 0;
    for (; i < str.size() && i < current->word.size(); i++) {
      if (str[i] != current->word[i]) {
        break;
      }
    }
    if (i != 0) {
      is_match = true;

      // 情况一：当前节点的内容与字符串完全匹配
      if (i == str.size() && i == current->word.size()) {
        // 如果该节点没有子节点，则将该节点删除。否则将is_end标记为false
        if (current->children.empty()) {
          node->children.erase(current);
        } else {
          current->is_end = false;
        }

        // 如果删除了该节点后，父节点仅剩下一个子节点，且父节点不完整，则将两个节点合并
        if (node->children.size() == 1 && !node->is_end && node != root) {
          auto sub_node = *node->children.begin();
          node->children.erase(sub_node);
          node->is_end = sub_node->is_end;
          node->word.append(sub_node->word);
          node->children = sub_node->children;
          return node;
        }
      }
      // 情况二：当前节点是字符串的前缀
      else if (i == current->word.size()) {
        // 继续向下搜索，如果返回值不为空则说明需要合并节点
        auto sub_node = erase_helper(str.substr(i), current);
        if (sub_node && node->children.size() == 1 && !node->is_end &&
            node != root) {
          auto sub_node = *node->children.begin();
          node->children.erase(sub_node);
          node->is_end = sub_node->is_end;
          node->word.append(sub_node->word);
          node->children = sub_node->children;
        }
      }
      // 情况三：字符串是当前节点的前缀，此时字符串必定不存在，删除结束
      else {
        break;
      }
    }
    if (is_match) {
      return nullptr;
    }
  }
  return nullptr;
}

查找

查找实现的逻辑如下：

  1. 从根节点出发，如果字符串为空，判断空字符有没有存储到根节点，没有往下执行。
  2. 遍历当前节点的所有子节点，查找是否存在公共前缀，此时存在以下四种情况：
    • 当前节点的内容与字符串完全匹配：此时根据当前路径是否为完整单词，判断查找是否成功。
    • 当前节点的内容是字符串的前缀：将字符串拆分为前缀和剩余后缀，将后缀继续递归到该节点的子节点处继续查询，重复流程 2
    • 字符串是当前节点内容的前缀：查找失败，这一部分前缀必定没有插入到树中。
    • 无公共前缀：继续遍历下一个子节点，如果已经遍历完，则认为查找失败，该字符串不存在。
bool search(const string &str) {
  if (str.empty()) {
    return root->is_end;
  }
  return search_helper(str, root);
}

bool search_helper(const string &str, shared_ptr<RadixTreeNode> node) {
  for (auto current : node->children) {
    int i = 0;
    for (; i < str.size() && i < current->word.size(); i++) {
      if (str[i] != current->word[i]) {
        break;
      }
    }
    if (i != 0) {
      // 情况一：当前节点的内容与字符串完全匹配，根据是否为完整单词判断结果
      if (i == str.size() && i == current->word.size()) {
        return current->is_end;
      }
      // 情况二：当前节点的内容是字符串的前缀
      else if (i == current->word.size()) {
        return search_helper(str.substr(i), current);
      }
      // 情况三：字符串的内容是当前节点的前缀，直接返回错误
      else {
        return false;
      }
    }
  }
  // 没有找到
  return false;
}

完整代码

//
// Created by orekilee on 2023/3/31.
//

#ifndef RADIX_RADIXTREE_CPP
#define RADIX_RADIXTREE_CPP

#include <iostream>
#include <memory>
#include <string>
#include <unordered_set>

using namespace std;

class RadixTreeNode {
public:
  explicit RadixTreeNode(const string &word = "", bool is_end = false)
      : word(word), is_end(is_end) {}

  unordered_set<shared_ptr<RadixTreeNode>> children;
  string word;
  bool is_end;
};

class RadixTree {
public:
  RadixTree() : root(make_shared<RadixTreeNode>()){};

  virtual ~RadixTree() = default;

  RadixTree(const RadixTree &) = delete;
  RadixTree &operator=(const RadixTree &) = delete;

  void insert(const string &str) {
    if (str.empty()) {
      root->is_end = true;
    } else {
      insert_helper(str, root);
    }
  }

  void erase(const string &str) {
    if (str.empty()) {
      root->is_end = false;
    } else {
      erase_helper(str, root);
    }
  }

  bool search(const string &str) {
    if (str.empty()) {
      return root->is_end;
    }
    return search_helper(str, root);
  }

private:
  shared_ptr<RadixTreeNode> root;

  void insert_helper(const string &str, shared_ptr<RadixTreeNode> node) {
    // 如果当前没有子节点，则直接作为新的子节点
    if (node->children.empty()) {
      auto new_node = make_shared<RadixTreeNode>(str, true);
      node->children.insert(new_node);
      return;
    }

    bool is_match = false;
    for (auto current : node->children) {
      int i = 0;
      for (; i < str.size() && i < current->word.size(); i++) {
        if (str[i] != current->word[i]) {
          break;
        }
      }
      if (i != 0) {
        is_match = true;
        // 情况一：当前节点的内容与字符串完全匹配，则直接将该前缀标记为完整
        if (i == str.size() && i == current->word.size()) {
          current->is_end = true;
        } else if (i != current->word.size()) {
          // 如果当前节点的内容是字符串的部分前缀，则进行分裂
          auto new_node = make_shared<RadixTreeNode>(current->word.substr(i),
                                                     current->is_end);

          current->word = current->word.substr(0, i);
          current->is_end = (i == str.size()) ? true : false;
          current->children.swap(new_node->children);
          current->children.insert(new_node);

          if (i != str.size()) {
            auto new_node2 = make_shared<RadixTreeNode>(str.substr(i), true);
            current->children.insert(new_node2);
          }
        } else {
          // 如果当前节点已匹配完，则继续往子节点匹配
          insert_helper(str.substr(i), current);
        }
        if (is_match) {
          return;
        }
      }
    }
    // 如果没有找到，则直接插入
    auto new_node = make_shared<RadixTreeNode>(str, true);
    node->children.insert(new_node);
  }

  shared_ptr<RadixTreeNode> erase_helper(const string &str,
                                         shared_ptr<RadixTreeNode> node) {
    bool is_match = false;
    for (auto current : node->children) {
      int i = 0;
      for (; i < str.size() && i < current->word.size(); i++) {
        if (str[i] != current->word[i]) {
          break;
        }
      }
      if (i != 0) {
        is_match = true;

        // 情况一：当前节点的内容与字符串完全匹配
        if (i == str.size() && i == current->word.size()) {
          // 如果该节点没有子节点，则将该节点删除。否则将is_end标记为false
          if (current->children.empty()) {
            node->children.erase(current);
          } else {
            current->is_end = false;
          }

          // 如果删除了该节点后，父节点仅剩下一个子节点，且父节点不完整，则将两个节点合并
          if (node->children.size() == 1 && !node->is_end && node != root) {
            auto sub_node = *node->children.begin();
            node->children.erase(sub_node);
            node->is_end = sub_node->is_end;
            node->word.append(sub_node->word);
            node->children = sub_node->children;
            return node;
          }
        }
        // 情况二：当前节点是字符串的前缀
        else if (i == current->word.size()) {
          // 继续向下搜索，如果返回值不为空则说明需要合并节点
          auto sub_node = erase_helper(str.substr(i), current);
          if (sub_node && node->children.size() == 1 && !node->is_end &&
              node != root) {
            auto sub_node = *node->children.begin();
            node->children.erase(sub_node);
            node->is_end = sub_node->is_end;
            node->word.append(sub_node->word);
            node->children = sub_node->children;
          }
        }
        // 情况三：字符串是当前节点的前缀，此时必定查询失败
        else {
          break;
        }
      }
      if (is_match) {
        return nullptr;
      }
    }
    return nullptr;
  }

  bool search_helper(const string &str, shared_ptr<RadixTreeNode> node) {
    for (auto current : node->children) {
      int i = 0;
      for (; i < str.size() && i < current->word.size(); i++) {
        if (str[i] != current->word[i]) {
          break;
        }
      }
      if (i != 0) {
        // 情况一：当前节点的内容与字符串完全匹配，根据是否为完整单词判断结果
        if (i == str.size() && i == current->word.size()) {
          return current->is_end;
        }
        // 情况二：当前节点的内容是字符串的前缀
        else if (i == current->word.size()) {
          return search_helper(str.substr(i), current);
        }
        // 情况三：字符串的内容是当前节点的前缀，直接返回错误
        else {
          return false;
        }
      }
    }
    // 没有找到
    return false;
  }
};


#endif // RADIX_RADIXTREE_CPP
凌桓丶
关注
  • 8
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基数树(radix tree)
weixin_36145588的博客
10-27 7408
作用 基数树（radix tree）是将long整数与指针键值相关联的机制，它存储有效率，并且可快速查询，用于整数值与指针的映射，对于长整型数据的映射，如何解决Hash冲突和Hash表大小的设计是一个很头疼的问题，利用radix树可以根据一个长整型（比如一个长ID）快速查找到其对应的对象指针。这比用hash映射来的简单，也更节省空间，使用hash映射hash函数难以设计，不恰当的hash函数可能增大
自适应基数树：Java中快速且节省空间的基数树
02-05
实施为Java NavigableMap的自适应基数树 该库基于ICDE 2013“自适应基数树：主存数据库的ARTful索引”，以的形式提供了自适应基数树（ART）的实现。 在有序数据结构的空间中，特别有趣，因为它们的高度和时间复杂度取决于密钥长度（k）而不是树中已经存在的密钥数（n）。 在数据集非常庞大的时代，当n的增长速度快于k时，具有与n无关的时间复杂度非常有吸引力。 但是，由于每个内部节点都有固定数量的子代，它们一直困扰着过多的空间消耗问题。 ART通过根据其实际拥有的子代数自适应地更改内部节点的大小来解决此问题。 随着内部节点的子代数增加/减少，ART将内部节点增加/缩小为
C++ 实现基数树 radix tree内含源码以及说明书可以自己运行复现.zip
最新发布
05-07
C++ 实现基数树 radix tree内含源码以及说明书可以自己运行复现.zip
radixtree基数树
06-12
基数树源码
radix-tree:Compact Prefix树（基数）的Java实现
05-24
基数树 Compact Prefix树（基数）的Java实现。
基数（radix）树 - 嵌入式系统书撰写 （转载）
fivedoumi的专栏
12-19 1112
基数（radix）树 Linux基数树（radix tree）是将指针与long整数键值相关联的机制，它存储有效率，并且可快速查询，用于指针与整数值的映射（如：IDR机制）、内存管理等。 IDR（IDRadix）机制是将对象的身份鉴别号整数值ID与对象指针建立关联表，完成从ID与指针之间的相互转换。IDR机制使用radix树状结构作为由id进行索引获取指针的稀疏数组，通过使用位图可以快速
radix-tree算法浅析--从不懂到装懂
C_JLMPC2009的博客
01-11 3771
前言 本文为原创，可能会存在一些知识点或理解上的问题，欢迎切磋和交流 ^_^ 1. 为什么要研究radix-tree算法？(脑残吗) 存储的核心就是I/O流，不懂I/O流就不要说自己会存储；而最近一直研究和分析文件系统I/O流，说到I/O瓶颈和提升性能，缓存读写显然是重中之重。在分析ceph文件系统写I/O流程中，比如调用ceph_write_iter接口，如果过缓存，必调用generi...
RadixTree（基数树）
白杨的专栏
11-06 4444
1. 基数树概述 对于长整型数据的映射，如何解决Hash冲突和Hash表大小的设计是一个很头疼的问题。 radix树就是针对这种稀疏的长整型数据查找，能快速且节省空间地完成映射。借助于Radix树，我们可以实现对于长整型数据类型的路由。 利用radix树可以根据一个长整型（比如一个长ID）快速查找到其对应的对象指针。这比用hash映射来的简单，也更节省空间，使用hash映射hash函数难以设计，不恰
radix tree
dodobear的小窝窝
03-03 5044
这个tree是一种很有趣的tree，我以前都没见过这种树。在linux中，它的非叶节点是一种radix_tree_node结构，叶节点是一个page结构。radix_tree_node包含一个64长度的数组，用来存放叶节点或者非叶节点。每个被插入的page，都有一个index，用来标识这个page应该被插入的位置。比如当这棵树只有一层的时候，根据index的值，将page插入64数组的inde
中南月赛F ZZY and his little friends
weixin_33862188的博客
10-02 150
Problem F: ZZY and his little friends Time Limit: 5 SecMemory Limit: 256 MBSubmit: 137Solved: 70[Submit][Status][Web Board] Description zzy养了一只小怪兽和N只凹凸曼，单挑的话每只凹凸曼都不是小怪兽的对手，所以必须由两只凹凸曼合作来和小...
Radix TRee
hggjgff的博客
11-12 307
Radix TRee
Linux 内核数据结构：Radix 树
01-09
　首先说明一下什么是 radix tree ，Radix tree 是一个 压缩 trie， trie 是一种通过保存关联数组（associative array）来提供 关键字-值（key-value） 存储与查找的数据结构。通常关键字是字符串，不过也可以是...
PHP排序算法之基数排序(Radix Sort)实例详解
10-18
主要介绍了PHP排序算法之基数排序(Radix Sort),结合实例形式详细分析了php基数排序算法的原理、实现方法与相关使用技巧,需要的朋友可以参考下
网络入侵检测系统之Suricata(十五)--IPOnly/Radix Tree详解
诗酒趁年华
03-08 977
IpOnly规则比较特殊，一般认为命中源和目的ip地址，再校验以下其他头部信息，就可以认为该报文 可以命中这条规则。Radix Tree本质是一个二叉树，由内部节点和外部节点，内部节点用于指示需要进行bit test的位置，并根据测试结果决定查找方向，外部节点则用于存储键值。Suricata具体实现在IPOnlyPrepare中，它分别建立了4个Radix Tree，代表源ipv4/6，目的ipv4/6。，路由表查找本质就是对目的ip进行 最长掩码匹配，而索引到路由表中的下一跳。
Redis 源码解析 - Redis Radix tree 源码解析
qq_33240556的博客
05-06 380
Redis中的Radix Tree（也称为PATRICIA Trie或Compact Prefix Tree）是一种高效的数据结构，用于存储键值对，尤其是在实现Slot映射、ACL管理和Stream数据类型等方面。
图解基数树(RadixTree)
qq_41583040的博客
04-27 1465
基数树（RadixTree），是一种比较有趣的数据结构，最近需要一种比较高效的查找，两度遇到了基数树，便整理下来给有相关需求的伙伴提供一种思路。
利用Radix tree基树进行IP地址的匹配
02-12 886
一 基树概念Radix tree（也称为基树trie或紧凑trie）是一种空间优化的trie数据结构，用于存储关联数组，其中键是字符序列（例如，字符串或字节数组）。在基数树中，树中的每个节点表示一个或多个键的公共前缀，节点之间的边缘表示该前缀的扩展。由于它们的前缀共享，基数树可能比常规尝试更节省空间，特别是对于具有许多键共享公共前缀的数据集。注意：有的地方区分了Radix tree和Trie Tr...
Linux内核Radix Tree（一）
weixin_30872499的博客
09-12 263
一、概述 Linux radix树最广泛的用途是用于内存管理，结构address_space通过radix树跟踪绑定到地址映射上的核心页，该radix树允许内存管理代码快速查找标识为dirty或writeback的页。Linux radix树的API函数在lib/radix-tree.c中实现。 Linux基数树（radix tree）是将指针与long整数键值相关联的机制，它存储有效率，并且...
什么是基数排序？
热门推荐
凌桓丶的博客
10-17 1万+
文章目录什么是基数排序稳定的计数排序基数排序的实现 什么是基数排序 稳定的计数排序 数据结构与算法 | 计数排序 计数排序的基本思路在这里就不多进行介绍了，如果不了解的可以看看我以前写的博客。 void countSort(vector<int>& arr) { int max = arr[0], min = arr[0]; //找出最大值和最小值，缩减范围 for(int i = 1; i < arr.size(); i++) {
Linux 内核数据结构：内核数据结构：Radix 树树
01-20
Radix树是Linux内核中的一种数据结构，用于将值映射为整型关键字。它在内核中被广泛使用，用于高效地存储和检索大量的键值对。Radix树的定义和实现可以在Linux内核的include/linux/radix-tree.h文件中找到。 Radix树的实现和API相关的文件有两个，它们分别是： 1. radix-tree.h：定义了Radix树的数据结构和相关函数。 2. radix-tree.c：实现了Radix树的操作和算法。 Radix树的特点是它可以高效地支持范围查询和前缀查询。它通过将关键字按位划分为多个层级，每个层级都有一个节点来存储对应的键值对。这种分层的结构使得Radix树在存储和检索大量数据时具有较高的效率。 Radix树在Linux内核中被广泛应用于各种场景，例如文件系统、网络协议栈和虚拟内存管理等。它的高效性和灵活性使得它成为了Linux内核中重要的数据结构之一。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌桓丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值