键树算法的实现

最新推荐文章于 2020-12-04 16:43:08 发布
最新推荐文章于 2020-12-04 16:43:08 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： 电信计费技术 文章标签： 算法 null list struct parameters c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuzj/article/details/1378450
版权

键树算法在计费系统中非常普遍，用来在共享内存中查找用户资料的时候，非常快，查找代价始终是常数级别。

下面是源码广泛应用在国内的计费系统之中，其中alloctor，dealloctor函数是用来在共享内存中分配和释放内存的，可以参考我的另一篇文章

为C++标准库容器写自己的内存分配程序

另外重复键值的算法采用的是线性链表的算法，比较简单，所以就没有列出源码。

h_trie.h

#ifndef H_TRIE_H_
#define H_TRIE_H_

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

#include "error.h"
#include "list.h"

#define TRIE_FANOUT 10

/* - - - 键树节点结构 - - - */
typedef struct trie_s
{   
 int  subchanged[TRIE_FANOUT]; /* 记录子节点发生变化的情况 */
 int  listchanged; /* 记录所属链表的变化情况 */
 list_t  *list;
 struct trie_s *subtrie[TRIE_FANOUT];
}trie_t;

void InitHTrie (trie_t **trie);

int InsertHTrie (trie_t **trie, const char str[], const int level,
  void *data, size_t n, int changed);

void * SearchHTrie (trie_t *trie, const char str[], const int level, void *data,
 int (*cmp) (const void *data1, const void *data2));

int TouchHTrie (trie_t **trie, const char str[], const int level, list_t ***list);

list_t *GetListofHTrie (trie_t *trie, const char str[], const int level);

void PrintHTrie (trie_t *trie, const int level, const int key,
 void (*print) (const void *data));
/*
void OperateTrie (trie_t *trie, void (* op_list) (void *data));
*/
void RefreshHTrie (trie_t *trie, void (* op_data) (void *data));

void FreeHTrie (trie_t *trie);

int NeedRefresh (trie_t *trie);

/*
 * 最大可能匹配树查找
 */
list_t *MatchHTrie (trie_t *trie, const char str[], const int level);

/*
 * 功能： TRIE树遍历操作函数
 *
 * 注意 节点操作可中断
 *
 * 返回 0 未执行完毕 1 执行完毕
 */ 
int DealHTrie (trie_t *trie, int (* op_data) (void *data));

#endif

h_trie.c

#include "stdafx.h"
#include <stdio.h>
#include <ctype.h>

#include "h_trie.h"
#include "alloc.h"
static char keyarray[256];

/*-------------------------------
 * usage: 初始化键值数组
 * comment:将char映射成0-9的数值
 *-------------------------------*/
void InitHTrie (trie_t **trie)
{
 int c;

 for (c = 0; c < 256; c++)
 {
  if (isdigit (c))
   keyarray[c] = c - '0';
  else
   keyarray[c] = c%10;
 }
 
 *trie = NULL;
}

static trie_t * NewNode ()
{
 int i;
 trie_t *node = (trie_t *)allocate (sizeof (trie_t));

 if (node)
 {
  node->list = NULL;
  for (i = 0; i < TRIE_FANOUT; i++)
  {
   node->subchanged[i] = 0;
   node->listchanged = 0;
   node->subtrie[i] = NULL;
  }
 }

        if (node == NULL)
  pr_error("errorcode:%d,msg:NewNode: allocate() return NULL/n");       
              
 return node;
}

/*--------------------------------
 * usage: 向键树中插入一个新的数据
 * arguments: *trie -- 键树头指针
 *   str   -- 键值字符串
 *   level -- 键值长度
 *   data  -- 要插入的数据
 *   n     -- 要插入的数据的大小
 *   changed - 记录当前节点的子节点的内容是否发生了变化
 *     1 -- 有变化 0 -- 无变化
 * return: -1 -- 出错 0 -- 正常
 * comment：键树的叶节点是链表，出入数据时，先根据键值找到叶节点，再向
 *   叶节点所指的链表中插入数据。
 *---------------------------------*/
int InsertHTrie (trie_t **trie, const char str[], const int level,
  void *data, size_t n, int changed)
{
 int i;
 int key;
 trie_t *curnode;

 if (*trie == NULL)
 {
  *trie = NewNode ();
  if (*trie == NULL) {
   return -1;
  }
 }

 curnode = *trie;
 for (i = 0; i < level ; i++)
 {
  key = (int) keyarray[(int)str[i]];
  if (curnode->subtrie[key] == NULL)
  {
   if ((curnode->subtrie[key] = NewNode ()) == NULL)
    return -1;
  }
  curnode->subchanged[key] = changed;
  
  curnode = curnode->subtrie[key];
 }
 
 curnode->listchanged = changed;
 
 return (InsertList (&(curnode->list), data, n));
}

