TrieTree（字典树,前缀树） 的实现 (增删改查)

最新推荐文章于 2024-04-17 16:21:59 发布
最新推荐文章于 2024-04-17 16:21:59 发布
阅读量4.9k 收藏 2
点赞数 1
分类专栏： vc++ Linux 数据结构及算法 文章标签： vs2012 trie tree 字典树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zison_sun/article/details/52298773
版权 
以下 代码 vs2012 下多线程 海量数据  测试过 无内存泄漏



// TrieTreeTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "trie.h"
#include <windows.h> 
#include <ctime>  
#include "vld.h"

#include "ieee_addr.h"


#define MULTY_THREADS 1


int g_keep_run = 1;
TrieRoot root = {0};


char * create_a_ieee()
{
#if 1
	char * text = NULL;

	text = (char *)malloc (17);

	for(int i = 0; i < 16;i++)
	{
		int index = rand() % 16;
		_snprintf(text + i,1,"%x",index);
	}
	text[16] = 0;
	if(strlen(text)!= 16)
	{
		printf("fuck error\n");
	}
	return text;
#else
	int index = rand() %  (sizeof(text) / sizeof(char *));
	return text[index];
#endif
	
}

char * create_a_string(char * ieee)
{
	char * text;

	text = (char *)malloc(21);

	strcpy(text,ieee);
	text[16] = 0;
	return text;
}


void printf_handler(void * data)
{
	printf("%s\n",data);
}

void free_handler(void * data)
{
	free(data);
}

DWORD WINAPI add(LPVOID pM)  
{
	char * ieee;
	char * str;
	
	while(g_keep_run)
	{
		int time_s = rand() % 2;
		
		ieee = create_a_ieee();
		str = create_a_string(ieee);

		if(TRIE_SUCCESS == trie_insert(&root,ieee,str))
		{
		  //printf("add [%s]\n",key[index]);
		}
		else
		{
			free(str);
		}
		free(ieee);
		Sleep(time_s);
	}

    return 0;  
}

DWORD WINAPI upd(LPVOID pM)  
{
	char * ieee;
	char * str;
	char * old_str;
	while(g_keep_run)
	{

		int time_s = rand() % 2;
		ieee = create_a_ieee();
		str = create_a_string(ieee);

		if(TRIE_SUCCESS == trie_update(&root,ieee,str,(void **)&old_str))
		{
			free(old_str);
		}
		else
		{
			free(str);
		}
		free(ieee);
		Sleep(time_s);
	}

    return 0;  
}

DWORD WINAPI sch(LPVOID pM)  
{  
	char * ieee;

	while(g_keep_run)
	{
		int time_s = rand() % 100;
		ieee = create_a_ieee();

		char * data = NULL;
		trie_search(&root,ieee,(void **)&data);
		free(ieee);
		Sleep(time_s);
	}

    return 0;  
}

DWORD WINAPI del(LPVOID pM)  
{  
	char * ieee;
    char * data_pointer;

	while(g_keep_run)
	{
		int time_s = rand() % 100;
		ieee = create_a_ieee();

		if(TRIE_SUCCESS == trie_delete(&root,ieee,(void **)&data_pointer))
		{
			free(data_pointer);
		}
		//else
			//printf("del [%s] failed\n",key[index]);
		free(ieee);
		Sleep(time_s);
	}

    return 0;  
}

DWORD WINAPI fore(LPVOID pM)  
{  
	while(g_keep_run)
	{
		srand( (unsigned)time(NULL ) );//srand()函数产生一个以当前时间开始的随机种子.应该放在for等循环语句前面 不然要很长时间等待  
		int index = rand() % 8;

		trie_foreach(&root,printf_handler);
		Sleep(index);
	}

    return 0;  
}

