reconstruct search package

Author: howz97

demo/avltree.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/howz97/algorithm/search"
+)
+
+func main() {
+	fmt.Println("BinaryTree:")
+	demoBinaryTreeTraversal()
+	fmt.Println("\nAVL:")
+	demoAvlTraversal()
+	fmt.Println("\nRedBlack:")
+	demoRedBlackTraversal()
+}
+
+func demoBinaryTreeTraversal() {
+	bt := search.NewBinTree[int, string]()
+	nodes := []int{50, 20, 10, 30, 40, 45, 60}
+	for _, v := range nodes {
+		bt.Put(v, strconv.Itoa(v))
+	}
+	search.PrintTree(bt.Root(), func(nd *search.BtNode[int, string]) string { return nd.Value() })
+
+	printNode := func(nd *search.BtNode[int, string]) bool {
+		fmt.Print("\t", nd.Value())
+		return true
+	}
+	fmt.Print("Preorder:")
+	search.Preorder(bt.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("PreorderRecur:")
+	search.PreorderRecur(bt.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("Inorder:")
+	search.Inorder(bt.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("Postorder:")
+	search.Postorder(bt.Root(), printNode)
+	fmt.Println()
+}
+
+func demoAvlTraversal() {
+	avl := search.NewAVL[int, string]()
+	nodes := []int{50, 20, 10, 30, 40, 45, 60}
+	for _, v := range nodes {
+		avl.Put(v, strconv.Itoa(v))
+	}
+	search.PrintTree(avl.Root(), func(nd *search.AvlNode[int, string]) string { return nd.Value() })
+
+	printNode := func(nd *search.AvlNode[int, string]) bool {
+		fmt.Print("\t", nd.Value())
+		return true
+	}
+	fmt.Print("Preorder:")
+	search.Preorder(avl.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("PreorderRecur:")
+	search.PreorderRecur(avl.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("Inorder:")
+	search.Inorder(avl.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("Postorder:")
+	search.Postorder(avl.Root(), printNode)
+	fmt.Println()
+}
+
+func demoRedBlackTraversal() {
+	rbt := search.NewRBTree[int, string]()
+	nodes := []int{50, 20, 10, 30, 40, 45, 60}
+	for _, v := range nodes {
+		rbt.Put(v, strconv.Itoa(v))
+	}
+	search.PrintTree(rbt.Root(), func(nd *search.RbNode[int, string]) string {
+		var c string
+		if nd.IsRed() {
+			c = "r"
+		} else {
+			c = "b"
+		}
+		return fmt.Sprintf("%s(%v)", nd.Value(), c)
+	})
+
+	printNode := func(nd *search.RbNode[int, string]) bool {
+		fmt.Print("\t", nd.Value())
+		return true
+	}
+	fmt.Print("Preorder:")
+	search.Preorder(rbt.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("PreorderRecur:")
+	search.PreorderRecur(rbt.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("Inorder:")
+	search.Inorder(rbt.Root(), printNode)
+	fmt.Println()
+
+	fmt.Print("Postorder:")
+	search.Postorder(rbt.Root(), printNode)
+	fmt.Println()
+}

demo/compress.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"os"
 
 	"github.com/howz97/algorithm/util"
 	"gopkg.in/yaml.v2"
@@ -17,7 +17,7 @@ var (
 )
 
 func readYaml(filename string) (*Digraph, error) {
-	content, err := ioutil.ReadFile(filename)
+	content, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, err
 	}
@@ -98,11 +98,11 @@ func checkNoDirection(dg *Digraph) error {
 	dg.IterWEdge(func(from, to int, w float64) bool {
 		wr := dg.GetWeight(to, from)
 		if wr == 0 {
-			err = errors.New(fmt.Sprintf("edge %d->%d has direction", from, to))
+			err = fmt.Errorf(fmt.Sprintf("edge %d->%d has direction", from, to))
 			return false
 		}
 		if wr != w {
-			err = errors.New(fmt.Sprintf("edge %d->%d has weight %v, but %d->%d has weight %v",
+			err = fmt.Errorf(fmt.Sprintf("edge %d->%d has weight %v, but %d->%d has weight %v",
 				from, to, w, to, from, wr))
 			return false
 		}

demo/hash_map.go

@@ -4,21 +4,21 @@ import (
 	"strconv"
 
 	"github.com/howz97/algorithm/basic"
-	"github.com/howz97/algorithm/search/hashmap"
-	. "github.com/howz97/algorithm/util"
+	"github.com/howz97/algorithm/search"
+	"github.com/howz97/algorithm/util"
 	"gopkg.in/yaml.v2"
 )
 
 func NewDigraph(size uint) *Digraph {
-	edges := make([]*hashmap.Chaining[Int, float64], size)
+	edges := make([]*search.HashMap[util.Int, float64], size)
 	for i := range edges {
-		edges[i] = hashmap.New[Int, float64]()
+		edges[i] = search.NewHashMap[util.Int, float64]()
 	}
 	return &Digraph{edges: edges}
 }
 
 type Digraph struct {
-	edges []*hashmap.Chaining[Int, float64]
+	edges []*search.HashMap[util.Int, float64]
 	*Symbol
 }
 
@@ -51,7 +51,7 @@ func (dg *Digraph) HasEdge(from, to int) bool {
 	if !dg.HasVert(from) || !dg.HasVert(to) {
 		return false
 	}
-	_, ok := dg.edges[from].Get(Int(to))
+	_, ok := dg.edges[from].Get(util.Int(to))
 	return ok
 }
 
@@ -62,18 +62,18 @@ func (dg *Digraph) addWeightedEdge(from, to int, w float64) {
 	if from == to {
 		panic(ErrSelfLoop)
 	}
-	dg.edges[from].Put(Int(to), w)
+	dg.edges[from].Put(util.Int(to), w)
 }
 
 // DelEdge delete an edge
 func (dg *Digraph) DelEdge(src, dst int) {
-	dg.edges[src].Del(Int(dst))
+	dg.edges[src].Del(util.Int(dst))
 }
 
 // GetWeight get the weight of edge
 // Zero will be returned if edge not exist
 func (dg *Digraph) GetWeight(from, to int) float64 {
-	w, _ := dg.edges[from].Get(Int(to))
+	w, _ := dg.edges[from].Get(util.Int(to))
 	return w
 }
 
@@ -96,7 +96,7 @@ func (dg *Digraph) IterAdjacent(v int, fn func(int) bool) {
 
 // IterWAdjacent iterate all adjacent vertices and weight of v
 func (dg *Digraph) IterWAdjacent(v int, fn func(int, float64) bool) {
-	dg.edges[v].Range(func(key Int, val float64) bool {
+	dg.edges[v].Range(func(key util.Int, val float64) bool {
 		return fn(int(key), val)
 	})
 }
@@ -234,7 +234,7 @@ func (dg *Digraph) Topological() (order *basic.Stack[int]) {
 func (dg *Digraph) IterWEdge(fn func(int, int, float64) bool) {
 	for src, hm := range dg.edges {
 		goon := true
-		hm.Range(func(dst Int, v float64) bool {
+		hm.Range(func(dst util.Int, v float64) bool {
 			goon = fn(src, int(dst), v)
 			return goon
 		})