/*--------------------------------
 * usage: 在键树中查找数据
 * arguments: trie  -- 键树头指针
 *   str   -- 键值字符串
 *   level -- 键值长度
 *   data  -- 要查找的数据
 *   cmp   -- 比较函数指针
 * return: 找到 -- 返回指向该数据的指针 没找到 -- NULL
 * comment:查找规则由cmp函数指定
 *---------------------------------*/
void * SearchHTrie (trie_t *trie, const char str[], const int level, void *data,
  int (*cmp) (const void *data1, const void *data2))
{
 int i;
 int key;
 trie_t *curnode;

 if (trie == NULL)
  return NULL;

 curnode = trie;
 for (i = 0; i < level ; i++)
 {
  key = (int) keyarray[ (int)str[i] ];
  if (curnode->subtrie[key] == NULL)
   return NULL;
  
  curnode = curnode->subtrie[key];
 }

 return (SearchList (curnode->list, data, cmp));
}

/*--------------------------------
 * usage: 在键树中查找键值指向的链头。并将经过的节点的changed字段置1
 *  表示该节点的子节点要发生变化。如节点不存在，则生成该节点
 * arguments: trie  -- 键树头指针
 *   str   -- 键值字符串
 *   level -- 键值长度
 *   list  -- 保存指向链头list指针的指针，由于要保存指针的指针，
 *     使用3层指针
 * return: 找到 -- 返回指向该链表头的指针 没找到 -- NULL
 * comment:
 *---------------------------------*/
int TouchHTrie (trie_t **trie, const char str[], const int level, list_t ***list)
{
 int i;
 int key;
 trie_t *curnode;

 if (*trie == NULL)
 {
  *trie = NewNode ();
  if (*trie == NULL) {
   pr_error("errorcode:%d,msg:TouchHTrie:NewNode () return NULL/n");
                 
   return -1;
  }
 }

 curnode = *trie;
 for (i = 0; i < level ; i++)
 {
  key = (int) keyarray[ (int)str[i]];
  if (curnode->subtrie[key] == NULL)
  {
   if ((curnode->subtrie[key] = NewNode ()) == NULL) {
    pr_error("errorcode:%d,msg:NewNode () error/n");
    return -1;
   }
  }
  curnode->subchanged[key] = 1;
  
  curnode = curnode->subtrie[key];
 }
 
 curnode->listchanged = 1;
 
 *list = &(curnode->list);
 
 return 0;
}

/*-------------------------------------------
 *
 *-------------------------------------------*/
list_t *GetListofHTrie (trie_t *trie, const char str[], const int level)
{
 int i;
 int key;
 trie_t *curnode;
 
 if (trie == NULL)
  return NULL;
 
 curnode = trie;
 for (i = 0; i < level ; i++)
 {
  key = (int) keyarray[(int)str[i]];
  if (curnode->subtrie[key] == NULL)
   return NULL;
   
  curnode = curnode->subtrie[key];
 }
 
 return curnode->list;
}


list_t *MatchHTrie (trie_t *trie, const char str[], const int level)
{
 int i;
 int key;
 trie_t *curnode;
 
 if (trie == NULL)
  return NULL;
 
 curnode = trie;
 
 for (i = 0; i < level ; i++)
 {
  key = (int) keyarray[(int)str[i]];
  if (curnode->subtrie[key] == NULL)
   return curnode->list;
   
  curnode = curnode->subtrie[key];
 }
 
 return curnode->list;
}

/*-------------------------------
 * usage: 释放键树
 * arguments: trie -- the head of trie
 *-------------------------------*/
void FreeHTrie (trie_t *trie)
{
 int i;

 if (trie)
 {
  for (i = 0; i < TRIE_FANOUT; i++)
   FreeHTrie (trie->subtrie[i]);
  FreeList (trie->list);
  free (trie);
 }
}

/*----------------------------------
 * usage: print the data of the trie
 *----------------------------------*/
void PrintHTrie (trie_t *trie, const int level, const int key, void (*print) (const void *data))
{
 int i;
 
 if (trie)
 {
  fprintf (stderr, "enter subtrie -- level:%d,key:%d/n", level, key);
  for (i = 0; i < TRIE_FANOUT; i++)
  {
   PrintHTrie (trie->subtrie[i], level + 1, i, print);
  }
  PrintList (trie->list, print);
 }
}
/*
void OperateHTrie (trie_t *trie, void (* op_list) (void *data))
{
  
}
*/

