binary search tree
This commit is contained in:
parent
d4cbad40c3
commit
fcd2f9b99a
3 changed files with 743 additions and 0 deletions
389
searching/binary_search_tree.go
Normal file
389
searching/binary_search_tree.go
Normal file
|
|
@ -0,0 +1,389 @@
|
|||
package searching
|
||||
|
||||
import "github.com/fotonmoton/algorithms/fundamentals/queue"
|
||||
|
||||
type bstNode[K any, V any] struct {
|
||||
left *bstNode[K, V]
|
||||
right *bstNode[K, V]
|
||||
key K
|
||||
val V
|
||||
n int64
|
||||
}
|
||||
|
||||
// TODO: maybe pass pointers for recursive funcs?
|
||||
type bst[K any, V any] struct {
|
||||
root *bstNode[K, V]
|
||||
cmp func(*K, *K) int
|
||||
}
|
||||
|
||||
func NewBST[K any, V any](cmp func(*K, *K) int) SymbolTable[K, V] {
|
||||
return &bst[K, V]{nil, cmp}
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Put(key K, val V) {
|
||||
t.root = t.put(key, val, t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) put(key K, val V, node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node == nil {
|
||||
return &bstNode[K, V]{nil, nil, key, val, 1}
|
||||
}
|
||||
|
||||
cmp := t.cmp(&key, &node.key)
|
||||
|
||||
if cmp < 0 {
|
||||
node.left = t.put(key, val, node.left)
|
||||
}
|
||||
|
||||
if cmp == 0 {
|
||||
node.val = val
|
||||
}
|
||||
|
||||
if cmp > 0 {
|
||||
node.right = t.put(key, val, node.right)
|
||||
}
|
||||
|
||||
node.n = t.size(node.left) + t.size(node.right) + 1
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Get(key K) *V {
|
||||
return t.get(key, t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) get(key K, node *bstNode[K, V]) *V {
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
cmp := t.cmp(&key, &node.key)
|
||||
|
||||
if cmp < 0 {
|
||||
return t.get(key, node.left)
|
||||
}
|
||||
|
||||
if cmp > 0 {
|
||||
return t.get(key, node.right)
|
||||
}
|
||||
|
||||
return &node.val
|
||||
}
|
||||
|
||||
func (t *bst[_, __]) Size() int64 {
|
||||
return t.size(t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) size(node *bstNode[K, V]) int64 {
|
||||
if node == nil {
|
||||
return 0
|
||||
}
|
||||
|
||||
return node.n
|
||||
}
|
||||
|
||||
func (t *bst[K, _]) Min() *K {
|
||||
if t.root == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &t.min(t.root).key
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) min(node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node.left == nil {
|
||||
return node
|
||||
}
|
||||
|
||||
return t.min(node.left)
|
||||
}
|
||||
|
||||
func (t *bst[K, _]) Max() *K {
|
||||
if t.root == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &t.max(t.root).key
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) max(node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node.right == nil {
|
||||
return node
|
||||
}
|
||||
|
||||
return t.max(node.right)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Floor(key K) *K {
|
||||
largest := t.floor(key, t.root)
|
||||
|
||||
if largest == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &largest.key
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) floor(key K, node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
cmp := t.cmp(&key, &node.key)
|
||||
|
||||
if cmp == 0 {
|
||||
return node
|
||||
}
|
||||
|
||||
if cmp < 0 {
|
||||
return t.floor(key, node.left)
|
||||
}
|
||||
|
||||
larger := t.floor(key, node.right)
|
||||
|
||||
if larger != nil {
|
||||
return larger
|
||||
}
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Ceiling(key K) *K {
|
||||
smallest := t.ceiling(key, t.root)
|
||||
|
||||
if smallest == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &smallest.key
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) ceiling(key K, node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
cmp := t.cmp(&key, &node.key)
|
||||
|
||||
if cmp == 0 {
|
||||
return node
|
||||
}
|
||||
|
||||
if cmp > 0 {
|
||||
return t.ceiling(key, node.right)
|
||||
}
|
||||
|
||||
smaller := t.ceiling(key, node.left)
|
||||
|
||||
if smaller != nil {
|
||||
return smaller
|
||||
}
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Rank(key K) int64 {
|
||||
return t.rank(key, t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) rank(key K, node *bstNode[K, V]) int64 {
|
||||
if node == nil {
|
||||
return 0
|
||||
}
|
||||
|
||||
cmp := t.cmp(&key, &node.key)
|
||||
|
||||
// If we found key in a tree then left subtree
|
||||
// will always contain keys less than current node key
|
||||
// and right subtree will always ontain greater keys (by BST definition).
|
||||
// So we simply return left subtree size
|
||||
if cmp == 0 {
|
||||
return t.size(node.left)
|
||||
}
|
||||
|
||||
// If current node key is bigger than key for which rank is searched
|
||||
// we should descend deeper in left subtree
|
||||
if cmp < 0 {
|
||||
return t.rank(key, node.left)
|
||||
}
|
||||
|
||||
// If we found node with key that is less than search key
|
||||
// we get the size of the left subtree, add 1 to count current node in
|
||||
// rank value and descend deeper in right subtree.
|
||||
return 1 + t.size(node.left) + t.rank(key, node.right)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) KeyByRank(i int64) *K {
|
||||
node := t.keyByRank(i, t.root)
|
||||
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &node.key
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) keyByRank(rank int64, node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// We need left subtree size to substract it from our index
|
||||
// when we descend deeper in right subtree
|
||||
leftSize := t.size(node.left)
|
||||
|
||||
if rank < leftSize {
|
||||
return t.keyByRank(rank, node.left)
|
||||
}
|
||||
|
||||
if rank > leftSize {
|
||||
// We subtract left size subtree
|
||||
return t.keyByRank(rank-leftSize-1, node.right)
|
||||
}
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Contains(key K) bool {
|
||||
return t.Get(key) == nil
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) IsEmpty() bool {
|
||||
return t.Size() == 0
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) DeleteMin() {
|
||||
|
||||
if t.root == nil {
|
||||
return
|
||||
}
|
||||
|
||||
t.root = t.deleteMin(t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) deleteMin(node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node.left == nil {
|
||||
return node.right
|
||||
}
|
||||
|
||||
node.left = t.deleteMin(node.left)
|
||||
node.n = t.size(node.left) + t.size(node.right) + 1
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) DeleteMax() {
|
||||
|
||||
if t.root == nil {
|
||||
return
|
||||
}
|
||||
|
||||
t.root = t.deleteMax(t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) deleteMax(node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node.right == nil {
|
||||
return node.left
|
||||
}
|
||||
|
||||
node.right = t.deleteMax(node.right)
|
||||
node.n = t.size(node.left) + t.size(node.right) + 1
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Delete(key K) {
|
||||
t.root = t.delete(key, t.root)
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) delete(key K, node *bstNode[K, V]) *bstNode[K, V] {
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
cmp := t.cmp(&key, &node.key)
|
||||
|
||||
if cmp < 0 {
|
||||
node.left = t.delete(key, node.left)
|
||||
} else if cmp > 0 {
|
||||
node.right = t.delete(key, node.right)
|
||||
} else {
|
||||
|
||||
// Shortcut: we can return left or right subtree if we have only one of them
|
||||
// without size recalculation and pointers juggling
|
||||
if node.right == nil {
|
||||
return node.left
|
||||
}
|
||||
if node.left == nil {
|
||||
return node.right
|
||||
}
|
||||
|
||||
// Needed to delete "min" node in right subtree
|
||||
tmp := node
|
||||
// We substitute current node with "min" node from right subtree.
|
||||
// When "node" variable will be returned to the caller "tmp" node
|
||||
// will be erased by "node" value and be marked for garbage collection.
|
||||
// At least it should work as described
|
||||
node = t.min(tmp.right)
|
||||
// We prevent "node" duplication in the tree by deleting it from right subtree
|
||||
node.right = t.deleteMin(tmp.right)
|
||||
// Left subtree stays unchanged
|
||||
node.left = tmp.left
|
||||
}
|
||||
node.n = t.size(node.left) + t.size(node.right) + 1
|
||||
return node
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) KeysBetween(lo, hi K) []K {
|
||||
q := queue.NewQueue[K]()
|
||||
t.keysBetween(lo, hi, t.root, q)
|
||||
keys := make([]K, 0, q.Size())
|
||||
|
||||
for !q.IsEmpty() {
|
||||
keys = append(keys, q.Dequeue())
|
||||
}
|
||||
|
||||
return keys
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) keysBetween(lo, hi K, node *bstNode[K, V], q queue.Queue[K]) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
cmplo := t.cmp(&lo, &node.key)
|
||||
cmphi := t.cmp(&hi, &node.key)
|
||||
|
||||
if cmplo < 0 {
|
||||
t.keysBetween(lo, hi, node.left, q)
|
||||
}
|
||||
|
||||
if cmplo <= 0 && cmphi >= 0 {
|
||||
q.Enqueue(node.key)
|
||||
}
|
||||
|
||||
if cmphi > 0 {
|
||||
t.keysBetween(lo, hi, node.right, q)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) Keys() []K {
|
||||
if t.IsEmpty() {
|
||||
return []K{}
|
||||
}
|
||||
|
||||
q := queue.NewQueue[K]()
|
||||
t.keysBetween(*t.Min(), *t.Max(), t.root, q)
|
||||
keys := make([]K, 0, q.Size())
|
||||
|
||||
for !q.IsEmpty() {
|
||||
keys = append(keys, q.Dequeue())
|
||||
}
|
||||
|
||||
return keys
|
||||
}
|
||||
|
||||
func (t *bst[K, V]) SizeBetween(lo K, hi K) int64 {
|
||||
q := queue.NewQueue[K]()
|
||||
t.keysBetween(lo, hi, t.root, q)
|
||||
|
||||
return int64(q.Size())
|
||||
}
|
||||
331
searching/binary_search_tree_test.go
Normal file
331
searching/binary_search_tree_test.go
Normal file
|
|
@ -0,0 +1,331 @@
|
|||
package searching
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func intCompare(a, b *int) int {
|
||||
if *a < *b {
|
||||
return -1
|
||||
}
|
||||
|
||||
if *a > *b {
|
||||
return 1
|
||||
}
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
func TestPut(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
table.Put(1, 10)
|
||||
table.Put(2, 20)
|
||||
|
||||
assert.Equal(t, 10, *table.Get(1))
|
||||
assert.Equal(t, 20, *table.Get(2))
|
||||
|
||||
// rewrite
|
||||
table.Put(1, 11)
|
||||
|
||||
assert.Equal(t, 11, *table.Get(1))
|
||||
assert.Equal(t, 20, *table.Get(2))
|
||||
assert.Equal(t, int64(2), table.Size())
|
||||
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestGet(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Nil(t, table.Get(0))
|
||||
|
||||
table.Put(1, 2)
|
||||
|
||||
assert.Equal(t, 2, *table.Get(1))
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestSize(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Equal(t, int64(0), table.Size())
|
||||
|
||||
table.Put(1, 1)
|
||||
|
||||
assert.Equal(t, int64(1), table.Size())
|
||||
|
||||
table.Put(2, 2)
|
||||
|
||||
assert.Equal(t, int64(2), table.Size())
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestMin(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Nil(t, table.Min())
|
||||
|
||||
table.Put(3, 3)
|
||||
|
||||
assert.Equal(t, 3, *table.Min())
|
||||
|
||||
table.Put(2, 2)
|
||||
|
||||
assert.Equal(t, 2, *table.Min())
|
||||
|
||||
table.Put(4, 4)
|
||||
|
||||
assert.Equal(t, 2, *table.Min())
|
||||
|
||||
table.Put(1, 1)
|
||||
|
||||
assert.Equal(t, 1, *table.Min())
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestMax(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Nil(t, table.Max())
|
||||
|
||||
table.Put(1, 1)
|
||||
assert.Equal(t, 1, *table.Max())
|
||||
|
||||
table.Put(2, 2)
|
||||
assert.Equal(t, 2, *table.Max())
|
||||
|
||||
table.Put(5, 5)
|
||||
assert.Equal(t, 5, *table.Max())
|
||||
|
||||
table.Put(4, 4)
|
||||
assert.Equal(t, 5, *table.Max())
|
||||
|
||||
table.Put(3, 3)
|
||||
assert.Equal(t, 5, *table.Max())
|
||||
|
||||
table.Put(5, 55)
|
||||
assert.Equal(t, 5, *table.Max())
|
||||
|
||||
table.Put(6, 6)
|
||||
assert.Equal(t, 6, *table.Max())
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestFloor(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Nil(t, table.Floor(0))
|
||||
|
||||
table.Put(1, 1)
|
||||
assert.Equal(t, 1, *table.Floor(1))
|
||||
|
||||
table.Put(5, 5)
|
||||
assert.Equal(t, 5, *table.Floor(5))
|
||||
assert.Equal(t, 1, *table.Floor(4))
|
||||
|
||||
table.Put(4, 4)
|
||||
assert.Equal(t, 5, *table.Floor(5))
|
||||
assert.Equal(t, 4, *table.Floor(4))
|
||||
assert.Equal(t, 1, *table.Floor(3))
|
||||
assert.Nil(t, table.Floor(0))
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestCeiling(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Nil(t, table.Ceiling(0))
|
||||
|
||||
table.Put(5, 5)
|
||||
assert.Equal(t, 5, *table.Ceiling(5))
|
||||
|
||||
table.Put(4, 4)
|
||||
assert.Equal(t, 4, *table.Ceiling(0))
|
||||
assert.Equal(t, 5, *table.Ceiling(5))
|
||||
|
||||
table.Put(3, 3)
|
||||
assert.Equal(t, 3, *table.Ceiling(0))
|
||||
assert.Equal(t, 3, *table.Ceiling(1))
|
||||
assert.Equal(t, 3, *table.Ceiling(3))
|
||||
assert.Equal(t, 4, *table.Ceiling(4))
|
||||
assert.Equal(t, 5, *table.Ceiling(5))
|
||||
assert.Nil(t, table.Ceiling(6))
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestRank(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Equal(t, int64(0), table.Rank(1))
|
||||
|
||||
table.Put(0, 0)
|
||||
assert.Equal(t, int64(1), table.Rank(1))
|
||||
|
||||
table.Put(1, 1)
|
||||
assert.Equal(t, int64(2), table.Rank(2))
|
||||
|
||||
table.Put(4, 4)
|
||||
assert.Equal(t, int64(2), table.Rank(2))
|
||||
assert.Equal(t, int64(2), table.Rank(3))
|
||||
assert.Equal(t, int64(3), table.Rank(5))
|
||||
|
||||
table.Put(2, 2)
|
||||
assert.Equal(t, int64(2), table.Rank(2))
|
||||
assert.Equal(t, int64(3), table.Rank(3))
|
||||
assert.Equal(t, int64(4), table.Rank(5))
|
||||
|
||||
table.Put(3, 3)
|
||||
assert.Equal(t, int64(2), table.Rank(2))
|
||||
assert.Equal(t, int64(3), table.Rank(3))
|
||||
assert.Equal(t, int64(4), table.Rank(4))
|
||||
assert.Equal(t, int64(5), table.Rank(5))
|
||||
}
|
||||
|
||||
// TODO: test with delete
|
||||
func TestKeyByRank(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.Nil(t, table.KeyByRank(1))
|
||||
|
||||
table.Put(0, 0)
|
||||
assert.Nil(t, table.KeyByRank(1))
|
||||
assert.Equal(t, 0, *table.KeyByRank(table.Rank(0)))
|
||||
|
||||
table.Put(5, 5)
|
||||
assert.Equal(t, 5, *table.KeyByRank(table.Rank(5)))
|
||||
assert.EqualValues(t, 1, table.Rank(*table.KeyByRank(1)))
|
||||
}
|
||||
|
||||
func TestDeleteMin(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
table.DeleteMin()
|
||||
|
||||
table.Put(0, 0)
|
||||
assert.EqualValues(t, 1, table.Size())
|
||||
|
||||
table.DeleteMin()
|
||||
assert.EqualValues(t, 0, table.Size())
|
||||
|
||||
table.Put(5, 5)
|
||||
table.Put(0, 0)
|
||||
table.Put(1, 1)
|
||||
table.Put(2, 2)
|
||||
|
||||
assert.Equal(t, 0, *table.Get(0))
|
||||
|
||||
table.DeleteMin()
|
||||
|
||||
assert.Nil(t, table.Get(0))
|
||||
assert.EqualValues(t, 3, table.Size())
|
||||
}
|
||||
|
||||
func TestDeleteMax(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
table.DeleteMin()
|
||||
|
||||
table.Put(0, 0)
|
||||
assert.EqualValues(t, 1, table.Size())
|
||||
|
||||
table.DeleteMax()
|
||||
assert.EqualValues(t, 0, table.Size())
|
||||
|
||||
table.Put(0, 0)
|
||||
table.Put(5, 5)
|
||||
table.Put(1, 1)
|
||||
table.Put(2, 2)
|
||||
|
||||
assert.Equal(t, 5, *table.Get(5))
|
||||
|
||||
table.DeleteMax()
|
||||
|
||||
assert.Nil(t, table.Get(5))
|
||||
assert.EqualValues(t, 3, table.Size())
|
||||
}
|
||||
|
||||
// TODO: add more cases
|
||||
func TestDelete(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
table.Delete(0)
|
||||
|
||||
table.Put(0, 0)
|
||||
|
||||
table.Delete(0)
|
||||
assert.EqualValues(t, 0, table.Size())
|
||||
assert.Nil(t, table.Get(0))
|
||||
|
||||
table.Put(0, 0)
|
||||
table.Put(5, 5)
|
||||
table.Put(1, 1)
|
||||
table.Put(2, 2)
|
||||
|
||||
assert.Equal(t, 1, *table.Get(1))
|
||||
|
||||
table.Delete(1)
|
||||
assert.Nil(t, table.Get(1))
|
||||
assert.EqualValues(t, 3, table.Size())
|
||||
|
||||
table.Delete(2)
|
||||
table.Delete(5)
|
||||
table.Delete(0)
|
||||
assert.EqualValues(t, 0, table.Size())
|
||||
}
|
||||
|
||||
func TestKeysBetween(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.EqualValues(t, []int{}, table.KeysBetween(0, 10))
|
||||
|
||||
table.Put(1, 1)
|
||||
|
||||
assert.EqualValues(t, []int{}, table.KeysBetween(2, 10))
|
||||
assert.EqualValues(t, []int{1}, table.KeysBetween(1, 1))
|
||||
|
||||
table.Put(2, 2)
|
||||
table.Put(5, 5)
|
||||
|
||||
assert.EqualValues(t, []int{5}, table.KeysBetween(3, 10))
|
||||
assert.EqualValues(t, []int{1, 2, 5}, table.KeysBetween(1, 5))
|
||||
}
|
||||
|
||||
func TestKeys(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.EqualValues(t, []int{}, table.Keys())
|
||||
|
||||
table.Put(1, 1)
|
||||
|
||||
assert.EqualValues(t, []int{1}, table.Keys())
|
||||
|
||||
table.Put(2, 2)
|
||||
table.Put(5, 5)
|
||||
|
||||
assert.EqualValues(t, []int{1, 2, 5}, table.Keys())
|
||||
|
||||
table.Delete(2)
|
||||
|
||||
assert.EqualValues(t, []int{1, 5}, table.Keys())
|
||||
|
||||
}
|
||||
|
||||
func TestSizeBetween(t *testing.T) {
|
||||
table := NewBST[int, int](intCompare)
|
||||
|
||||
assert.EqualValues(t, 0, table.SizeBetween(0, 10))
|
||||
|
||||
table.Put(1, 1)
|
||||
|
||||
assert.EqualValues(t, 0, table.SizeBetween(2, 10))
|
||||
assert.EqualValues(t, 1, table.SizeBetween(1, 1))
|
||||
|
||||
table.Put(2, 2)
|
||||
table.Put(5, 5)
|
||||
|
||||
assert.EqualValues(t, 1, table.SizeBetween(3, 10))
|
||||
assert.EqualValues(t, 3, table.SizeBetween(1, 5))
|
||||
}
|
||||
23
searching/symbol_table.go
Normal file
23
searching/symbol_table.go
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
package searching
|
||||
|
||||
// TODO: think about pointer semantics: where pointers should be used?
|
||||
// Does go compiler silently convert values to pointers when they are leave table?
|
||||
type SymbolTable[K any, V any] interface {
|
||||
Put(K, V) // add value V with associated key K to symbol table
|
||||
Get(K) *V // get value V with associated key K to symbol table, nil if value is absent
|
||||
Size() int64 // number of key-value pairs
|
||||
Min() *K // smallest key
|
||||
Max() *K // largest key
|
||||
Floor(K) *K // largest key less than or equal to K
|
||||
Ceiling(K) *K // smallest key greater or equal to K
|
||||
Rank(K) int64 // number of keys less than K. Rank(*Index(in)) = in
|
||||
KeyByRank(int64) *K // key of specified rank. *Index(Rank(K)) = K
|
||||
Contains(K) bool // check if key K exists in symbol table
|
||||
IsEmpty() bool // check if symbol table is empty
|
||||
DeleteMin() // delete value with smallest key
|
||||
DeleteMax() // delete value with largest key
|
||||
Delete(K) // delete value associated with key K.
|
||||
KeysBetween(K, K) []K // keys between two other keys in sorted order
|
||||
Keys() []K // all existing keys in sorted order
|
||||
SizeBetween(K, K) int64 // number of keys between two keys
|
||||
}
|
||||
Loading…
Reference in a new issue