add trie st

Author: shellfly

README.md

@@ -19,14 +19,11 @@ To test each algorithm(data structure), instead of running the file directly, yo
 ## Index
 
 * 1 FUNDAMENTALS
-
   * [Bag](algs4/bag.go)
   * [Queue](algs4/queue.go)
   * [Stack](algs4/stack.go)
   * [UnionFind](algs4/uf.go)
-
 * 2 SORTING
-
   * [Selection](algs4/selection.go)
   * [Insertion](algs4/insertion.go)
   * [Shell](algs4/shell.go)
@@ -38,17 +35,14 @@ To test each algorithm(data structure), instead of running the file directly, yo
   * [IndexMinPQ](algs4/index_min_pq.go)
   * [Multiway](algs4/cmd/multiway/main.go)
   * [Heap](algs4/heap.go)
-
 * 3 SEARCHING
-
   * [FrequencyCounter](algs4/cmd/frequency-counter/main.go)
   * [SequentialSearchST](algs4/sequential_search.go)
   * [BinarySearchST](algs4/binary_search_st.go)
   * [BST](algs4/bst.go)
   * [RedBlackBST](algs4/red_black_bst.go)
   * [SeparateChainingHashST](algs4/separate_chaining_hash_st.go)
   * [LinearProbingHashST](algs4/linear_probing_hash_st.go)
-
 * 4 GRAPHS
   * Graph
     * [Graph](algs4/graph.go)
@@ -77,12 +71,11 @@ To test each algorithm(data structure), instead of running the file directly, yo
     * [DijkstraSP](algs4/dijkstra_sp.go)
     * [AcyclicSP](algs4/acyclic_sp.go)
     * [BellmanFordSP](algs4/bellman_ford_sp.go)
-
-
 * 5 STRING
-
   * [LSD](algs4/lsd.go)
   * [MSD](algs4/msd.go)
+  * [Quick3string](algs4/quick3_string.go)
+  * [TrieST](trie_st.go)
 
 
 ## License

algs4/quick3_string.go

@@ -0,0 +1,55 @@
+package algs4
+
+// Quick3String ...
+type Quick3String struct {
+	CUTOFF int // cutoff to insertion sort
+	R      int // extended ASCII alphabet size
+	aux    []string
+}
+
+// NewQuick3String ...
+func NewQuick3String(a []string) *Quick3String {
+	m := &Quick3String{CUTOFF: 15, R: 256, aux: make([]string, len(a))}
+	m.sort(a, 0, len(a)-1, 0)
+	return m
+}
+
+func (m *Quick3String) insertion(a []string, lo, hi, d int) {
+	for i := lo; i <= hi; i++ {
+		for j := i; j > lo && a[j][d] < a[j-1][d]; j-- {
+			a[j], a[j-1] = a[j-1], a[j]
+		}
+	}
+}
+func (m *Quick3String) sort(a []string, lo, hi, d int) {
+	if hi <= lo+m.CUTOFF {
+		m.insertion(a, lo, hi, d)
+		return
+	}
+
+	lt, gt := lo, hi
+	v := a[lo][d]
+	for i := lo + 1; i <= gt; {
+		t := a[i][d]
+		if t < v {
+			m.exch(a, lt, i)
+			lt++
+			i++
+		} else if t > v {
+			m.exch(a, i, gt)
+			gt--
+		} else {
+			i++
+		}
+	}
+	m.sort(a, lo, lt-1, d)
+	if v >= 0 {
+		m.sort(a, lt, gt, d+1)
+	}
+	m.sort(a, gt+1, hi, d)
+
+}
+
+func (m *Quick3String) exch(a []string, i, j int) {
+	a[i], a[j] = a[j], a[i]
+}

algs4/trie_st.go

