trie——字典树

已于 2023-02-19 21:04:40 修改
阅读量146 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 1024程序员节 go
于 2021-10-24 19:16:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawnto/article/details/120938745
版权 
package trie

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

/*
前缀树
1.单个字符中，字符从前到后的加到一棵多叉数上
2.字符放在路上，节点是国内有专属的数据项（常见的是pass和end值[通过值和收尾值]）  pass 当前节点被通过了几次， end 成为了多少个字符串的结尾
3.所有样本都这样添加，如果没有路就新建，如果有路就复用
4.沿途节点的pass值增加1，每个字符串结束时来到的节点end值加1

可以完成前缀相关的查询


["abc"], ["abd"], ["kst"]
 每新加一个字符串都是 从头节点触发的
 加一个节点[“ab"] ["a"]
                                                        [p:1,e:0]  p: 5  e:1
                                               a/                      \k
                                          [p:1, e:0] p:2 p:3        [p:1,e:0]
                                        b/                               \s
                                   [p:1,e:0]   p:2 p:3 e:1            [p:1,e:0]
                                  c/     \d                                \t
                          [p:1,e:1]     [p:1,e:1]                       [p:1,e:1]

     如果所有字符串字符数量是N  建树的代价是 O(N),每处理一个字符代价是O(1)
    "gab" 加入直接新建 不用考虑复用(压缩)
    查询abd 字符串插入了几次
    有没有走向 a 的路
    有没有走向 b 的路
    有没有走向 d 的路  查看e值

    查询"ks" 有k 没有s

    加入的所有字符串 有多少字符串以a 做前缀    p值就是 加入多少次，因为以我为路径加入的


  字典树可以用于 不文明发言检测

*/


type Node1 struct {
    pass  int
	end   int
	nexts []*Node1
}

func NewNode1() *Node1 {
	return &Node1{
		pass:  0,
		end:   0,
		// 0 --> 'a'  1 --> 'b'  nexts[i] == nil i方向上的路不存在
		//                       nexts[i] != nil i方向上的路存在
		nexts: make([]*Node1,26),  //如果加入的字符都是 a——z 小写的形式
	}
}

type  Trie1 struct {
	root *Node1
}

func NewTrie1() *Trie1 {
	return &Trie1{
		root: NewNode1(),
	}
}

func (t *Trie1)insert(word string)  {
	if word == "" {
		return
	}
	node := t.root
	node.pass++  // 有字符的话，必经过头结点

	path := 0
	for k := 0; k < len(word); k++ {
		path = int(word[k] - 'a')
		if node.nexts[path] == nil {
			node.nexts[path] = NewNode1()
		}
		node = node.nexts[path]
		node.pass++
	}
	node.end++
}

func (t *Trie1)delete(word string)  {
	if t.search(word) == 0 {   // 查一下是否被加入，不删除一个未加入的字符串
		return
	}

	node := t.root
	node.pass--

	path := 0
	for k := 0; k < len(word); k++ {
		path = int(word[k] - 'a')
		if node.nexts[path].pass - 1 == 0 {
			node.nexts[path] = nil
			return
		}
		node.nexts[path].pass--
		node = node.nexts[path]
	}
	node.end--
}



func (t *Trie1)search(word string) int { // word 被加入几次
	if word == "" {
		return 0
	}

	node, path := t.root, 0
	for k := 0; k < len(word); k++ {
		path = int(word[k] - 'a')
		if node.nexts[path] == nil {
			return 0
		}
		node = node.nexts[path]
	}
	return node.end
}

func (t *Trie1)prefixNumber(pre string) int { // pre 所有加入的字符串中，有几个是以pre这个字符串作为前缀
	if pre == "" {
		return 0
	}

	node, path := t.root, 0
	for k := 0; k < len(pre); k++ {
		path = int(pre[k] - 'a')
		if node.nexts[path] == nil {
			return 0
		}
		node = node.nexts[path]
	}
	return node.pass
}





func TestTrieInsert(t *testing.T)  {
	trie := NewTrie1()
	trie.insert("helloworld")
	fmt.Println(*trie.root.nexts['h'- 'a'].nexts['e'-'a'].nexts['l'-'a'])
}

func TestTrieSearch(t *testing.T)  {
	trie := NewTrie1()
	trie.insert("helloworld")
	trie.insert("helloworld")
	fmt.Println(trie.search("helloworld"))
}

func TestTriePrefixNumber(t *testing.T)  {
	trie := NewTrie1()
	trie.insert("helloworld")
	trie.insert("helloworld")
	trie.insert("hellow")
	fmt.Println(trie.prefixNumber("hello"))
}