int _tmain(int argc, _TCHAR* argv[])
{
	int cha;
	int count = 20;
	void * data_pointer;
	srand( (unsigned)time(NULL ) );

	
	trie_init(&root);

#if 1
	HANDLE add_handle = CreateThread(NULL, 0, add, NULL, 0, NULL);  
	HANDLE sch_handle = CreateThread(NULL, 0, sch, NULL, 0, NULL);  
	HANDLE upd_handle = CreateThread(NULL, 0, upd, NULL, 0, NULL);  
	HANDLE del_handle = CreateThread(NULL, 0, del, NULL, 0, NULL);  
//	HANDLE	for_handle = CreateThread(NULL, 0, fore, NULL, 0, NULL); 
	
	cha = getchar();
	g_keep_run = 0;
	
	WaitForSingleObject(add_handle, INFINITE);  
	WaitForSingleObject(sch_handle, INFINITE);  
	WaitForSingleObject(upd_handle, INFINITE);  
	WaitForSingleObject(del_handle, INFINITE);  
//	WaitForSingleObject(for_handle, INFINITE);  

	CloseHandle(add_handle);
	CloseHandle(sch_handle);
	CloseHandle(upd_handle);
	CloseHandle(del_handle);
//	CloseHandle(for_handle);


//	for(int i =0;i<key_size;i++)
//			trie_delete(&root,key[i],(void **)&data_pointer);
	
	trie_foreach(&root,free_handler);

	trie_destroy(&root);
	 
//	getchar();
#else
	char * str1 = (char *) malloc(21);
	char * str2 = (char *) malloc(21);

	char * strout;

	sprintf(str1,"fuckyou");
	sprintf(str2,"fuckme");


	trie_insert(&root,"123456789",str1);
	trie_insert(&root,"123123123",str1);
	trie_insert(&root,"123123123",str1);
	trie_insert(&root,"123123123",str1);
	trie_insert(&root,"123123123",str1);

	trie_search(&root,"123456789",(void **)&strout);


	//trie_update(&root,"123456789",(void *)str2,(void **)&strout);
	//free(strout);

	if(TRIE_SUCCESS == trie_delete(&root,"123123123",(void **)&strout))
	{
		//free(strout);
	}
	if(TRIE_SUCCESS == trie_delete(&root,"123123123",(void **)&strout))
	{
		//free(strout);
	}

	free(str1);
	free(str2);

	trie_destroy(&root);
#endif
	return 0;
}





<pre class="cpp" name="code">// *****************************************************************************
// * trie.h
// *
// * an implementation of a trie tree
// *
// * author: zison sun
// *
// * date: 2016-8-16
// *****************************************************************************

#ifndef	_MACRO_trie_DATA_STRUCTURE_HEADER_
#define	_MACRO_trie_DATA_STRUCTURE_HEADER_

#define WINDOWS 1

#if WINDOWS
#include <windows.h>
#else
#include <pthread.h>
#endif

#define TRIE_SON_NUM	16		//(0-F)

enum trieStatus
{
	TRIE_ERROR	=	0,
	TRIE_SUCCESS = 	1,
};

typedef struct tagTrie
{
	int		href; //引用计数
	void * 	data_pointer; //数据指针
	void *  addr_in_parent; //自身在父节点中的地址
	struct tagTrie * branch[TRIE_SON_NUM];
} Trie, * PTrie;

typedef struct tagTrieRoot
{
#if WINDOWS
	HANDLE hMutex;
#else
	pthread_rwlock_t trie_lock;
#endif

	Trie * proot;
} TrieRoot, * PTrieRoot;

typedef void (*trieCallback)(void *);

trieStatus trie_init(PTrieRoot ptrie_root);

trieStatus trie_insert(PTrieRoot ptrie_root,char * word,void * data_pointer);
trieStatus trie_update(PTrieRoot ptrie_root,char * word,void * data_pointer,void ** old_data_pointer);
trieStatus trie_search(PTrieRoot ptrie_root,char * word,void ** data_pointer);
trieStatus trie_delete(PTrieRoot ptrie_root,char * word,void ** data_pointer);
trieStatus trie_foreach(PTrieRoot ptrie_root,trieCallback  call);
trieStatus trie_destroy(PTrieRoot ptrie_root);

#endif //_MACRO_trie_DATA_STRUCTURE_HEADER_



 

 

 

 

// *****************************************************************************
// * trie.c
// *
// * an implementation of a trie tree
// *
// * author: zison sun
// *
// * date: 2016-8-16
// *****************************************************************************
#include "stdafx.h"
#include "vld.h"

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

#include "trie.h"

void _trie_rwlock_rdlock(PTrieRoot ptrie_root);
void _trie_rwlock_wrlock(PTrieRoot ptrie_root);
void _trie_rwlock_unlock(PTrieRoot ptrie_root);