@@ -0,0 +1,174 @@
+package algs4
+
+const radix = 256
+
+type trieNode struct {
+	val  interface{}
+	next []*trieNode
+}
+
+func newNode() *trieNode {
+	return &trieNode{next: make([]*trieNode, radix)}
+}
+
+// TrieST ...
+type TrieST struct {
+	R    int
+	n    int // size
+	root *trieNode
+}
+
+// NewTrieST ...
+func NewTrieST() *TrieST {
+	return &TrieST{radix, 0, nil}
+}
+
+// Get ...
+func (t *TrieST) Get(key string) interface{} {
+	x := t.get(t.root, key, 0)
+	if x == nil {
+		return nil
+	}
+	return x.val
+}
+
+func (t *TrieST) get(x *trieNode, key string, d int) *trieNode {
+	if x == nil {
+		return nil
+	}
+	if d == len(key) {
+		return x
+	}
+	c := key[d]
+	return t.get(x.next[c], key, d+1)
+}
+
+// Put ...
+func (t *TrieST) Put(key string, val interface{}) {
+	t.root = t.put(t.root, key, val, 0)
+}
+
+func (t *TrieST) put(x *trieNode, key string, val interface{}, d int) *trieNode {
+	if x == nil {
+		x = newNode()
+	}
+	if d == len(key) {
+		if x.val == nil {
+			t.n++
+		}
+		x.val = val
+		return x
+	}
+	c := key[d]
+	x.next[c] = t.put(x.next[c], key, val, d+1)
+	return x
+}
+
+// Keys ...
+func (t *TrieST) Keys() []string {
+	return t.KeysWithPrefix("")
+}
+
+// KeysWithPrefix ...
+func (t *TrieST) KeysWithPrefix(pre string) (keys []string) {
+	q := NewQueue()
+	t.collect(t.get(t.root, pre, 0), pre, q)
+	for _, item := range q.Slice() {
+		keys = append(keys, item.(string))
+	}
+	return
+}
+
+func (t *TrieST) collect(x *trieNode, pre string, q *Queue) {
+	if x == nil {
+		return
+	}
+	if x.val != nil {
+		q.Enqueue(pre)
+	}
+	for c := 0; c < t.R; c++ {
+		t.collect(x.next[c], pre+string(c), q)
+	}
+}
+
+// KeysThatMatch ...
+func (t *TrieST) KeysThatMatch(pat string) (keys []string) {
+	q := NewQueue()
+	t.collectMatch(t.root, "", pat, q)
+	for _, item := range q.Slice() {
+		keys = append(keys, item.(string))
+	}
+	return
+}
+
+func (t *TrieST) collectMatch(x *trieNode, pre, pat string, q *Queue) {
+	if x == nil {
+		return
+	}
+	d := len(pre)
+	if d == len(pat) && x.val != nil {
+		q.Enqueue(pre)
+	}
+	if d == len(pat) {
+		return
+	}
+	next := pat[d]
+	for c := 0; c < t.R; c++ {
+		if string(next) == "." || int(next) == c {
+			t.collectMatch(x.next[c], pre+string(c), pat, q)
+		}
+	}
+}
+
+// LongPrefixOf ...
+func (t *TrieST) LongPrefixOf(s string) string {
+	length := t.search(t.root, s, 0, 0)
+	return s[:length]
+}
+func (t *TrieST) search(x *trieNode, s string, d, length int) int {
+	if x == nil {
+		return length
+	}
+	if x.val != nil {
+		length = d
+	}
+	if d == len(s) {
+		return length
+	}
+	c := s[d]
+	return t.search(x.next[c], s, d+1, length)
+}
+
+// Delete ...
+func (t *TrieST) Delete(key string) {
+	t.root = t.delete(t.root, key, 0)
+}
+
+func (t *TrieST) delete(x *trieNode, key string, d int) *trieNode {
+	if x == nil {
+		return nil
+	}
+	if d == len(key) {
+		if x.val != nil {
+			t.n--
+		}
+		x.val = nil
+	} else {
+		c := key[d]
+		x.next[c] = t.delete(x.next[c], key, d+1)
+	}
+	if x.val == nil {
+		return x
+	}
+	for c := 0; c < t.R; c++ {
+		if x.next[c] != nil {
+			return x
+		}
+	}
+	return nil
+}
+
+// Size ...
+func (t *TrieST) Size() int {
+	return t.n
+}

cmd/quick3-string/main.go

@@ -0,0 +1,39 @@
+/******************************************************************************
+ *  Execution:   go run cmd/quick3-string/main.go < input.txt
+ *  Data files:   https://algs4.cs.princeton.edu/51radix/words3.txt
+ *                https://algs4.cs.princeton.edu/51radix/shells.txt
+ *
+ *  Reads string from standard input and 3-way string quicksort them.
+ *
+ *  % go run cmd/quick3-string/main.go < shells.txt
+ *  are
+ *  by
+ *  sea
+ *  seashells
+ *  seashells
+ *  sells
+ *  sells
+ *  she
+ *  she
+ *  shells
+ *  shore
+ *  surely
+ *  the
+ *  the
+ *
+ ******************************************************************************/
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/shellfly/algo/algs4"
+	"github.com/shellfly/algo/stdin"
+)
+
+func main() {
+	words := stdin.ReadAllStrings()
+	algs4.NewQuick3String(words)
+	fmt.Println(words)
+}

cmd/trie-st/main.go

@@ -0,0 +1,65 @@
+/******************************************************************************
+ *  Compilation:  javac TrieST.java
+ *  Execution:    java TrieST < words.txt
+ *  Dependencies: StdIn.java
+ *  Data files:   https://algs4.cs.princeton.edviu/52trie/shellsST.txt
+ *
+ *  A string symbol table for extended ASCII strings, implemented
+ *  using a 256-way trie.
+ *
+ *  % java TrieST < shellsST.txt
+ *  by 4
+ *  sea 6
+ *  sells 1
+ *  she 0
+ *  shells 3
+ *  shore 7
+ *  the 5
+ *
+ ******************************************************************************/
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/shellfly/algo/algs4"
+	"github.com/shellfly/algo/stdin"
+)
+
+func main() {
+	st := algs4.NewTrieST()
+	in := stdin.NewStdIn()
+	for i := 0; !in.IsEmpty(); i++ {
+		key := in.ReadString()
+		st.Put(key, i)
+	}
+
+	// print results
+	if st.Size() < 100 {
+		fmt.Println("keys(\"\"):")
+		for _, key := range st.Keys() {
+			fmt.Println(key, " ", st.Get(key))
+		}
+		fmt.Println()
+	}
+
+	fmt.Println("longestPrefixOf(\"shellsort\"):")
+	fmt.Println(st.LongPrefixOf("shellsort"))
+	fmt.Println()
+
+	fmt.Println("longestPrefixOf(\"quicksort\"):")
+	fmt.Println(st.LongPrefixOf("quicksort"))
+	fmt.Println()
+
+	fmt.Println("keysWithPrefix(\"shor\"):")
+	for _, s := range st.KeysWithPrefix("shor") {
+		fmt.Println(s)
+	}
+	fmt.Println()
+
+	fmt.Println("keysThatMatch(\".he.l.\"):")
+	for _, s := range st.KeysThatMatch(".he.l.") {
+		fmt.Println(s)
+	}
+}