func TestTrieDelete(t *testing.T)  {
	trie := NewTrie1()
	trie.insert("helloworld")
	trie.insert("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
	trie.delete("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
	trie.delete("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
	trie.delete("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
}



//-----------------------------------------------

type Node2 struct {
	pass int
	end  int
	nexts map[int]*Node2
}

func NewNode2() *Node2 {
	return &Node2{
		pass:  0,
		end:   0,
		nexts: map[int]*Node2{},
	}
}

type Trie2 struct {
	root *Node2
}


func NewTrie2() *Trie2 {
	return &Trie2{
		root: NewNode2(),
	}
}

func (t *Trie2)insert(word string)  {
	if word == "" {
		return
	}
	node := t.root
	node.pass++

	path := 0
	for k := range word { //range 好处，可以不拆分汉字
		path = int(word[k])
		if  node.nexts[path] == nil {
			node.nexts[path] = NewNode2()
		}
		node = node.nexts[path]
		node.pass++
	}
	node.end++
}

func (t *Trie2)delete(word string)  {
	if t.search(word) == 0 {   // 查一下是否被加入，不删除一个未加入的字符串
		return
	}

	node := t.root
	node.pass--

	path := 0
	for k := range word {
		path = int(word[k])
		if node.nexts[path].pass - 1 == 0 {
			node.nexts[path] = nil
			return
		}
		node.nexts[path].pass--
		node = node.nexts[path]
	}
	node.end--
}

func (t *Trie2)search(word string) int { // word 被加入几次
	if word == "" {
		return 0
	}

	node, path := t.root, 0
	for k := range word {
		path = int(word[k])
		if  node.nexts[path] == nil {
			return 0
		}
		node = node.nexts[path]
	}
	return node.end
}

func (t *Trie2)prefixNumber(pre string) int { // pre 所有加入的字符串中，有几个是以pre这个字符串作为前缀
	if pre == "" {
		return 0
	}

	node, path := t.root, 0
	for k := range pre {
		path = int(pre[k])
		if  node.nexts[path] == nil {
			return 0
		}
		node = node.nexts[path]
	}
	return node.pass
}


func TestTrieInsert2(t *testing.T)  {
	trie := NewTrie2()
	trie.insert("helloworld")
	fmt.Println(*trie.root.nexts['h'].nexts['e'].nexts['l'])
}

func TestTrieSearch2(t *testing.T)  {
	trie := NewTrie2()
	trie.insert("helloworld")
	trie.insert("helloworld")
	fmt.Println(trie.search("helloworld"))
}

func TestTriePrefixNumber2(t *testing.T)  {
	trie := NewTrie2()
	trie.insert("helloworld")
	trie.insert("helloworld")
	trie.insert("hellow")
	fmt.Println(trie.prefixNumber("hello"))
}

func TestTrieDelete2(t *testing.T)  {
	trie := NewTrie2()
	trie.insert("helloworld")
	trie.insert("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
	trie.delete("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
	trie.delete("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
	trie.delete("helloworld")
	fmt.Println(trie.prefixNumber("hello"))
}



func TestTrie(t *testing.T)  {
   dic := []string{
	   "卧了个*",
	   "傻*",
	   "出门没吃药",
	   "违规词",
	   "尼玛，没吃药吗",
	   "长眼睛了吗",
   }

   trie := NewTrie2()
   for k := range dic{
	   trie.insert(dic[k])
   }

   userSay := "尼玛"
   if trie.prefixNumber(userSay) > 0 {
	   //违规词汇
   }

   fmt.Println(trie.search("卧了个槽"))
}

func Test(t *testing.T)  {
  compare()
}





func getRandomString(l int) string {
	rand.Seed(time.Now().UnixNano())
	length := rand.Int() % l
	ans := ""
	for i := 0; i < length; i++ {
		str := string(rune('a' + (rand.Int() % 26)))
		ans += str
	}
	return ans
}




func compare()  {
	t1, t2 := NewTrie1(), NewTrie2()
	for i := 1; i < 100000;i++ {
		randStr := getRandomString(100)
		t1.insert(randStr)
		t2.insert(randStr)

		key := getRandomString(10)
		if t1.search(key) != t2.search(key) {
			fmt.Println(randStr,t1.search(key),t2.search(key))
			panic("err")
		}

		if t1.prefixNumber(key) != t2.prefixNumber(key) {
			fmt.Println(randStr,t1.prefixNumber(key),t2.prefixNumber(key))
			panic("err")
		}

		del := getRandomString(10)
		t1.delete(del)
		t2.delete(del)
	}

	fmt.Println((*t1.root).nexts)
	fmt.Println(t2.root.nexts)

}
metabit
关注
专栏目录
Trie——字典树
萌新的博客
03-06 149
Trie树几个练手的题目，值得一试，难度都不大
trie——字典树模板
PBomb的博客
07-22 279
#include <iostream> using namespace std; const int N = 20010; int son[N][26], cnt[N], idx; // son[i]数组存放存放第i个节点其各个子节点的下标, cnt数组表示以该节点结尾的单词数, idx表示当前节点序号 void insert(char str[]) { int p = 0; // 根节点 for (int i = 0; str[i]; i++) {
Trie树——字典树
NLP翟
10-10 286
简介 Trie树又称字典树（前缀树），常用在搜索场景下。用于判断一个词汇或者文本是否出现在已有的记录中。 利用Trie树记录一个词表，判断文本中的词汇是否出现在词表中。这个应用中使用Trie树可以提高整体的检索效率。 实现 通常Tire树的实现需要完成三部分： Trie树中插入词汇 从Trie树中检索词汇 从Trie树中判断是否有给出的前缀字符串 代码 class Trie(object): def __init__(self): self.lookup = {} # 可以理解为是根节点 d
c语言 trie树,数据结构篇——字典树（trie树）
weixin_31433053的博客
05-19 1026
引入现在有这样一个问题， 给出$n$个单词和$m$个询问，每次询问一个单词，回答这个单词是否在单词表中出现过。好像还行，用 map ，几行就完事了。那如果n的范围是 $10^5$ 呢？再用 $map$ 妥妥的超时，说不定还会超内存。这时候就需要一种强大的数据结构——字典树基本性质字典树，又叫Trie树、前缀树，用于统计，排序和保存大量的字符串，经常被搜索引擎系统用于文本词频统计。基本思想： 利用字...
Trie树——字典Trie树
最新发布
r2931887650的博客
09-23 245
共有 N (1≤N≤2×10^4) 个操作，输入的字符串总长度不超过 10^5，字符串仅包含小写英文字母。对于每个询问指令 Q x，都要输出一个整数作为结果，表示 x 在集合中出现的次数。接下来 N 行，每行包含一个操作指令，指令为 I x 或 Q x 中的一种。第一行包含整数 N，表示操作数。
Trie树——字典树，单词查找树
LarsGyonX的博客
02-24 213
给出n个单词，询问q次，看某单词是否在这些单词中，单词最长为l。如果使用暴力遍历的话，复杂度可达到O（n*q*l)，很显然，一般会超时的。因此，我们发现了Trie树。 Trie树是个什么样的数据结构 int son[N][26], cnt[N], idx; // 0号点既是根节点，又是空节点 // son[][]存储树中每个节点的子节点 // cnt[]存储以每个节点结尾的单词数量 idx：插入顺序标号，全局变量 son[p][x]=i：p表示新插入字母的前一个字母的标号，x表示新字
C++———trie树字典树个人解析
m0_74939592的博客
11-12 320
这是用到数组实现的，每个父节点最多都会有26个子节点，这分别对应了26个字母，在插入的过程之中会用到一个idx表示插入了多少个节点。比如根节点的子节点a为son[0][1]=1,然后通过索引1可以插入a的子节点son[1][2]=b的插入排序数字。u的作用是存储的字母的ASCII码值，判断在son[][]二维数组中存储在哪，也就是说会存储在son[][u]的位置，并且位置表示字母，数组里面存储的是索引，是用来查找下一个字母的。根节点是空节点，在实现字典树的过程中就像一个树。这道题可以使用字典树思想。
Trie ——前缀树、字典树
我的博客
03-02 273
说在前面： Map映射数据结构和Trie的异同： 相同：都能够根据key进行映射得到对应的值。 不同： ① Trie中查询/添加的算法复杂度为O(len)，即插入/查询的字符串的长度，而Map查询/添加的算法复杂度为O(logn)，n为输入的查询元素个数。 ② Trie是用多叉树实现的，而Map一般是用二叉树实现的。 Trie：专门为了处理（存储/查询）字符串而设计的 Trie是以时间换空...
Trie字典树（1）—— 字典树查询
一角残叶的博客
02-09 433
1 Trie 介绍 1.1 字典 如果有 n 个条目，使用树结构，查询的时间复杂度是 O(logn); 如果有100 万个条目（2^20），logn 大约数20 1.2 Trie 查询每个条目的时间复杂度和字典中的条目总数无关； 时间复杂度是 O(w),w 是查询单词的长度； 1.3 Trie 的查询 Trie.java package tree; import java.util....
字符串处理——字典树.rar
09-16
本资源“字符串处理——字典树.rar”聚焦于一种高效的数据结构——字典树（Trie），它在字符串处理中发挥着关键作用。通过学习字典树，我们可以更好地理解和解决与字符串相关的问题。 字典树，又称前缀树或PAT树，...
Python高级数据结构——字典树（Trie）
Echo_Wish的博客
12-04 1069
字典树是一种强大的数据结构，特别适用于处理大量字符串集合的场景。通过高效的插入、查找和删除操作，字典树在搜索引擎、拼写检查、自动完成等应用中发挥着重要作用。在Python中，我们可以利用类似上述示例的代码轻松实现字典树，并加以灵活运用解决实际问题。理解字典树的基本概念、实现方式和应用场景，将有助于更好地应用字典树解决实际问题，提高算法的效率。
数据结构——Trie树（字典树）
劭星の博客
10-05 366
目录 一、什么是字典树 问题引入： 解法 1.暴力 2.奇奇怪怪的解法 二、字典树 1.思路 2.基本操作 (1)更新 update (2)查找 find 3.思考 三、模板题 一、什么是字典树 问题引入： 有n个字符串，每个字符串都由26个小写英文字母构成，现在请求出这些字符串的最长前缀 输入样例： 3 exit apple exford 输出样例：...
字符串算法总结——字典树
LiuKairui的博客
06-09 1397
字典树 好不容易不用学EXKMP，开森，实际上字典树很简单，我们看： 已知有 n 个长度不一定相同的母串，以及一个长度为 m 的模式串 T，求该模式串是否是其中一个母串的前缀。如果将模式串 T 挨个去比较，则算法复杂度会很高，达到 O(n×m)，是否有高效的方法呢？ 已知一个长度为 n 的字符串 S，求该字符串有多少个不相同的子串。朴素的做法，可以先枚举出所有的子串，这样时间复杂度为 O(n...
数据结构与算法笔记——用Go语言描述
Go的全部
11-16 3746
数据结构与算法 用Go语言描述 位运算 位运算——奇淫技巧 位运算——二进制截断和插入 位运算——交换奇偶位 位运算——回文判断 位运算——LeetCode1386. 安排电影院座位 位运算——面试题 17.19. 消失的两个数字 位运算——求1比特数 位运算——476. 数字的补数 位运算——出现一次的数，出现两次的数 查找 二分——有序数组中查找元素 二分——有序数组中，某个数最左或最右的位置 二分——无序无重复元素数组的局部最小值的索引 排序 排序——选择排序 排序——冒泡排序 排序——插入排序 .
go标准库——优先级队列的实现
Go的全部
10-24 3132
package heap_test // priorty_queue是以个带权值观念的queue，它允许加入新元素，移除旧元素，审视元素值等功能 import ( "container/heap" "fmt" "testing" ) // Item 是我们在优先队列中管理的东西 type Item struct { value string // The value of the item; arbitrary. priority int // 队列中项目的优先级 // The
动态规划——编辑距离问题
Go的全部
01-28 2546
动态规划——编辑距离问题
堆定制——1.0强耦合版
Go的全部
10-24 2242
package heap import ( "encoding/json" "fmt" "testing" ) //什么时候需要手写堆，需要更新堆中的某些值，让他自然有序 //迪杰斯特拉算法 就需要这类算法 // 从每个节点扫一遍， 代价会非常高 // 用户：可能对于某一个已经存在的对象，修改值， 在堆上找到，调整到该去的位置，logN级别 type student struct { Name string Age int Height int Weight int
上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
Go的全部
01-27 2196
题目描述： 小明有一个数组，他想从数组任意元素开始向后遍历，找出所有上升子序列，并计算出最长的上升子序列的长度。 上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
search——Bloom Filter
Go的全部
01-19 2193
BitMap
ACM必备：高级数据结构详解——字典树、并查集与哈夫曼树
本文主要介绍三种重要的高级数据结构：字典树（Trie）、并查集（Union-Find Sets）和哈夫曼树（Huffman Tree）。 1. **字典树（Trie）** Trie，又称前缀树，是一种特殊的数据结构，用于高效地存储和查找具有公共...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

metabit

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

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

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

打赏作者

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

抵扣说明：

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

余额充值