/*------------------------------------------
 * usage: 刷新TRIE，对changed为1的节点的子节点的链表做op_list指定的操作
 * parameters: trie   -- trie head pointer
 *   op_list-- 对list的操作
 *------------------------------------------*/
void RefreshHTrie (trie_t *trie, void (* op_data) (void *data))
{
 int i;
 
 if (trie)
 {
  for (i = 0; i < TRIE_FANOUT; i++)
  {
   if (trie->subchanged[i]) /* 子节点发生过变化 */
   {
    RefreshHTrie (trie->subtrie[i], op_data);
    trie->subchanged[i] = 0;
   }
  }
  if (trie->listchanged) 
  {
   OperateList (trie->list, op_data);
   trie->listchanged = 0;
  }
 }
}

int NeedRefresh (trie_t *trie)
{
 int i;
 
 if (trie)
 {
  for (i = 0; i < TRIE_FANOUT; i++)
  {
   if (trie->subchanged[i]) /* 子节点发生过变化 */
   {
    return 1;
   }
  }
  if (trie->listchanged)
  {
   return 1;
  }
 }
 
 return 0;
}

/*
 * 功能： TRIE树遍历操作函数
 *
 * 注意 节点操作可中断
 *
 * 返回 0 未执行完毕 1 执行完毕
 */ 
int DealHTrie (trie_t *trie, int (* op_data) (void *data))
{
 int i;
 
 if (trie)
 {
  for (i = 0; i < TRIE_FANOUT; i++)
  {
   if (trie->subchanged[i]) /* 子节点发生过变化 */
   {
    /* 字节点操作中断， 返回 0 */
    if (DealHTrie (trie->subtrie[i], op_data) == 0)
     return 0;
     
    trie->subchanged[i] = 0;
   }
  }
  if (trie->listchanged) 
  {
   if (DealList (trie->list, op_data) == 0)
    return 0;
   trie->listchanged = 0;
  }
 }
 
 return 1;
}

 测试主程序在vs2005中编译通过

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

#include "alloc.h"
#include "list.h"
#include "h_trie.h"

static trie_t *pTrie;
struct testdata
{
 int key;
 char data[20];
};


int _tmain(int argc, _TCHAR* argv[])
{
 struct testdata *pData;
    int i;
    char key[10];

 InitShm(sizeof(trie_t)*100+sizeof(list_t)*20);

 PrintFreelistAndCookie();

 InitHTrie(&pTrie);

 for(i = 0 ;i<10; i++)
 {
  printf("main:i=%d/n",i);
  pData = (struct testdata*)malloc(sizeof(struct testdata));
  if (pData == NULL)
  {
   pr_error("allocate fail/n");
  }

  pData->key = i;
  sprintf(pData->data ,"%d", i*9999);
        sprintf(key, "%d", pData->key);

  if ( - 1 == InsertHTrie(&pTrie, key, sizeof(int), pData,
   sizeof(struct testdata), 0) )
  {
   pr_error("errorcode:%d,msg:insert tree error/n");
  }

  PrintFreelistAndCookie();
 }


 free(getShm());
 return 0;
};

 