trieStatus _trie_delete(PTrie * pptrie,char * word,void ** data_pointer);
void _trie_foreach(PTrie ptrie,trieCallback  call);
void _trie_destroy(PTrie * pptrie);

void _trie_rwlock_rdlock(PTrieRoot ptrie_root)
{
#if WINDOWS
	DWORD dReturn = WaitForSingleObject(ptrie_root->hMutex,INFINITE);
#else

#endif
}

void _trie_rwlock_wrlock(PTrieRoot ptrie_root)
{
#if WINDOWS
	DWORD dReturn = WaitForSingleObject(ptrie_root->hMutex,INFINITE);
#else

#endif
}

void _trie_rwlock_unlock(PTrieRoot ptrie_root)
{
#if WINDOWS
	ReleaseMutex(ptrie_root->hMutex);
#else

#endif
}

int trie_char_to_index(char charsert)
{
	if(charsert >= '0'  && charsert <= '9' )
		return (charsert - '0');
	else if(charsert >= 'A'  && charsert <= 'F' )
		return (charsert - 'A' + 10);	
	else if(charsert >= 'a'  && charsert <= 'f' )
		return (charsert - 'a' + 10);
	else
		return -1;
}

trieStatus trie_word_check(char * word)
{
	while(*word)
	{
		if(-1 == trie_char_to_index(*word))
			return TRIE_ERROR;

		word++;
	}

	return TRIE_SUCCESS;
}

PTrie trie_malloc()
{
	PTrie  ptrie_temp;
	
	ptrie_temp  = (PTrie) malloc(sizeof(Trie));
	if(!ptrie_temp)
	{
		return 0;
	}
	memset(ptrie_temp,0,sizeof(Trie));

	return ptrie_temp;
}

void trie_free(PTrie ptrie)
{
	if(!ptrie)
		return;
	
	//设置父节点中自己的那个索引为NULL
	if(ptrie->addr_in_parent)
		*((int *)ptrie->addr_in_parent) = NULL;
	free(ptrie);
	
	return ;
}

trieStatus trie_init(PTrieRoot ptrie_root)
{
#if WINDOWS
	ptrie_root->hMutex = CreateMutex(NULL,FALSE,NULL);
#else

#endif
	return TRIE_SUCCESS;
}
/*
 *   warning: chareset in	word  should in [0-9][a-f]
 */
trieStatus trie_insert(PTrieRoot ptrie_root,char * word,void * data_pointer)
{
	int index = -1;
	PTrie ptrie_cur;
	PTrie ptrie_new;
	trieStatus ret = TRIE_ERROR;
	void * data_p;

	if(TRIE_ERROR == trie_word_check(word))
		return TRIE_ERROR;

	if(!ptrie_root)
		return TRIE_ERROR;

	if(TRIE_SUCCESS == trie_search(ptrie_root,word,&data_p))
		return TRIE_ERROR;

	_trie_rwlock_wrlock(ptrie_root);

#if 1//debug
	char sss_copy[256];
	strncpy_s(sss_copy,word,255);
#endif

	printf("add [%s] begin text=[%s]\n",word,data_pointer);
	if(! ptrie_root->proot)
	{
		ptrie_root->proot = trie_malloc();
	}

	ptrie_cur = ptrie_root->proot;

	while(*word)
	{
		index = trie_char_to_index(*word);
		if(-1 == index)
			goto OnReturn;

		ptrie_cur->href++;

		if(ptrie_cur->branch[index] == NULL)
		{
			ptrie_new = trie_malloc();
			ptrie_cur->branch[index] = ptrie_new;
			ptrie_new->addr_in_parent = &ptrie_cur->branch[index];
		}
		
		ptrie_cur = ptrie_cur->branch[index];
	
		word++;
	}

	ptrie_cur->data_pointer = data_pointer;
	ret = TRIE_SUCCESS;

OnReturn:
	printf("add [%s] end\n",sss_copy);
	_trie_rwlock_unlock(ptrie_root);
	return ret;
}

trieStatus trie_if_exist(PTrieRoot prtie_root,char * word)
{
	void * data_addr;
	
	return trie_search(prtie_root,word,&data_addr);
}

