basic directory reconstruct

Author: howz97

Diff for: README.md

@@ -1,12 +1,14 @@
-Algorithm (Sedgewick, 4th) implemented in golang
-## Basic
-  * [Stack](https://github.com/howz97/algorithm/tree/master/basic/stack)
-  * [Queue](https://github.com/howz97/algorithm/tree/master/basic/queue)
+Algorithm (Sedgewick, 4th) implemented in golang.  
+[Document](https://pkg.go.dev/github.com/howz97/algorithm)
+
+## [Basic](basic)
+  * Stack
+  * Queue
     * Array List
     * Linked List
-  * [Set](https://github.com/howz97/algorithm/tree/master/basic/set)
-  * [Union-Find](https://github.com/howz97/algorithm/tree/master/basic/unionfind)
-## [Sorting](https://github.com/howz97/algorithm/tree/master/sort)
+  * Set
+  * Union-Find
+## [Sorting](sort)
   * Bubblesort
   * Heapsort
   * Insertsort
@@ -15,11 +17,11 @@ Algorithm (Sedgewick, 4th) implemented in golang
   * Selectsort
   * Shellsort
 ## Searching
-  * [Binary Search Tree](https://github.com/howz97/algorithm/tree/master/search/binarytree)
-  * [AVL Tree](https://github.com/howz97/algorithm/tree/master/search/avlst)
-  * [Red-Black Tree](https://github.com/howz97/algorithm/tree/master/search/redblack)
-  * [Hash Table](https://github.com/howz97/algorithm/tree/master/search/hashmap)
-## [Graphs](https://github.com/howz97/algorithm/tree/master/graphs)
+  * [Binary Search Tree](search/binarytree)
+  * [AVL Tree](search/avlst)
+  * [Red-Black Tree](search/redblack)
+  * [Hash Table](search/hashmap)
+## [Graphs](graphs)
   * Directed Graph
     * BFS
     * DFS
@@ -40,23 +42,22 @@ Algorithm (Sedgewick, 4th) implemented in golang
     * Topological
     * BellmanFord
 ## Strings
-  * [String Sort](https://github.com/howz97/algorithm/tree/master/strings/sort)
+  * [String Sort](strings/sort)
     * Most-significant-digit-first
     * Three-way String Quicksort
-  * [Trie](https://github.com/howz97/algorithm/tree/master/strings/trie)
+  * [Trie](strings/trie)
     * R-way Trie
     * Ternary Search Trie (TST)
-  * [Substring Search](https://github.com/howz97/algorithm/tree/master/strings)
+  * [Substring Search](strings)
     * Knuth-Morris-Pratt
     * Boyer-Moore
     * Rabin-Karp
-  * [Regular Expression](https://github.com/howz97/algorithm/tree/master/strings/regexp)
+  * [Regular Expression](strings/regexp)
   * Data Compression
-    * [Huffman](https://github.com/howz97/algorithm/tree/master/strings/compress/huffman)
-    * [LZW](https://github.com/howz97/algorithm/tree/master/strings/compress/lzw)
-## Priority Queues
-  * [Heap](https://github.com/howz97/algorithm/tree/master/pq/heap)
-  * [Leftist Heap](https://github.com/howz97/algorithm/tree/master/pq/leftist)
-  * [Binomial Heap](https://github.com/howz97/algorithm/tree/master/pq/binomial)
+    * [Huffman](strings/compress/huffman)
+    * [LZW](strings/compress/lzw)
+## [Priority Queues](pq)
+  * Heap
+  * Leftist Heap
+  * Binomial Heap
 
-[Document](https://pkg.go.dev/github.com/howz97/algorithm)

Diff for: basic/queue/linked.go renamed to basic/link_queue.go

@@ -1,25 +1,25 @@
-package queue
+package basic
 
-type LinkQ[T any] struct {
+type LinkQueue[T any] struct {
 	head *elem[T]
 	tail *elem[T]
 	size int
 }
 
-func NewLinkQ[T any]() *LinkQ[T] {
-	return new(LinkQ[T])
+func NewLinkQueue[T any]() *LinkQueue[T] {
+	return new(LinkQueue[T])
 }
 
 type elem[T any] struct {
 	v    T
 	next *elem[T]
 }
 
-func (q *LinkQ[T]) Peek() *T {
+func (q *LinkQueue[T]) Peek() *T {
 	return &q.head.v
 }
 
-func (q *LinkQ[T]) PopFront() T {
+func (q *LinkQueue[T]) PopFront() T {
 	e := q.head.v
 	q.head = q.head.next
 	if q.head == nil {
@@ -29,7 +29,7 @@ func (q *LinkQ[T]) PopFront() T {
 	return e
 }
 
-func (q *LinkQ[T]) PushBack(e T) {
+func (q *LinkQueue[T]) PushBack(e T) {
 	q.size++
 	if q.head == nil {
 		q.head = &elem[T]{
@@ -44,6 +44,6 @@ func (q *LinkQ[T]) PushBack(e T) {
 	q.tail = q.tail.next
 }
 
-func (q *LinkQ[T]) Size() int {
+func (q *LinkQueue[T]) Size() int {
 	return q.size
 }

Diff for: basic/queue/queue.go renamed to basic/queue.go

@@ -1,8 +1,4 @@
-package queue
-
-const (
-	MinCap = 4
-)
+package basic
 
 type Queue[T any] struct {
 	elems      []T

Diff for: basic/queue/queue_test.go renamed to basic/queue_test.go

@@ -1,4 +1,4 @@
-package queue
+package basic
 
 import (
 	"testing"
@@ -24,15 +24,15 @@ func BenchmarkQueue_PopFront(b *testing.B) {
 }
 
 func BenchmarkLinkQueue_PushBack(b *testing.B) {
-	q := NewLinkQ[int]()
+	q := NewLinkQueue[int]()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		q.PushBack(i)
 	}
 }
 
 func BenchmarkLinkQueue_PopFront(b *testing.B) {
-	q := NewLinkQ[int]()
+	q := NewLinkQueue[int]()
 	for i := 0; i < b.N; i++ {
 		q.PushBack(i)
 	}

Diff for: basic/set/set.go renamed to basic/set.go

@@ -1,8 +1,8 @@
-package set
+package basic
 
 type Set[T comparable] map[T]struct{}
 
-func New[T comparable]() Set[T] {
+func NewSet[T comparable]() Set[T] {
 	return make(map[T]struct{})
 }
 

Diff for: basic/stack/stack.go renamed to basic/stack.go

@@ -1,4 +1,4 @@
-package stack
+package basic
 
 import (
 	"fmt"
@@ -15,7 +15,7 @@ type Stack[T any] struct {
 	top   int
 }
 
-func New[T any](c int) *Stack[T] {
+func NewStack[T any](c int) *Stack[T] {
 	if c < MinCap {
 		c = MinCap
 	}
@@ -120,3 +120,22 @@ func (s *Stack[T]) Drain() []T {
 	}
 	return elems
 }
+
+type StackCmp[T comparable] struct {
+	Stack[T]
+}
+
+func NewStackCmp[T comparable](c int) *StackCmp[T] {
+	return &StackCmp[T]{
+		Stack: *NewStack[T](c),
+	}
+}
+
+func (s *StackCmp[T]) Contains(e T) bool {
+	for i := 0; i < s.top; i++ {
+		if s.elems[i] == e {
+			return true
+		}
+	}
+	return false
+}

Diff for: basic/stack/contains.go

@@ -1,4 +1,4 @@
-package stack
+package basic
 
 import (
 	"fmt"
@@ -7,7 +7,7 @@ import (
 
 func TestNewStack(t *testing.T) {
 	testTimes := 100
-	s := New[int](10)
+	s := NewStack[int](10)
 	for i := 0; i < testTimes; i++ {
 		s.Push(i)
 	}

Diff for: basic/stack/stack_test.go renamed to basic/stack_test.go

@@ -1,4 +1,4 @@
-package unionfind
+package basic
 
 const (
 	verticalOverflow = "vertical overflow"
@@ -9,7 +9,7 @@ type UnionFind struct {
 	numcc int
 }
 
-func New(numV int) *UnionFind {
+func NewUnionFind(numV int) *UnionFind {
 	uf := &UnionFind{
 		id:    make([]int, numV),
 		numcc: numV,

Diff for: basic/unionfind/union_find.go renamed to basic/union_find.go

@@ -1,12 +1,12 @@
-package unionfind
+package basic
 
 import (
 	"fmt"
 	"testing"
 )
 
 func TestUnionFind_Union(t *testing.T) {
-	uf := New(8)
+	uf := NewUnionFind(8)
 	fmt.Printf("NumConnectedComponent: %v\n", uf.NumConnectedComponent())
 	uf.Union(1, 7)
 	uf.Union(7, 0)

Diff for: basic/unionfind/union_find_test.go renamed to basic/union_find_test.go

@@ -3,8 +3,7 @@ package graphs
 import (
 	"strconv"
 
-	"github.com/howz97/algorithm/basic/queue"
-	"github.com/howz97/algorithm/basic/stack"
+	"github.com/howz97/algorithm/basic"
 	"github.com/howz97/algorithm/search/hashmap"
 	. "github.com/howz97/algorithm/util"
 	"gopkg.in/yaml.v2"
@@ -219,11 +218,11 @@ func (dg *Digraph) detectCycleDFS(v int, marked []bool, path *Path) bool {
 }
 
 // Topological return a stack that will pop vertices in topological order
-func (dg *Digraph) Topological() (order *stack.Stack[int]) {
+func (dg *Digraph) Topological() (order *basic.Stack[int]) {
 	if dg.FindCycle() != nil {
 		return
 	}
-	order = stack.New[int](int(dg.NumVert()))
+	order = basic.NewStack[int](int(dg.NumVert()))
 	dg.IterVetBDFS(func(v int) bool {
 		order.Push(v)
 		return true
@@ -522,7 +521,7 @@ func (dg Digraph) BFS(src int) *BFS {
 		marked: make([]bool, dg.NumVert()),
 		edgeTo: make([]int, dg.NumVert()),
 	}
-	q := queue.NewLinkQ[int]()
+	q := basic.NewLinkQueue[int]()
 	bfs.marked[src] = true
 	q.PushBack(src)
 	for q.Size() > 0 {

Diff for: graphs/digraph.go

@@ -5,7 +5,7 @@ import (
 	stdsort "sort"
 	"testing"
 
-	"github.com/howz97/algorithm/basic/stack"
+	"github.com/howz97/algorithm/basic"
 	"github.com/howz97/algorithm/sort"
 	"github.com/howz97/algorithm/util"
 )
@@ -136,7 +136,7 @@ func TestRevDFS(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	order := stack.New[int](0)
+	order := basic.NewStack[int](0)
 	g.IterBDFSFrom(0, func(v int) bool {
 		order.Push(v)
 		return true

Diff for: graphs/digraph_test.go

@@ -6,8 +6,7 @@ import (
 	"math"
 	"strconv"
 
-	"github.com/howz97/algorithm/basic/queue"
-	"github.com/howz97/algorithm/basic/stack"
+	"github.com/howz97/algorithm/basic"
 	"github.com/howz97/algorithm/pq"
 )
 
@@ -146,7 +145,7 @@ func dijkstraRelax(g *WDigraph, v int, edgeTo []int, distTo []float64, pq *pq.Fi
 }
 
 func (spt *PathTree) initTopological(g *WDigraph) {
-	order := stack.New[int](int(g.NumVert()))
+	order := basic.NewStack[int](int(g.NumVert()))
 	g.IterBDFSFrom(spt.src, func(v int) bool {
 		order.Push(v)
 		return true
@@ -168,7 +167,7 @@ func topologicalRelax(g *WDigraph, v int, edgeTo []int, distTo []float64) {
 }
 
 func (spt *PathTree) initBellmanFord(g *WDigraph) error {
-	q := queue.NewLinkQ[int]()
+	q := basic.NewLinkQueue[int]()
 	onQ := make([]bool, g.NumVert())
 	q.PushBack(spt.src)
 	onQ[spt.src] = true
@@ -199,7 +198,7 @@ func (spt *PathTree) toWDigraph(g *WDigraph) *WDigraph {
 	return sptg
 }
 
-func bellmanFordRelax(g *WDigraph, v int, edgeTo []int, distTo []float64, q *queue.LinkQ[int], onQ []bool) {
+func bellmanFordRelax(g *WDigraph, v int, edgeTo []int, distTo []float64, q *basic.LinkQueue[int], onQ []bool) {
 	g.IterWAdjacent(v, func(adj int, w float64) bool {
 		if distTo[v]+w < distTo[adj] {
 			edgeTo[adj] = v
@@ -285,12 +284,12 @@ func (s *Searcher) GetPath(src, dst int) *Path {
 
 func NewPath() *Path {
 	return &Path{
-		Stack: stack.New[edge](2),
+		Stack: basic.NewStack[edge](2),
 	}
 }
 
 type Path struct {
-	*stack.Stack[edge]
+	*basic.Stack[edge]
 }
 
 func (p *Path) Push(from, to int, w float64) {

Diff for: graphs/w_digraph.go

@@ -1,7 +1,7 @@
 package graphs
 
 import (
-	"github.com/howz97/algorithm/basic/unionfind"
+	"github.com/howz97/algorithm/basic"
 	"github.com/howz97/algorithm/pq"
 )
 
@@ -100,7 +100,7 @@ func primVisit(g, mst *WGraph, v int, marked []bool, pq *pq.Fixable[float64, int
 // Kruskal gets the minimum spanning tree by Kruskal algorithm. g MUST be a connected graph
 func (g *WGraph) Kruskal() (mst *WGraph) {
 	mst = NewWGraph(g.NumVert())
-	uf := unionfind.New(int(g.NumVert()))
+	uf := basic.NewUnionFind(int(g.NumVert()))
 	pq := pq.NewPaired[float64, *edge](g.NumVert())
 	g.IterWEdge(func(src int, dst int, w float64) bool {
 		pq.PushPair(w, &edge{