编程浪子2018
关注
专栏目录
数据结构---键树（C语言）
06-04
数据结构 C语言 键树 如果一个关键字可以表示成字符的序号，即字符串，那么可以用键树（keyword tree），又称数字搜索树（digital search tree）或字符树，来表示这样的字符串的集合。
完整B树算法Java实现代码
09-01
在Java中实现B树时，通常会创建一个包含节点、键和指针的类结构。例如，`BTree`类会有一个内部类`Node`来表示B树的节点，它包含子节点数量m以及一个`Entry`数组来存储键和指针。`Entry`类进一步分为内部节点和外部...
键树的c++代码实现
xdxiaofeng的专栏
11-07 1116
建树时使用的是Ukkonens算法.因为看的都是英文资料，所以很吃力。加上这个算法很复杂，偶看了好几天。主要是在后缀链上老是出问题。对于后缀链，我觉得有几点比较重要，可以帮助你理解建树的过程。总结如下：(1)suffix link只能在内部节点之间出现.也就说只能从内部节点指向内部节点.所以如果节点是叶子的话，就不用考虑了。(2)一个新的内部节点总是由规则2产生的。规则2要拆分节点。(3)一个
键树
brizer的博客
05-27 4015
键树又称为数字查找树，它是一颗度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字为数值，则结点中只包含一个数位；若关键字为单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。         我们来举一个例子吧，下面有一个集合： {CAI,CAO,LI,LAN,CHA,CHANG,WEN,CHAO,YUN,YANG,
键树（双链树）C语言实现
KK的博客
12-04 947
键树 键树又称数字查找树。它是一棵度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字是数值，则结点中只包含一个数位；若关键字是单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。 举例 假设有如下16个关键字的集合{CAI,CAO,LI,LAN,CHA,CHANG,WEN,CHAO,YUN,YANG,LONG,WANG,ZHAO,LIU,WU,CHEN} 首先按照其首字符不同将它们分成5个子集： {CAI,CAO,CHA,C
B树算法与实现(C语言描述).doc
05-05
B树算法与实现（C语言描述） B树是一种自平衡的搜索树，广泛应用于数据库的索引中。它的优点是能够保持较高的搜索效率，即使在大量数据的情况下。B树的实现通常使用C语言，以下是B树算法的详细描述： B树的定义 B...
Caley树算法实现
10-29
案例30－Caley树算法提供的源码应该包含了完整的实现，包括DAG的读取、Caley树的构建、图形化展示以及用户交互功能。学习这个案例，不仅可以深入理解Caley树算法，还能提升在MFC环境下的编程技巧，这对于理解和开发...
键树来实现前缀匹配算法
01-08
总结来说，这个项目展示了如何使用键树数据结构和C/C++编程来实现前缀匹配算法，它涉及到文件读取、数据结构设计（键树和队列）、以及算法实现（如插入和查找）。通过这个项目，开发者可以深入理解数据结构和算法在...
B树算法的C++实现
10-24
在给定的压缩包中，"B树"可能是实现B树算法的源代码文件，包含了上述功能的C++实现。通过阅读和学习这个源代码，你可以深入了解B树的内部工作机制，掌握如何在实际项目中应用B树算法。这将对理解和优化大数据存储、...
C++键树编程
04-20
用c++编写的键树程序，绝对原创
键树的应用
look01的专栏
11-06 1152
在开发windows域同步工具遇到了很棘手的问题,LDAP协议返回的值是这样的,举例: vall="小明a",OU="一班",OU="一年级"          val2="小明b",OU="一班",OU="二年级"我们假设同一个班级或年级下不可能出现重名的情况,windows域也确实是这样,那么假设我们只知道小明b是一班的同学,那么如何知道他是一年级还是二年级的同学呢?如何建立这样的
查找算法（V）键树——双链树和Trie树
weixin_34185320的博客
11-15 257
键树 键树的基本概念 　　键树又称数字查找树（Digital Search Tree）。 　　它是一棵度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。 　　例如，若关键字是数值，则结点中只包含一个数位；若关键字是单词，则结点中只包含一个字母字符。 　　这种树会给某种类型关键字的表的查找带来方便。 　　如下图所示为一棵键树：   　　从根到...
查找算法 | 键树详细分析
挖坑埋你
10-31 1359
键树，又称数字查找树(Digital Search Trees)，是一棵度&amp;amp;gt;=2的树，它的某个节点不是包含一个或多个关键字，而是只包含组成关键字的一部分（字符或数字）。 如果关键字本身是字符串，则键树中的一个结点只包含有一个字符；如果关键字本身是数字，则键树中的一个结点只包含一个数位。每个关键字都是从键树的根结点到叶子结点中经过的所有结点中存储的组合。 根结点不代表任何字符，根以下第一层...
【数据结构】算法9.16 键树-Trie树-查找
Zelda 的博客
10-10 464
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<ctype.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define MAXKEYLEN 16 typedef int Status; typed
【数据结构】算法9.15 键树-双链树-查找
Zelda 的博客
10-10 659
#include<stdio.h> #include<string.h> #include<stdlib.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2typedef int Status; typedef int ElemType;#def
数据结构——键树之Tire树
minyuanxiani的专栏
09-03 744
#include "stdio.h" #include "stdlib.h" #include "string.h" #include "ctype.h" #define OK 1 #define ERROR 0 typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等 typedef int Boolean; // Boolean
2-3查找树算法实现与测试
- 在这个文件中，很可能是实现了上述提到的折半查找算法、二叉排序树的插入、查找、删除操作以及2-3查找树的相应功能，并配合测试代码以验证功能的正确性。 - 程序员在编写该程序时可能采用了面向对象的方式，定义了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值