trieStatus trie_update(PTrieRoot ptrie_root,char * word,void * data_pointer,void ** old_data_pointer)
{
	int index = -1;
	PTrie ptrie_temp;
	trieStatus ret = TRIE_ERROR;

	if(TRIE_ERROR == trie_word_check(word))
		return TRIE_ERROR;

	if(!ptrie_root)
		return TRIE_ERROR;

	_trie_rwlock_wrlock(ptrie_root);

#if 1//debug
	char sss_copy[256];
	strncpy_s(sss_copy,word,255);
#endif
	if(!ptrie_root->proot)
	{
		_trie_rwlock_unlock(ptrie_root);
		return TRIE_ERROR;
	}	
	
	printf("update [%s] begin text = [%s]\n",word,data_pointer);
	ptrie_temp = ptrie_root->proot;

	while(*word)
	{
		index = trie_char_to_index(*word);
		if(-1 == index)
			goto OnReturn;

		if(ptrie_temp->branch[index] == NULL)
		{
			goto OnReturn;
		}
		
		word++;
		ptrie_temp = ptrie_temp->branch[index];
	}

	*old_data_pointer = ptrie_temp->data_pointer;
	ptrie_temp->data_pointer = data_pointer;
	ret = TRIE_SUCCESS;
OnReturn:
	printf("update [%s] end\n",sss_copy);
	_trie_rwlock_unlock(ptrie_root);
	return ret;

}

trieStatus trie_search(PTrieRoot ptrie_root,char * word,void ** data_pointer)
{
	int index = -1;
	PTrie ptrie_temp;
	trieStatus ret = TRIE_ERROR;

	if(TRIE_ERROR == trie_word_check(word))
		return TRIE_ERROR;

	if(!ptrie_root)
		return TRIE_ERROR;

	_trie_rwlock_rdlock(ptrie_root);

#if 1//debug
	char sss_copy[256];
	strncpy_s(sss_copy,word,255);
#endif
	if(!ptrie_root->proot)
	{
		_trie_rwlock_unlock(ptrie_root);
		return TRIE_ERROR;
	}	
	
	printf("search [%s] begin\n",word);
	ptrie_temp = ptrie_root->proot;

	while(*word)
	{
		index = trie_char_to_index(*word);
		if(-1 == index)
			goto OnReturn;

		if(ptrie_temp->branch[index] == NULL)
		{
			goto OnReturn;
		}
		
		word++;
		ptrie_temp = ptrie_temp->branch[index];
	}

	*data_pointer = ptrie_temp->data_pointer ;
	ret = TRIE_SUCCESS;
OnReturn:
	printf("search [%s] end\n",sss_copy);
	_trie_rwlock_unlock(ptrie_root);
	return ret;

}

trieStatus trie_delete(PTrieRoot ptrie_root,char * word,void ** data_pointer)
{
#if 1
	int index = -1;
	PTrie ptrie_cur;
	PTrie ptrie_cpy;
	int broot = 1;
	trieStatus ret = TRIE_ERROR;

	*data_pointer = NULL;

	if(!ptrie_root)
		return TRIE_ERROR;

	if(TRIE_ERROR == trie_word_check(word))
		return TRIE_ERROR;

	if(TRIE_ERROR == trie_search(ptrie_root,word,data_pointer))
		return TRIE_ERROR;

	_trie_rwlock_wrlock(ptrie_root);
#if 1//debug
	char sss_copy[256];
	strncpy_s(sss_copy,word,255);
#endif
	printf("del [%s] begin\n",word);
	if(! ptrie_root->proot)
		goto onReturn;

	ptrie_cur = ptrie_root->proot;

	while(ptrie_cur && *word)
	{
		index = trie_char_to_index(*word);
		if(-1 == index)
			goto onReturn;

		if(ptrie_cur->branch[index] == NULL)
			goto onReturn;
		 
		ptrie_cpy = ptrie_cur->branch[index];

		if(ptrie_cur->href > 1)
		{
			ptrie_cur->href--;
			broot = 0;
		}
		else
		{
			ptrie_cur->href = 0;
			if(broot)
			{
				ptrie_root->proot = NULL;
				broot = 0;
			}

			trie_free(ptrie_cur);
			ptrie_cpy->addr_in_parent = NULL;
		}

		ptrie_cur = ptrie_cpy;
		word++;
	}


	*data_pointer = ptrie_cur->data_pointer ;
	printf("%s\n",*data_pointer);
	ret = TRIE_SUCCESS;
	if(ptrie_cur->href == 0)
		trie_free(ptrie_cur);

onReturn:
	printf("del [%s] end\n",sss_copy);
	_trie_rwlock_unlock(ptrie_root);

	return ret;
#else
// 递归
	trieStatus ret;
	
	if(!ptrie_root)
		return TRIE_ERROR;
	
	if(TRIE_ERROR == trie_word_check(word))
		return TRIE_ERROR;
	
	printf("delete begin\n");
	_trie_rwlock_wrlock(ptrie_root);
	ret = _trie_delete(&ptrie_root->proot,word,data_pointer);
	printf("delete end\n");
	_trie_rwlock_unlock(ptrie_root);
	return ret;

#endif
}

