无序链表（顺序查找）符号表

参考书籍
算法（第四版）Robert Sedgewick Kevin Wayne

该代码是基于泛型实现
键不允许为零，必须是可比较的。
值不允许为零值，因为我们在获取值不到元素时，会返回零值

实现文件

sequentialSearchST

package symbolTable

import (
	"errors"
	"reflect"
)

var (
	nullError = errors.New("key is null")
)

type Node[KEY any, VALUE any] struct {
	key   KEY
	value VALUE
	next  *Node[KEY, VALUE]
}

func NewNode[KEY any, VALUE any](key KEY, value VALUE, node *Node[KEY, VALUE]) *Node[KEY, VALUE] {
	return &Node[KEY, VALUE]{key: key, value: value, next: node}
}

// 顺序查找，基于无序链表
type SequentialSearchST[KEY comparable, VALUE any] struct {
	first *Node[KEY, VALUE]
	key   KEY
	value VALUE
	//compare Comparer[KEY]
	n int
}

func (s *SequentialSearchST[KEY, VALUE]) equals(key1, key2 KEY) bool {
	return key1 == key2
}

func NewSequentialSearchST[KEY comparable, VALUE any]() *SequentialSearchST[KEY, VALUE] {
	return &SequentialSearchST[KEY, VALUE]{}
}

func (s *SequentialSearchST[KEY, VALUE]) Get(key KEY) (val VALUE, error error) {

	if reflect.ValueOf(key).IsZero() {
		return val, nullError
	}

	for x := s.first; x != nil; x = x.next {
		if s.equals(x.key, key) {
			return x.value, nil
		}
	}

	return val, nil
}

func (s *SequentialSearchST[KEY, VALUE]) Put(key KEY, value VALUE) error {
	if reflect.ValueOf(key).IsZero() {
		return nullError
	}
	if reflect.ValueOf(value).IsZero() {
		return s.Delete(key)
	}
	//查找给定的健，找到则更新其值，否则在表中新建节点
	for x := s.first; x != nil; x = x.next {
		if s.equals(x.key, key) {
			x.value = value
			return nil
		}
	}
	s.first = NewNode(key, value, s.first)
	s.n++
	return nil
}

func (s *SequentialSearchST[KEY, VALUE]) Delete(key KEY) (err error) {
	if reflect.ValueOf(key).IsZero() {
		return nullError
	}
	s.first = s.delete(s.first, key)
	return nil
}

func (s *SequentialSearchST[KEY, VALUE]) delete(node *Node[KEY, VALUE], key KEY) (res *Node[KEY, VALUE]) {

	if reflect.ValueOf(key).IsZero() {
		return
	}

	if reflect.ValueOf(node).IsZero() {
		return
	}

	if s.equals(node.key, key) {
		res = node.next
		s.n--
		return node.next
	}

	node.next = s.delete(node.next, key)
	return
}

func (s *SequentialSearchST[KEY, VALUE]) Keys() []KEY {
	keys := make([]KEY, s.Size())
	for x := s.first; x != nil; x = x.next {
		keys = append(keys, x.key)
	}
	return keys
}

func (s *SequentialSearchST[KEY, VALUE]) Size() int {
	return s.n
}

func (s *SequentialSearchST[KEY, VALUE]) IsEmpty() bool {
	return s.Size() == 0
}

func (s *SequentialSearchST[KEY, VALUE]) Contains(key KEY) bool {
	if reflect.ValueOf(key).IsZero() {
		return false
	}
	var v VALUE
	v, err := s.Get(key)
	if err != nil {
		return false
	}
	if reflect.ValueOf(v).IsZero() {
		return false
	}

	return true
}

测试文件

sequentialSearchST_test.go

package symbolTable

import (
	"fmt"
	"strconv"
	"testing"
)

func TestNewSequentialSearchST(t *testing.T) {
	st := NewSequentialSearchST[string, int]()

	if st.IsEmpty() != true {
		fmt.Println("Expected true, but got false")
	}

	for i := 0; i < 10; i++ {
		st.Put(strconv.Itoa(i+1), i+1)
	}

	if st.Size() != 10 {
		t.Errorf("Expected 10, but got %d", st.Size())
	}

	get, err := st.Get("1")
	if err != nil {
		t.Fatal(err)
	}
	if get != 1 {
		t.Errorf("Expected 1, but got %d", get)
	}

	get, err = st.Get("100")
	if err != nil {
		t.Fatal(err)
	}
	if get != 0 {
		t.Errorf("Expected 0, but got %d", get)
	}

	get, err = st.Get("")
	if err == nil {
		t.Fatal("Expected error, but got nil")
	}
	if get != 0 {
		t.Errorf("Expected 0, but got %d", get)
	}

	err = st.Delete("1")
	get, err = st.Get("100")
	if err != nil {
		t.Fatal(err)
	}
	if get != 0 {
		t.Errorf("Expected 0, but got %d", get)
	}

	if st.IsEmpty() == true {
		t.Errorf("Expected false, but got true")
	}

	st.Put("6", 66)
	if v, _ := st.Get("6"); v != 66 {
		t.Errorf("Expected 66, but got %d", v)
	}

	err = st.Delete("6")
	if err != nil {
		t.Fatal(err)
	}

	err = st.Delete("0")
	if err != nil {
		t.Fatal(err)
	}
}