Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/viant/ptrie
A prefix tree implementation in go
https://github.com/viant/ptrie
prefix-tree trie
Last synced: 4 days ago
JSON representation
A prefix tree implementation in go
- Host: GitHub
- URL: https://github.com/viant/ptrie
- Owner: viant
- License: apache-2.0
- Created: 2019-05-20T14:13:05.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-04-05T16:12:12.000Z (9 months ago)
- Last Synced: 2024-07-31T20:48:39.297Z (6 months ago)
- Topics: prefix-tree, trie
- Language: Go
- Size: 67.4 KB
- Stars: 39
- Watchers: 9
- Forks: 11
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
- awesome-go - ptrie - An implementation of prefix tree. (Data Structures and Algorithms / Text Analysis)
- awesome-go - ptrie - An implementation of prefix tree. (Data Structures and Algorithms / Text Analysis)
- awesome-go-extra - ptrie - 05-20T14:13:05Z|2022-03-26T15:03:21Z| (Generators / Text Analysis)
README
# Trie (Prefix tree)
[](https://goreportcard.com/report/github.com/viant/ptrie)
[](https://godoc.org/github.com/viant/ptrie)
This library is compatible with Go 1.11+
Please refer to [`CHANGELOG.md`](CHANGELOG.md) if you encounter breaking changes.
- [Motivation](#motivation)
- [Introduction](#introduction)
- [Usage](#usage)
- [Benchmark](#benchmark)
## Motivation
The goal of this project is to provide serverless prefix tree friendly implementation.
where one function can easily building tree and publishing to some cloud storge.
Then the second load trie to perform various operations.
## Introduction
A trie (prefix tree) is a space-optimized tree data structure in which each node that is merged with its parent.
Unlike regular trees (where whole keys are from their beginning up to the point of inequality), the key at each node is compared chunk by chunk,
Prefix tree has the following application:
- text document searching
- rule based matching
- constructing associative arrays for string keys
Character comparision complexity:
* **Brute Force:** _O(d n k)_
* **Prefix Trie**: _O(d log(k))_
Where
- d: number of characters in document
- n: number of keywords
- k: average keyword length
### Usage
```go
trie := ptrie.New()
for key, value := range pairs {
if err = trie.Put(key, value); err != nil {
log.Fatal(err)
}
}
//...
has := trie.Has(key)
value, has := trie.Get(key)
//...
matched := trie.MatchAll(input, func(key []byte, value interface{}) bool {
fmt.Printf("matched: key: %s, value %v\n", key, value)
return true
})
```
1. Building
```go
trie := ptrie.New()
for key, value := range pairs {
if err = trie.Put(key, value); err != nil {
log.Fatal(err)
}
}
writer := new(bytes.Buffer)
if err := trie.Encode(writer); err != nil {
log.Fatal(err)
}
encoded := write.Bytes()
//write encode data
```
2. Loading
```go
//V type can be any type
var v *V
trie := ptrie.New()
trie.UseType(reflect.TypeOf(v))
if err := trie.Decode(reader); err != nil {
log.Fatal(err)
}
```
3. Traversing (range map)
```go
trie.Walk(func(key []byte, value interface{}) bool {
fmt.Printf("key: %s, value %v\n", key, value)
return true
})
```
4. Lookup
```go
has := trie.Has(key)
value, has := trie.Get(key)
```
5. MatchPrefix
```go
var input []byte
...
matched := trie.MatchPrefix(input, func(key []byte, value interface{}) bool {
fmt.Printf("matched: key: %s, value %v\n", key, value)
return true
})
```
6. MatchAll
```go
var input []byte
...
matched := trie.MatchAll(input, func(key []byte, value interface{}) bool {
fmt.Printf("matched: key: %s, value %v\n", key, value)
return true
})
```
#### Benchmark
The benchmark count all words that are part of the following extracts:
**[Lorem Ipsum](test/lorem.txt)**
1. Short: avg line size: 20, words: 13
2. Long: avg line size: 711, words: 551
```bash
Benchmark_LoremBruteForceShort-8 500000 3646 ns/op
Benchmark_LoremTrieShort-8 500000 2376 ns/op
Benchmark_LoremBruteForceLong-8 1000 1612877 ns/op
Benchmark_LoremTrieLong-8 10000 119990 ns/op
```
**[Hamlet](test/hamlet.txt)**
1. Short: avg line size: 20, words: 49
2. Long: avg line size: 41, words: 105
```bash
Benchmark_HamletBruteForceShort-8 30000 44306 ns/op
Benchmark_HamletTrieShort-8 100000 18530 ns/op
Benchmark_HamletBruteForceLong-8 10000 226836 ns/op
Benchmark_HamletTrieLong-8 50000 39329 ns/op
```
##### Code coverage
[](https://gocover.io/github.com/viant/ptrie)
The source code is made available under the terms of the Apache License, Version 2, as stated in the file `LICENSE`.
Individual files may be made available under their own specific license,
all compatible with Apache License, Version 2. Please see individual files for details.
## Credits and Acknowledgements
**Library Author:** Adrian Witas