trieStatus _trie_delete(PTrie *pptrie,char * word,void ** data_pointer)
{
	int index;
	
	if(!*pptrie)
		return TRIE_ERROR;

	if(*word)
	{
		index = trie_char_to_index(*word);
		if(-1 == index)
			return TRIE_ERROR;

		if((*pptrie)->branch[index] == NULL)
		{
			return TRIE_ERROR;
		}
		
		word++;
		if(TRIE_SUCCESS == _trie_delete(&(*pptrie)->branch[index],word,data_pointer))
		{
			(*pptrie)->href--;

			if( (*pptrie)->href ==0)
			{
				trie_free(*pptrie);
				*pptrie = NULL;
			}
		}
	}
	else
	{
		if( (*pptrie)->href ==0)
		{
			*data_pointer = (*pptrie)->data_pointer ;
			trie_free(*pptrie);
			*pptrie = NULL;
		}
	}
	
	return TRIE_SUCCESS;
}


trieStatus trie_foreach(PTrieRoot ptrie_root,trieCallback  call)
{
	if(!ptrie_root)
		return TRIE_ERROR;

	_trie_rwlock_rdlock(ptrie_root);
	printf("foreach begin\n");
	_trie_foreach(ptrie_root->proot,call);
	printf("foreach end\n");
	_trie_rwlock_unlock(ptrie_root);
	return TRIE_SUCCESS;
}


void _trie_foreach(PTrie ptrie,trieCallback  call)
{
	int i = 0;

	if(!ptrie)
		return;
	
	if(0 == ptrie->href && NULL != ptrie->data_pointer)
	{
		call(ptrie->data_pointer);
		return ;
	}
	for(i = 0; i < TRIE_SON_NUM;i++)
	{
		if((ptrie)->branch[i])
		{
			_trie_foreach(ptrie->branch[i],call);
		}
	}

	return;
}

trieStatus trie_destroy(PTrieRoot ptrie_root)
{
	if(!ptrie_root)
		return TRIE_ERROR;

	_trie_rwlock_wrlock(ptrie_root);

	printf("destroy begin\n");
	_trie_destroy(&ptrie_root->proot);
	ptrie_root->proot = NULL;
	printf("destroy end\n");
	_trie_rwlock_unlock(ptrie_root);

	
#if WINDOWS
	CloseHandle(ptrie_root->hMutex);
	ptrie_root->hMutex = 0;
#else

#endif


	return TRIE_SUCCESS;
}

void _trie_destroy(PTrie * pptrie)
{
	int i = 0;

	if(!*pptrie)
		return;

	for(i = 0; i < TRIE_SON_NUM;i++)
	{
		if((*pptrie)->branch[i])
		{
			_trie_destroy(&(*pptrie)->branch[i]);
			trie_free((*pptrie)->branch[i]);
		}
	}
	trie_free(*pptrie);
	*pptrie = NULL;

	return ;
}

 

 

 


   


                

        

        

    




    

      

        

            

              
                
                  光谷中心城打工人
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
实现二叉树的增删改查基本操作的c++程序

				
			

			

				

					07-29
				

			

		

		

			
				
很好很强大的程序，实现二叉树的增删改查等基本操作，操作简单，程序结构清晰

			
		

	



                

              
                



	

		

			

				
					
一棵Java字典树（trie）和它的增删改查

				
			

			

				

					01-20
				

			

		

		

			
				
