mirror of
https://github.com/hlccd/goSTL.git
synced 2025-01-18 13:59:32 +08:00
新增单词查找树Trie的实现,修改了一些之前实现的数据结构的注释
This commit is contained in:
hlccd
GitHub
parent
e432cf42e5
commit
8c4ffc8f0f
@ -1,5 +1,13 @@
|
||||
package algorithm
|
||||
|
||||
//@Title algorithm
|
||||
//@Description
|
||||
// hash函数
|
||||
// 定义了一个hash函数类型,该类型可传入一个key并返回其hash值
|
||||
// 该包内定义了一些自带类型的hash函数
|
||||
// 当使用自定义的数据结构时若不传入hash函数则使用默认的hash函数
|
||||
// 若传入类型非系统自带类型,则返回nil同时对数据的插入失败
|
||||
|
||||
type Hasher func(key interface{}) uint64
|
||||
|
||||
func GetHash(e interface{}) (hash Hasher) {
|
||||
@ -47,37 +55,37 @@ func boolHash(key interface{}) uint64 {
|
||||
return 0
|
||||
}
|
||||
func intHash(key interface{}) uint64 {
|
||||
return uint64(key.(int) * key.(int)/2)
|
||||
return uint64(key.(int) * key.(int) / 2)
|
||||
}
|
||||
func int8Hash(key interface{}) uint64 {
|
||||
return uint64(key.(int8) * key.(int8)/2)
|
||||
return uint64(key.(int8) * key.(int8) / 2)
|
||||
}
|
||||
func uint8Hash(key interface{}) uint64 {
|
||||
return uint64(key.(uint8) * key.(uint8)/2)
|
||||
return uint64(key.(uint8) * key.(uint8) / 2)
|
||||
}
|
||||
func int16Hash(key interface{}) uint64 {
|
||||
return uint64(key.(int16) * key.(int16)/2)
|
||||
return uint64(key.(int16) * key.(int16) / 2)
|
||||
}
|
||||
func uint16Hash(key interface{}) uint64 {
|
||||
return uint64(key.(uint16) * key.(uint16)/2)
|
||||
return uint64(key.(uint16) * key.(uint16) / 2)
|
||||
}
|
||||
func int32Hash(key interface{}) uint64 {
|
||||
return uint64(key.(int32) * key.(int32)/2)
|
||||
return uint64(key.(int32) * key.(int32) / 2)
|
||||
}
|
||||
func uint32Hash(key interface{}) uint64 {
|
||||
return uint64(key.(uint32) * key.(uint32)/2)
|
||||
return uint64(key.(uint32) * key.(uint32) / 2)
|
||||
}
|
||||
func int64Hash(key interface{}) uint64 {
|
||||
return uint64(key.(int64) * key.(int64)/2)
|
||||
return uint64(key.(int64) * key.(int64) / 2)
|
||||
}
|
||||
func uint64Hash(key interface{}) uint64 {
|
||||
return uint64(key.(uint64) * key.(uint64)/2)
|
||||
return uint64(key.(uint64) * key.(uint64) / 2)
|
||||
}
|
||||
func float32Hash(key interface{}) uint64 {
|
||||
return uint64(key.(float32) * key.(float32)/2)
|
||||
return uint64(key.(float32) * key.(float32) / 2)
|
||||
}
|
||||
func float64Hash(key interface{}) uint64 {
|
||||
return uint64(key.(float64) * key.(float64)/2)
|
||||
return uint64(key.(float64) * key.(float64) / 2)
|
||||
}
|
||||
func complex64Hash(key interface{}) uint64 {
|
||||
r := uint64(real(key.(complex64)))
|
||||
|
||||
@ -37,7 +37,7 @@ type avlTreer interface {
|
||||
Size() (num int) //返回该二叉树中保存的元素个数
|
||||
Clear() //清空该二叉树
|
||||
Empty() (b bool) //判断该二叉树是否为空
|
||||
Insert(e interface{}) (b bool) //向二叉树中插入元素e
|
||||
Insert(e interface{}) (b bool) //向二叉树中插入元素e
|
||||
Erase(e interface{}) (b bool) //从二叉树中删除元素e
|
||||
Count(e interface{}) (num int) //从二叉树中寻找元素e并返回其个数
|
||||
}
|
||||
@ -149,7 +149,7 @@ func (avl *AvlTree) Empty() (b bool) {
|
||||
//@receiver avl *avlTree 接受者avlTree的指针
|
||||
//@param e interface{} 待插入元素
|
||||
//@return b bool 添加成功?
|
||||
func (avl *AvlTree) Insert(e interface{}) (b bool){
|
||||
func (avl *AvlTree) Insert(e interface{}) (b bool) {
|
||||
if avl == nil {
|
||||
return false
|
||||
}
|
||||
@ -186,7 +186,7 @@ func (avl *AvlTree) Insert(e interface{}) (b bool){
|
||||
// 如果该二叉树仅持有一个元素且根节点等价于待删除元素,则将二叉树根节点置为nil
|
||||
//@receiver avl *avlTree 接受者avlTree的指针
|
||||
//@param e interface{} 待删除元素
|
||||
//@return b bool 删除成功
|
||||
//@return b bool 删除成功?
|
||||
func (avl *AvlTree) Erase(e interface{}) (b bool) {
|
||||
if avl == nil {
|
||||
return false
|
||||
|
||||
204
goSTL/data_structure/trie/node.go
Normal file
204
goSTL/data_structure/trie/node.go
Normal file
@ -0,0 +1,204 @@
|
||||
package trie
|
||||
|
||||
//@Title trie
|
||||
//@Description
|
||||
// 单词查找树的节点
|
||||
// 可通过节点的分叉对string进行查找
|
||||
// 增添string时候只需要增删结点即可
|
||||
// 当string到终点时存储元素
|
||||
|
||||
//node树节点结构体
|
||||
//该节点是trie的树节点
|
||||
//结点存储到此时的string的前缀数量
|
||||
//以son为分叉存储下属的string
|
||||
//该节点同时存储其元素
|
||||
type node struct {
|
||||
num int
|
||||
son [64]*node
|
||||
value interface{}
|
||||
}
|
||||
|
||||
//@title newNode
|
||||
//@description
|
||||
// 新建一个单词查找树节点并返回
|
||||
// 将传入的元素e作为该节点的承载元素
|
||||
//@receiver nil
|
||||
//@param e interface{} 承载元素e
|
||||
//@return n *node 新建的单词查找树节点的指针
|
||||
func newNode(e interface{}) (n *node) {
|
||||
return &node{
|
||||
num: 0,
|
||||
value: e,
|
||||
}
|
||||
}
|
||||
|
||||
//@title inOrder
|
||||
//@description
|
||||
// 以node单词查找树节点做接收者
|
||||
// 遍历其分叉以找到其存储的所有string
|
||||
//@receiver n *node 接受者node的指针
|
||||
//@param s string 到该结点时的前缀string
|
||||
//@return es []interface{} 以该前缀s为前缀的所有string的集合
|
||||
func (n *node) inOrder(s string) (es []interface{}) {
|
||||
if n == nil {
|
||||
return es
|
||||
}
|
||||
if n.value != nil {
|
||||
es = append(es, s)
|
||||
}
|
||||
for i, p := 0, 0; i < 62 && p < n.num; i++ {
|
||||
if n.son[i] != nil {
|
||||
if i < 26 {
|
||||
es = append(es, n.son[i].inOrder(s+string(i+'a'))...)
|
||||
} else if i < 52 {
|
||||
es = append(es, n.son[i].inOrder(s+string(i-26+'A'))...)
|
||||
} else {
|
||||
es = append(es, n.son[i].inOrder(s+string(i-52+'0'))...)
|
||||
}
|
||||
p++
|
||||
}
|
||||
}
|
||||
return es
|
||||
}
|
||||
|
||||
//@title getIdx
|
||||
//@description
|
||||
// 传入一个byte并根据其值返回其映射到分叉的值
|
||||
// 当不属于'a'~'z','A'~'Z','0'~'9','+','/'时返回-1
|
||||
//@receiver nil
|
||||
//@param c byte 待映射的ASCII码
|
||||
//@return idx int 以c映射出的分叉下标
|
||||
func getIdx(c byte) (idx int) {
|
||||
if c >= 'a' && c <= 'z' {
|
||||
idx = int(c - 'a')
|
||||
} else if c >= 'A' && c <= 'Z' {
|
||||
idx = int(c-'A') + 26
|
||||
} else if c >= '0' && c <= '9' {
|
||||
idx = int(c-'0') + 52
|
||||
} else if c == '+' {
|
||||
idx = 62
|
||||
} else if c == '/' {
|
||||
idx = 63
|
||||
} else {
|
||||
idx = -1
|
||||
}
|
||||
return idx
|
||||
}
|
||||
|
||||
//@title insert
|
||||
//@description
|
||||
// 以node单词查找树节点做接收者
|
||||
// 从n节点中继续插入以s为索引的元素e,且当前抵达的string位置为p
|
||||
// 当到达s终点时进行插入,如果此时node承载了元素则插入失败,否则成功
|
||||
// 当未到达终点时,根据当前抵达的位置去寻找其子结点继续遍历即可
|
||||
//@receiver n *node 接受者node的指针
|
||||
//@param s string 待插入元素的索引s
|
||||
//@param p int 索引当前抵达的位置
|
||||
//@param e interface{} 待插入元素e
|
||||
//@return b bool 是否插入成功?
|
||||
func (n *node) insert(s string, p int, e interface{}) (b bool) {
|
||||
if p == len(s) {
|
||||
if n.value != nil {
|
||||
return false
|
||||
}
|
||||
n.value = e
|
||||
n.num++
|
||||
return true
|
||||
}
|
||||
idx := getIdx(s[p])
|
||||
if idx == -1 {
|
||||
return false
|
||||
}
|
||||
if n.son[idx] == nil {
|
||||
n.son[idx] = newNode(nil)
|
||||
}
|
||||
b = n.son[idx].insert(s, p+1, e)
|
||||
if b {
|
||||
n.num++
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
//@title erase
|
||||
//@description
|
||||
// 以node单词查找树节点做接收者
|
||||
// 从n节点中继续删除以s为索引的元素e,且当前抵达的string位置为p
|
||||
// 当到达s终点时进行删除,如果此时node未承载元素则删除失败,否则成功
|
||||
// 当未到达终点时,根据当前抵达的位置去寻找其子结点继续遍历即可,若其分叉为nil则直接失败
|
||||
//@receiver n *node 接受者node的指针
|
||||
//@param s string 待删除元素的索引s
|
||||
//@param p int 索引当前抵达的位置
|
||||
//@return b bool 是否删除成功?
|
||||
func (n *node) erase(s string, p int) (b bool) {
|
||||
if p == len(s) {
|
||||
if n.value != nil {
|
||||
n.value = nil
|
||||
n.num--
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
idx := getIdx(s[p])
|
||||
if idx == -1 {
|
||||
return false
|
||||
}
|
||||
if n.son[idx] == nil {
|
||||
return false
|
||||
}
|
||||
b = n.son[idx].erase(s, p+1)
|
||||
if b {
|
||||
n.num--
|
||||
if n.son[idx].num == 0 {
|
||||
n.son[idx] = nil
|
||||
}
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
//@title count
|
||||
//@description
|
||||
// 以node单词查找树节点做接收者
|
||||
// 从n节点中继续查找以s为前缀索引的元素e,且当前抵达的string位置为p
|
||||
// 当到达s终点时返回其值即可
|
||||
// 当未到达终点时,根据当前抵达的位置去寻找其子结点继续遍历即可,当其分叉为nil则直接返回0
|
||||
//@receiver n *node 接受者node的指针
|
||||
//@param s string 待查找元素的前缀索引
|
||||
//@param p int 索引当前抵达的位置
|
||||
//@return num int 以该s为前缀的string的数量
|
||||
func (n *node) count(s string, p int) (num int) {
|
||||
if p == len(s) {
|
||||
return n.num
|
||||
}
|
||||
idx := getIdx(s[p])
|
||||
if idx == -1 {
|
||||
return 0
|
||||
}
|
||||
if n.son[idx] == nil {
|
||||
return 0
|
||||
}
|
||||
return n.son[idx].count(s, p+1)
|
||||
}
|
||||
|
||||
//@title find
|
||||
//@description
|
||||
// 以node单词查找树节点做接收者
|
||||
// 从n节点中继续查找以s为前缀索引的元素e,且当前抵达的string位置为p
|
||||
// 当到达s终点时返回其承载的元素即可
|
||||
// 当未到达终点时,根据当前抵达的位置去寻找其子结点继续遍历即可,当其分叉为nil则直接返回nil
|
||||
//@receiver n *node 接受者node的指针
|
||||
//@param s string 待查找元素的前缀索引
|
||||
//@param p int 索引当前抵达的位置
|
||||
//@return e interface{} 该索引所指向的元素e
|
||||
func (n *node) find(s string, p int) (e interface{}) {
|
||||
if p == len(s) {
|
||||
return n.value
|
||||
}
|
||||
idx := getIdx(s[p])
|
||||
if idx == -1 {
|
||||
return nil
|
||||
}
|
||||
if n.son[idx] == nil {
|
||||
return nil
|
||||
}
|
||||
return n.son[idx].find(s, p+1)
|
||||
}
|
||||
243
goSTL/data_structure/trie/trie.go
Normal file
243
goSTL/data_structure/trie/trie.go
Normal file
@ -0,0 +1,243 @@
|
||||
package trie
|
||||
|
||||
//@Title trie
|
||||
//@Description
|
||||
// 单词查找树-Trie
|
||||
// 以多叉树的形式实现,本次实现中有64叉,即a~z,A~Z,0~9,'+','/'共64个,对应base64的字符
|
||||
// 当存储的string中出现其他字符则无法存储
|
||||
// 存储的string可以携带一个元素
|
||||
// 结点不允许覆盖,即插入值已经存在时会插入失败,需要先删除原值
|
||||
// 使用互斥锁实现并发控制
|
||||
|
||||
import (
|
||||
"github.com/hlccd/goSTL/utils/iterator"
|
||||
"sync"
|
||||
)
|
||||
|
||||
//trie单词查找树结构体
|
||||
//该实例存储单词查找树的根节点
|
||||
//同时保存该树已经存储了多少个元素
|
||||
//整个树不允许重复插入,若出现重复插入则直接失败
|
||||
type trie struct {
|
||||
root *node //根节点指针
|
||||
size int //存放的元素数量
|
||||
mutex sync.Mutex //并发控制锁
|
||||
}
|
||||
|
||||
//trie单词查找树容器接口
|
||||
//存放了trie单词查找树可使用的函数
|
||||
//对应函数介绍见下方
|
||||
type trieer interface {
|
||||
Iterator() (i *Iterator.Iterator) //返回包含该trie的所有string
|
||||
Size() (num int) //返回该trie中保存的元素个数
|
||||
Clear() //清空该trie
|
||||
Empty() (b bool) //判断该trie是否为空
|
||||
Insert(s string, e interface{}) (b bool) //向trie中插入string并携带元素e
|
||||
Erase(s string) (b bool) //从trie中删除以s为索引的元素e
|
||||
Count(s string) (num int) //从trie中寻找以s为前缀的string单词数
|
||||
Find(s string) (e interface{}) //从trie中寻找以s为索引的元素e
|
||||
}
|
||||
|
||||
//@title New
|
||||
//@description
|
||||
// 新建一个trie单词查找树容器并返回
|
||||
// 初始根节点为nil
|
||||
//@receiver nil
|
||||
//@param nil
|
||||
//@return t *trie 新建的trie指针
|
||||
func New() (t *trie) {
|
||||
return &trie{
|
||||
root: newNode(nil),
|
||||
size: 0,
|
||||
mutex: sync.Mutex{},
|
||||
}
|
||||
}
|
||||
|
||||
//@title Iterator
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 将该trie中所有存放的string放入迭代器中并返回
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param nil
|
||||
//@return i *iterator.Iterator 新建的Iterator迭代器指针
|
||||
func (t *trie) Iterator() (i *Iterator.Iterator) {
|
||||
if t == nil {
|
||||
return nil
|
||||
}
|
||||
t.mutex.Lock()
|
||||
//找到trie中存在的所有string
|
||||
es := t.root.inOrder("")
|
||||
i = Iterator.New(&es)
|
||||
t.mutex.Unlock()
|
||||
return i
|
||||
}
|
||||
|
||||
//@title Size
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 返回该容器当前含有元素的数量
|
||||
// 如果容器为nil返回0
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param nil
|
||||
//@return num int 容器中实际使用元素所占空间大小
|
||||
func (t *trie) Size() (num int) {
|
||||
if t == nil {
|
||||
return 0
|
||||
}
|
||||
return t.size
|
||||
}
|
||||
|
||||
//@title Clear
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 将该容器中所承载的元素清空
|
||||
// 将该容器的size置0
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param nil
|
||||
//@return nil
|
||||
func (t *trie) Clear() {
|
||||
if t == nil {
|
||||
return
|
||||
}
|
||||
t.mutex.Lock()
|
||||
t.root = newNode(nil)
|
||||
t.size = 0
|
||||
t.mutex.Unlock()
|
||||
}
|
||||
|
||||
//@title Empty
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 判断该trie是否含有元素
|
||||
// 如果含有元素则不为空,返回false
|
||||
// 如果不含有元素则说明为空,返回true
|
||||
// 如果容器不存在,返回true
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param nil
|
||||
//@return b bool 该容器是空的吗?
|
||||
func (t *trie) Empty() (b bool) {
|
||||
if t.Size() > 0 {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
//@title Insert
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 向trie插入以string类型的s为索引的元素e
|
||||
// 若存在重复的s则插入失败,不允许覆盖
|
||||
// 否则插入成功
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param s string 待插入元素的索引s
|
||||
//@param e interface{} 待插入元素e
|
||||
//@return b bool 添加成功?
|
||||
func (t *trie) Insert(s string, e interface{}) (b bool) {
|
||||
if t == nil {
|
||||
return
|
||||
}
|
||||
if len(s) == 0 {
|
||||
return false
|
||||
}
|
||||
t.mutex.Lock()
|
||||
if t.root == nil {
|
||||
//避免根节点为nil
|
||||
t.root = newNode(nil)
|
||||
}
|
||||
//从根节点开始插入
|
||||
b = t.root.insert(s, 0, e)
|
||||
if b {
|
||||
//插入成功,size+1
|
||||
t.size++
|
||||
}
|
||||
t.mutex.Unlock()
|
||||
return b
|
||||
}
|
||||
|
||||
//@title Erase
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 从trie树中删除元素以s为索引的元素e
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param s string 待删除元素的索引
|
||||
//@return b bool 删除成功?
|
||||
func (t *trie) Erase(s string) (b bool) {
|
||||
if t == nil {
|
||||
return false
|
||||
}
|
||||
if t.Empty() {
|
||||
return false
|
||||
}
|
||||
if len(s) == 0 {
|
||||
//长度为0无法删除
|
||||
return false
|
||||
}
|
||||
if t.root == nil {
|
||||
//根节点为nil即无法删除
|
||||
return false
|
||||
}
|
||||
t.mutex.Lock()
|
||||
//从根节点开始删除
|
||||
b = t.root.erase(s, 0)
|
||||
if b {
|
||||
//删除成功,size-1
|
||||
t.size--
|
||||
if t.size == 0 {
|
||||
//所有string都被删除,根节点置为nil
|
||||
t.root = nil
|
||||
}
|
||||
}
|
||||
t.mutex.Unlock()
|
||||
return b
|
||||
}
|
||||
|
||||
//@title Count
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 从trie中查找以s为前缀的所有string的个数
|
||||
// 如果存在以s为前缀的则返回大于0的值即其数量
|
||||
// 如果未找到则返回0
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param s string 待查找的前缀s
|
||||
//@return num int 待查找前缀在trie中存在的数量
|
||||
func (t *trie) Count(s string) (num int) {
|
||||
if t == nil {
|
||||
return 0
|
||||
}
|
||||
if t.Empty() {
|
||||
return 0
|
||||
}
|
||||
if t.root == nil {
|
||||
return 0
|
||||
}
|
||||
t.mutex.Lock()
|
||||
//统计所有以s为前缀的string的数量并返回
|
||||
num = int(t.root.count(s, 0))
|
||||
t.mutex.Unlock()
|
||||
return num
|
||||
}
|
||||
|
||||
//@title Find
|
||||
//@description
|
||||
// 以trie单词查找树做接收者
|
||||
// 从trie中查找以s为索引的元素e,找到则返回e
|
||||
// 如果未找到则返回nil
|
||||
//@receiver t *trie 接受者trie的指针
|
||||
//@param s string 待查找索引s
|
||||
//@return ans interface{} 待查找索引所指向的元素
|
||||
func (t *trie) Find(s string) (e interface{}) {
|
||||
if t == nil {
|
||||
return nil
|
||||
}
|
||||
if t.Empty() {
|
||||
return nil
|
||||
}
|
||||
if t.root == nil {
|
||||
return nil
|
||||
}
|
||||
t.mutex.Lock()
|
||||
//从根节点开始查找以s为索引的元素e
|
||||
e = t.root.find(s, 0)
|
||||
t.mutex.Unlock()
|
||||
return e
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user