Merge pull request #2 from li1234yun/trees_any_type_value

ugurcsen · web-flow · commit 95753c52b6b4 · 2023-04-26T10:43:10.000+03:00
Modify trees value generic type to any for allowing receive map/slice etc
diff --git a/examples/redblacktreeextended/redblacktreeextended.go b/examples/redblacktreeextended/redblacktreeextended.go
@@ -6,11 +6,12 @@ package redblacktreeextended
 
 import (
 	"fmt"
+
 	rbt "github.com/ugurcsen/gods-generic/trees/redblacktree"
 )
 
 // RedBlackTreeExtended to demonstrate how to extend a RedBlackTree to include new functions
-type RedBlackTreeExtended[K, T comparable] struct {
+type RedBlackTreeExtended[K comparable, T any] struct {
 	*rbt.Tree[K, T]
 }
 
diff --git a/trees/avltree/avltree.go b/trees/avltree/avltree.go
@@ -11,6 +11,7 @@ package avltree
 
 import (
 	"fmt"
+
 	"github.com/ugurcsen/gods-generic/trees"
 	"github.com/ugurcsen/gods-generic/utils"
 )
@@ -19,14 +20,14 @@ import (
 var _ trees.Tree[int] = new(Tree[int, int])
 
 // Tree holds elements of the AVL tree.
-type Tree[K, T comparable] struct {
+type Tree[K comparable, T any] struct {
 	Root       *Node[K, T]         // Root node
 	Comparator utils.Comparator[K] // Key comparator
 	size       int                 // Total number of keys in the tree
 }
 
 // Node is a single element within the tree
-type Node[K, T comparable] struct {
+type Node[K comparable, T any] struct {
 	Key      K
 	Value    T
 	Parent   *Node[K, T]    // Parent node
@@ -35,17 +36,17 @@ type Node[K, T comparable] struct {
 }
 
 // NewWith instantiates an AVL tree with the custom comparator.
-func NewWith[K, T comparable](comparator utils.Comparator[K]) *Tree[K, T] {
+func NewWith[K comparable, T any](comparator utils.Comparator[K]) *Tree[K, T] {
 	return &Tree[K, T]{Comparator: comparator}
 }
 
 // NewWithNumberComparator instantiates an AVL tree with the IntComparator, i.e. keys are of type int.
-func NewWithNumberComparator[T comparable]() *Tree[int, T] {
+func NewWithNumberComparator[T any]() *Tree[int, T] {
 	return &Tree[int, T]{Comparator: utils.NumberComparator[int]}
 }
 
 // NewWithStringComparator instantiates an AVL tree with the StringComparator, i.e. keys are of type string.
-func NewWithStringComparator[T comparable]() *Tree[string, T] {
+func NewWithStringComparator[T any]() *Tree[string, T] {
 	return &Tree[string, T]{Comparator: utils.StringComparator}
 }
 
@@ -291,7 +292,7 @@ func (t *Tree[K, T]) remove(key K, qp **Node[K, T]) bool {
 	return false
 }
 
-func removeMin[K, T comparable](qp **Node[K, T], minKey *K, minVal *T) bool {
+func removeMin[K comparable, T any](qp **Node[K, T], minKey *K, minVal *T) bool {
 	q := *qp
 	if q.Children[0] == nil {
 		*minKey = q.Key
@@ -309,7 +310,7 @@ func removeMin[K, T comparable](qp **Node[K, T], minKey *K, minVal *T) bool {
 	return false
 }
 
-func putFix[K, T comparable](c int8, t **Node[K, T]) bool {
+func putFix[K comparable, T any](c int8, t **Node[K, T]) bool {
 	s := *t
 	if s.b == 0 {
 		s.b = c
@@ -330,7 +331,7 @@ func putFix[K, T comparable](c int8, t **Node[K, T]) bool {
 	return false
 }
 
-func removeFix[K, T comparable](c int8, t **Node[K, T]) bool {
+func removeFix[K comparable, T any](c int8, t **Node[K, T]) bool {
 	s := *t
 	if s.b == 0 {
 		s.b = c
@@ -359,14 +360,14 @@ func removeFix[K, T comparable](c int8, t **Node[K, T]) bool {
 	return true
 }
 
-func singlerot[K, T comparable](c int8, s *Node[K, T]) *Node[K, T] {
+func singlerot[K comparable, T any](c int8, s *Node[K, T]) *Node[K, T] {
 	s.b = 0
 	s = rotate(c, s)
 	s.b = 0
 	return s
 }
 
-func doublerot[K, T comparable](c int8, s *Node[K, T]) *Node[K, T] {
+func doublerot[K comparable, T any](c int8, s *Node[K, T]) *Node[K, T] {
 	a := (c + 1) / 2
 	r := s.Children[a]
 	s.Children[a] = rotate(-c, s.Children[a])
@@ -388,7 +389,7 @@ func doublerot[K, T comparable](c int8, s *Node[K, T]) *Node[K, T] {
 	return p
 }
 
-func rotate[K, T comparable](c int8, s *Node[K, T]) *Node[K, T] {
+func rotate[K comparable, T any](c int8, s *Node[K, T]) *Node[K, T] {
 	a := (c + 1) / 2
 	r := s.Children[a]
 	s.Children[a] = r.Children[a^1]
@@ -446,7 +447,7 @@ func (n *Node[K, T]) walk1(a int) *Node[K, T] {
 	return p
 }
 
-func output[K, T comparable](node *Node[K, T], prefix string, isTail bool, str *string) {
+func output[K comparable, T any](node *Node[K, T], prefix string, isTail bool, str *string) {
 	if node.Children[1] != nil {
 		newPrefix := prefix
 		if isTail {
diff --git a/trees/avltree/avltree_test.go b/trees/avltree/avltree_test.go
@@ -6,9 +6,10 @@ package avltree
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/ugurcsen/gods-generic/utils"
 	"strings"
 	"testing"
+
+	"github.com/ugurcsen/gods-generic/utils"
 )
 
 func TestAVLTreeGet(t *testing.T) {
@@ -657,8 +658,7 @@ func TestAVLTreeIteratorPrevTo(t *testing.T) {
 }
 
 func TestAVLTreeSerialization(t *testing.T) {
-	tree := NewWith[string, string](utils.StringComparator)
-	tree = NewWithStringComparator[string]()
+	tree := NewWithStringComparator[string]()
 	tree.Put("c", "3")
 	tree.Put("b", "2")
 	tree.Put("a", "1")
diff --git a/trees/avltree/iterator.go b/trees/avltree/iterator.go
@@ -10,7 +10,7 @@ import "github.com/ugurcsen/gods-generic/containers"
 var _ containers.ReverseIteratorWithKey[int, int] = (*Iterator[int, int])(nil)
 
 // Iterator holding the iterator's state
-type Iterator[K, T comparable] struct {
+type Iterator[K comparable, T any] struct {
 	tree     *Tree[K, T]
 	node     *Node[K, T]
 	position position
diff --git a/trees/binaryheap/iterator.go b/trees/binaryheap/iterator.go
@@ -50,7 +50,7 @@ func (iterator *Iterator[T]) Value() T {
 	if end > iterator.heap.Size() {
 		end = iterator.heap.Size()
 	}
-	tmpHeap := NewWith[T](iterator.heap.Comparator)
+	tmpHeap := NewWith(iterator.heap.Comparator)
 	for n := start; n < end; n++ {
 		value, _ := iterator.heap.list.Get(n)
 		tmpHeap.Push(value)
diff --git a/trees/btree/btree.go b/trees/btree/btree.go
@@ -19,50 +19,51 @@ package btree
 import (
 	"bytes"
 	"fmt"
+	"strings"
+
 	"github.com/ugurcsen/gods-generic/trees"
 	"github.com/ugurcsen/gods-generic/utils"
-	"strings"
 )
 
 // Assert Tree implementation
 var _ trees.Tree[int] = (*Tree[int, int])(nil)
 
 // Tree holds elements of the B-tree
-type Tree[K, T comparable] struct {
+type Tree[K comparable, T any] struct {
 	Root       *Node[K, T]         // Root node
 	Comparator utils.Comparator[K] // Key comparator
 	size       int                 // Total number of keys in the tree
 	m          int                 // order (maximum number of children)
 }
 
 // Node is a single element within the tree
-type Node[K, T comparable] struct {
+type Node[K comparable, T any] struct {
 	Parent   *Node[K, T]
 	Entries  []*Entry[K, T] // Contained keys in node
 	Children []*Node[K, T]  // Children nodes
 }
 
 // Entry represents the key-value pair contained within nodes
-type Entry[K, T comparable] struct {
+type Entry[K comparable, T any] struct {
 	Key   K
 	Value T
 }
 
 // NewWith instantiates a B-tree with the order (maximum number of children) and a custom key comparator.
-func NewWith[K, T comparable](order int, comparator utils.Comparator[K]) *Tree[K, T] {
+func NewWith[K comparable, T any](order int, comparator utils.Comparator[K]) *Tree[K, T] {
 	if order < 3 {
 		panic("Invalid order, should be at least 3")
 	}
 	return &Tree[K, T]{m: order, Comparator: comparator}
 }
 
 // NewWithNumberComparator instantiates a B-tree with the order (maximum number of children) and the IntComparator, i.e. keys are of type int.
-func NewWithNumberComparator[T comparable](order int) *Tree[int, T] {
+func NewWithNumberComparator[T any](order int) *Tree[int, T] {
 	return NewWith[int, T](order, utils.NumberComparator[int])
 }
 
 // NewWithStringComparator instantiates a B-tree with the order (maximum number of children) and the StringComparator, i.e. keys are of type string.
-func NewWithStringComparator[T comparable](order int) *Tree[string, T] {
+func NewWithStringComparator[T any](order int) *Tree[string, T] {
 	return NewWith[string, T](order, utils.StringComparator)
 }
 
@@ -415,7 +416,7 @@ func (tree *Tree[K, T]) splitRoot() {
 	tree.Root = newRoot
 }
 
-func setParent[K, T comparable](nodes []*Node[K, T], parent *Node[K, T]) {
+func setParent[K comparable, T any](nodes []*Node[K, T], parent *Node[K, T]) {
 	for _, node := range nodes {
 		node.Parent = parent
 	}
diff --git a/trees/btree/btree_test.go b/trees/btree/btree_test.go
@@ -7,9 +7,10 @@ package btree
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/ugurcsen/gods-generic/utils"
 	"strings"
 	"testing"
+
+	"github.com/ugurcsen/gods-generic/utils"
 )
 
 func TestBTreeGet1(t *testing.T) {
@@ -1044,13 +1045,13 @@ func TestBTreeSearch(t *testing.T) {
 	}
 }
 
-func assertValidTree[K, T comparable](t *testing.T, tree *Tree[K, T], expectedSize int) {
+func assertValidTree[K comparable, T any](t *testing.T, tree *Tree[K, T], expectedSize int) {
 	if actualValue, expectedValue := tree.size, expectedSize; actualValue != expectedValue {
 		t.Errorf("Got %v expected %v for tree size", actualValue, expectedValue)
 	}
 }
 
-func assertValidTreeNode[K, T comparable](t *testing.T, node *Node[K, T], expectedEntries int, expectedChildren int, keys []K, hasParent bool) {
+func assertValidTreeNode[K comparable, T any](t *testing.T, node *Node[K, T], expectedEntries int, expectedChildren int, keys []K, hasParent bool) {
 	if actualValue, expectedValue := node.Parent != nil, hasParent; actualValue != expectedValue {
 		t.Errorf("Got %v expected %v for hasParent", actualValue, expectedValue)
 	}
diff --git a/trees/btree/iterator.go b/trees/btree/iterator.go
@@ -10,7 +10,7 @@ import "github.com/ugurcsen/gods-generic/containers"
 var _ containers.ReverseIteratorWithKey[int, int] = (*Iterator[int, int])(nil)
 
 // Iterator holding the iterator's state
-type Iterator[K, T comparable] struct {
+type Iterator[K comparable, T any] struct {
 	tree     *Tree[K, T]
 	node     *Node[K, T]
 	entry    *Entry[K, T]
diff --git a/trees/redblacktree/iterator.go b/trees/redblacktree/iterator.go
@@ -10,7 +10,7 @@ import "github.com/ugurcsen/gods-generic/containers"
 var _ containers.ReverseIteratorWithKey[int, int] = (*Iterator[int, int])(nil)
 
 // Iterator holding the iterator's state
-type Iterator[K, T comparable] struct {
+type Iterator[K comparable, T any] struct {
 	tree     *Tree[K, T]
 	node     *Node[K, T]
 	position position
diff --git a/trees/redblacktree/redblacktree.go b/trees/redblacktree/redblacktree.go
@@ -13,6 +13,7 @@ package redblacktree
 
 import (
 	"fmt"
+
 	"github.com/ugurcsen/gods-generic/trees"
 	"github.com/ugurcsen/gods-generic/utils"
 )
@@ -27,14 +28,14 @@ const (
 )
 
 // Tree holds elements of the red-black tree
-type Tree[K, T comparable] struct {
+type Tree[K comparable, T any] struct {
 	Root       *Node[K, T]
 	size       int
 	Comparator utils.Comparator[K]
 }
 
 // Node is a single element within the tree
-type Node[K, T comparable] struct {
+type Node[K comparable, T any] struct {
 	Key    K
 	Value  T
 	color  color
@@ -44,17 +45,17 @@ type Node[K, T comparable] struct {
 }
 
 // NewWith instantiates a red-black tree with the custom comparator.
-func NewWith[K, T comparable](comparator utils.Comparator[K]) *Tree[K, T] {
+func NewWith[K comparable, T any](comparator utils.Comparator[K]) *Tree[K, T] {
 	return &Tree[K, T]{Comparator: comparator}
 }
 
 // NewWithNumberComparator instantiates a red-black tree with the IntComparator, i.e. keys are of type int.
-func NewWithNumberComparator[T comparable]() *Tree[int, T] {
+func NewWithNumberComparator[T any]() *Tree[int, T] {
 	return &Tree[int, T]{Comparator: utils.NumberComparator[int]}
 }
 
 // NewWithStringComparator instantiates a red-black tree with the StringComparator, i.e. keys are of type string.
-func NewWithStringComparator[T comparable]() *Tree[string, T] {
+func NewWithStringComparator[T any]() *Tree[string, T] {
 	return &Tree[string, T]{Comparator: utils.StringComparator}
 }
 
@@ -296,7 +297,7 @@ func (node *Node[K, T]) String() string {
 	return fmt.Sprintf("%v", node.Key)
 }
 
-func output[K, T comparable](node *Node[K, T], prefix string, isTail bool, str *string) {
+func output[K comparable, T any](node *Node[K, T], prefix string, isTail bool, str *string) {
 	if node.Right != nil {
 		newPrefix := prefix
 		if isTail {
@@ -541,7 +542,7 @@ func (tree *Tree[K, T]) deleteCase6(node *Node[K, T]) {
 	}
 }
 
-func nodeColor[K, T comparable](node *Node[K, T]) color {
+func nodeColor[K comparable, T any](node *Node[K, T]) color {
 	if node == nil {
 		return black
 	}

Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,12 @@ package redblacktreeextended`
`6`	`6`
`7`	`7`	`import (`
`8`	`8`	`"fmt"`
	`9`	`+`
`9`	`10`	`rbt "github.com/ugurcsen/gods-generic/trees/redblacktree"`
`10`	`11`	`)`
`11`	`12`
`12`	`13`	`// RedBlackTreeExtended to demonstrate how to extend a RedBlackTree to include new functions`
`13`		`-type RedBlackTreeExtended[K, T comparable] struct {`
	`14`	`+type RedBlackTreeExtended[K comparable, T any] struct {`
`14`	`15`	`*rbt.Tree[K, T]`
`15`	`16`	`}`
`16`	`17`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ func (iterator *Iterator[T]) Value() T {`
`50`	`50`	`if end > iterator.heap.Size() {`
`51`	`51`	`end = iterator.heap.Size()`
`52`	`52`	`}`
`53`		`- tmpHeap := NewWith[T](iterator.heap.Comparator)`
	`53`	`+ tmpHeap := NewWith(iterator.heap.Comparator)`
`54`	`54`	`for n := start; n < end; n++ {`
`55`	`55`	`value, _ := iterator.heap.list.Get(n)`
`56`	`56`	`tmpHeap.Push(value)`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,10 @@ package btree`
`7`	`7`	`import (`
`8`	`8`	`"encoding/json"`
`9`	`9`	`"fmt"`
`10`		`- "github.com/ugurcsen/gods-generic/utils"`
`11`	`10`	`"strings"`
`12`	`11`	`"testing"`
	`12`	`+`
	`13`	`+ "github.com/ugurcsen/gods-generic/utils"`
`13`	`14`	`)`
`14`	`15`
`15`	`16`	`func TestBTreeGet1(t *testing.T) {`
`@@ -1044,13 +1045,13 @@ func TestBTreeSearch(t *testing.T) {`
`1044`	`1045`	`}`
`1045`	`1046`	`}`
`1046`	`1047`
`1047`		`-func assertValidTree[K, T comparable](t testing.T, tree Tree[K, T], expectedSize int) {`
	`1048`	`+func assertValidTree[K comparable, T any](t testing.T, tree Tree[K, T], expectedSize int) {`
`1048`	`1049`	`if actualValue, expectedValue := tree.size, expectedSize; actualValue != expectedValue {`
`1049`	`1050`	`t.Errorf("Got %v expected %v for tree size", actualValue, expectedValue)`
`1050`	`1051`	`}`
`1051`	`1052`	`}`
`1052`	`1053`
`1053`		`-func assertValidTreeNode[K, T comparable](t testing.T, node Node[K, T], expectedEntries int, expectedChildren int, keys []K, hasParent bool) {`
	`1054`	`+func assertValidTreeNode[K comparable, T any](t testing.T, node Node[K, T], expectedEntries int, expectedChildren int, keys []K, hasParent bool) {`
`1054`	`1055`	`if actualValue, expectedValue := node.Parent != nil, hasParent; actualValue != expectedValue {`
`1055`	`1056`	`t.Errorf("Got %v expected %v for hasParent", actualValue, expectedValue)`
`1056`	`1057`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ package redblacktree`
`13`	`13`
`14`	`14`	`import (`
`15`	`15`	`"fmt"`
	`16`	`+`
`16`	`17`	`"github.com/ugurcsen/gods-generic/trees"`
`17`	`18`	`"github.com/ugurcsen/gods-generic/utils"`
`18`	`19`	`)`
`@@ -27,14 +28,14 @@ const (`
`27`	`28`	`)`
`28`	`29`
`29`	`30`	`// Tree holds elements of the red-black tree`
`30`		`-type Tree[K, T comparable] struct {`
	`31`	`+type Tree[K comparable, T any] struct {`
`31`	`32`	`Root *Node[K, T]`
`32`	`33`	`size int`
`33`	`34`	`Comparator utils.Comparator[K]`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`// Node is a single element within the tree`
`37`		`-type Node[K, T comparable] struct {`
	`38`	`+type Node[K comparable, T any] struct {`
`38`	`39`	`Key K`
`39`	`40`	`Value T`
`40`	`41`	`color color`
`@@ -44,17 +45,17 @@ type Node[K, T comparable] struct {`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`// NewWith instantiates a red-black tree with the custom comparator.`
`47`		`-func NewWith[K, T comparable](comparator utils.Comparator[K]) *Tree[K, T] {`
	`48`	`+func NewWith[K comparable, T any](comparator utils.Comparator[K]) *Tree[K, T] {`
`48`	`49`	`return &Tree[K, T]{Comparator: comparator}`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`// NewWithNumberComparator instantiates a red-black tree with the IntComparator, i.e. keys are of type int.`
`52`		`-func NewWithNumberComparator[T comparable]() *Tree[int, T] {`
	`53`	`+func NewWithNumberComparator[T any]() *Tree[int, T] {`
`53`	`54`	`return &Tree[int, T]{Comparator: utils.NumberComparator[int]}`
`54`	`55`	`}`
`55`	`56`
`56`	`57`	`// NewWithStringComparator instantiates a red-black tree with the StringComparator, i.e. keys are of type string.`
`57`		`-func NewWithStringComparator[T comparable]() *Tree[string, T] {`
	`58`	`+func NewWithStringComparator[T any]() *Tree[string, T] {`
`58`	`59`	`return &Tree[string, T]{Comparator: utils.StringComparator}`
`59`	`60`	`}`
`60`	`61`
`@@ -296,7 +297,7 @@ func (node *Node[K, T]) String() string {`
`296`	`297`	`return fmt.Sprintf("%v", node.Key)`
`297`	`298`	`}`
`298`	`299`
`299`		`-func output[K, T comparable](node Node[K, T], prefix string, isTail bool, str string) {`
	`300`	`+func output[K comparable, T any](node Node[K, T], prefix string, isTail bool, str string) {`
`300`	`301`	`if node.Right != nil {`
`301`	`302`	`newPrefix := prefix`
`302`	`303`	`if isTail {`
`@@ -541,7 +542,7 @@ func (tree Tree[K, T]) deleteCase6(node Node[K, T]) {`
`541`	`542`	`}`
`542`	`543`	`}`
`543`	`544`
`544`		`-func nodeColor[K, T comparable](node *Node[K, T]) color {`
	`545`	`+func nodeColor[K comparable, T any](node *Node[K, T]) color {`
`545`	`546`	`if node == nil {`
`546`	`547`	`return black`
`547`	`548`	`}`