Step2 实现相应的操作方法——增删改查 Step1 设计结点 我们需要该结点能够存储以下数据： 该结点代表的单个字符->>字节 该结点是否为词语结尾（叶子结点）->>布尔 该结点的子结点串->>链表结构 public class Trie {...

			
		

	



                


  
              

                


	

		

			

				
					
字典树（增删改查 HDU 5687）

				
			

			

				

					weixin_33728268的博客
				

				

					03-13
					
					165
					
				

			

		

		

			
				
度熊手上有一本神奇的字典，你可以在它里面做如下三个操作：  
 1、insert : 往神奇字典中插入一个单词 
  
 2、delete: 在神奇字典中删除所有前缀等于给定字符串的单词 
  
 3、search: 查询是否在神奇字典中有一个字符串的前缀等于给定的字符串 
  

Input这里仅有一组测试数据。第一行输入一个正整数N(1≤N≤100000)，代表度...

			
		

	





	

		

			

				
					
【vue】el-tree的新增/编辑/删除节点

					
最新发布

				
			

			

				

					qq_39404437的博客
				

				

					04-17
					
					2242
					
				

			

		

		

			
				
关于树形结构的新增同级节点等四种操作，各种参数配置完全继承el-tree，本篇使用vue2 + element-ui。

			
		

	



		

			
		



	

		

			

				
					
字典树 增删查改变式

				
			

			

				

					lanshan1111的博客
				

				

					02-20
					
					207
					
				

			

		

		

			
				
度熊手上有一本神奇的字典，你可以在它里面做如下三个操作： 
  1、insert : 往神奇字典中插入一个单词 
  2、delete: 在神奇字典中删除所有前缀等于给定字符串的单词 
  3、search: 查询是否在神奇字典中有一个字符串的前缀等于给定的字符串 

Input

这里仅有一组测试数据。第一行输入一个正整数N(1≤N≤100000)N(1≤N≤100000)，代表度熊对于字典的操...

			
		

	





	

		

			

				
					
中文分词：之Trie树

				
			

			

				

					kydkong的博客
				

				

					08-01
					
					1226
					
				

			

		

		

			
				
http://blog.csdn.net/wzb56_earl/article/details/7902669

			
		

	





	

		

			

				
					
HDU5687（字典树Trie增删查）

				
			

			

				

					Winjourn的专栏
				

				

					05-20
					
					671
					
				

			

		

		

			
				
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5687

Problem C
Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 417    Accepted Submission

			
		

	





	

		

			

				
					
Trie树(字典树)的介绍及Java实现

				
			

			

				

					08-31
				

			

		

		

			
				
Trie树，又称字典树或前缀树，关于它的结构就不详细介绍了。Trie树在单词统计、前缀匹配等很多方面有很大用处。下面这篇文章主要介绍了Trie树，以及Java实现如何Trie树，有需要的朋友可以参考借鉴，下面来一起看看吧...

			
		

	





	

		

			

				
					
详解字典树Trie结构及其Python代码实现

				
			

			

				

					09-21
				

			

		

		

			
				
字典树，也称为Trie，是一种特殊的树形数据结构，主要用于快速查找和统计具有公共前缀的字符串。这种数据结构在处理大量字符串时特别有用，例如在搜索引擎的文本词频统计、搜索建议和拼写检查等场景中。Trie的主要...

			
		

	





	

		

			

				
					
Java实现字典树TrieTree

				
			

			

				

					08-19
				

			

		

		

			
				
Java实现字典树TrieTree,可用于计算出四六级试题的高频词.

			
		

	





	

		

			

				
					
Trie树_字典树(字符串排序)简介及实现

				
			

			

				

					10-26
				

			

		

		

			
				
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)

			
		

	





	

		

			

				
					
zTree树形菜单增删改

				
			

			

				

					01-12
				

			

		

		

			
				
不错的树形菜单，连接mysql数据库，可实现增删改功能，绑定菜单URL等等。

			
		

	





	

		

			

				
					
算法从0到1之trie(字典树)的增删改查(递归与非递归实现)

				
			

			

				

					Francis的博客
				

				

					10-26
					
					688
					
				

			

		

		

			
				
算法从0到1之trie(字典树)的增删改查(递归与非递归实现)0.导语Trie树，又称单词查找树或键树，是一种树形结构。典型应用是用于统计和排序大量的字符串（但不仅限于字...

			
		

	





	

		

			

				
					
带前缀修改的字典树

				
			

			

				

					weixin_33722405的博客
				

				

					04-24
					
					92
					
				

			

		

		

			
				
在一个 Minecraft 村庄中，村长有这一本小写字母构成的名册（字符串的表）， 每个名字旁边都记录着这位村民的声望值，而且有的村民还和别人同名。 随着时间的推移，因为没有村民死亡，这个名册变得十分大。
  现在需要您来帮忙维护这个名册，支持下列 4 种操作： 
  1. 插入新人名 si，声望为 ai 2. 给定名字前缀 pi 的所有人的声望值变化 di 3. 查询名字为 sj 村民们的声...

			
		

	





	

		

			

				
					
字典树的创建以及增删改查方法详解（Python实现）

				
			

			

				

					Delusional的博客
				

				

					10-17
					
					840
					
				

			

		

		

			
				
《自然语言处理入门》-2.4字典树 学习笔记

字典树的定义

参考博客：https://blog.csdn.net/weixin_39778570/article/details/81990417



这里还有一个映射的概念，图中能表示一个个字符串的集合，除了集合的功能之外，字典树也可以实现映射，只需将相应的值悬挂在键的终点节点上即可，后续的代码实现也是关于字典树的映射的。

字典树节点和树的Python代码实现


class Node(object):
    def __init__(self, 

			
		

	





	

		

			

				
					
 小白详解 Trie 树

				
			

			

				

					weixin_34221036的博客
				

				

					03-29
					
					259
					
				

			

		

		

			
				
一、引言
最近学习自然语言处理（NLP）相关的知识，认识了 Trie 这种树形数据结构，在 NLP 中一般会用其存储大量的字典字符以用于文本的快速分词；除此之外，典型应用场景还包括大批量文本的：词频统计、字符串查询和模糊匹配（比如关键词的模糊匹配）、字符串排序等任务；由于 Trie 大幅降低了无谓的字符串比较，因此在执行上述任务时，其效率...

			
		

	





	

		

			

				
					
多线程实现字典系统(server+client)

				
			

			

				

					qq_36098284的博客
				

				

					05-13
					
					1048
					
				

			

		

		

			
				
多线程字典系统实现

首先说明下该系统可以实现的功能，小白都可以！！！！

该博客只提供学习和实现的思路，如果需要详细的代码，请留言！！！

1 具体要求

简单来说，就是实现服务器端和客户端，可以做到多个客户端并发对字典中的数据进行操作，但是不考虑跨局域网的情况，但是我稍后的文章会介绍一个跨局域网多线程系统的实现。

1.需要实现客户端和服务器端Socket

2.实现多用户并发执行字典查询等操作 Thread类/Runnable接口...

			
		

	





	

		

			

				
					
前缀树(字典树)trieTree两种实现

				
			

			

				

					qq_44658941的博客
				

				

					02-28
					
					195
					
				

			

		

		

			
				
实现TrieTree中的易混淆的地方：注意查找字符串和字符串前缀的区别
1.查找字符串的话,要使用最后一个节点判断是否为单词,多种解决办法,可以设置标志位,tree：单词，false：不是单词，是字串的中间部分
或者也可以用第一种实现中的end值，end>0表示字符串结尾
2.查找前缀的话,没条件,只要trietree中有前缀单词即可

最后标注:数据结构的实现是多种多样的,掌握核心的灵魂才是关键

数组实现trieTree:缺点浪费空间,一般不使用
public class TrieTree {
 

			
		

	





	

		

			

				
					
没啥事用C语言写一个Trie tree玩玩，支持中英文，用g++编译通过

				
			

			

				

					tengyunjiawu_com的专栏
				

				

					09-26
					
					515
					
				

			

		

		

			
				
#include 
#include 
#include 

#define ALPHABETS 2600000
#define CASE 0
#define MAX_WORD_SIZE 25

using namespace std;

struct node
{
    struct node *parent;
    struct node *children[ALPHABETS];
   

			
		

	





	

		

			

				
					
CSharp 实现trie tree字典树 源代码

				
			

			

				

					04-07
				

			

		

		

			
				
以下是 CSharp 实现 Trie Tree 字典树的源代码：  ```csharp public class TrieNode {  public Dictionary, TrieNode> Children { get; set; }  public bool IsEndOfWord { get; set; }   public TrieNode()  {  ...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值