tree

type Comparer ¶

type Comparer[T any] interface {
	Compare(T) int
}

type FuncTree ¶

type FuncTree[E any] struct {
	// contains filtered or unexported fields
}

A FuncTree must be created with NewTreeFunc.

type Player struct {
    Name   string
    Rating int
}

func (p Player) Compare(q Player) int {
    return cmp.Compare(p.Rating, q.Rating)
}

players := []Player{
    {"Garry Kasparov", 2851},
    {"Magnus Carlsen", 2882},
    {"Bobby Fischer", 2785},
    {"Anatoly Karpov", 2780},
    {"Mikhail Tal", 2705},
}

t := NewFuncTree(func(a, b Player) int {
    return cmp.Compare(a.Rating, b.Rating)
})

t.Insert(Player{"Garry Kasparov", 2851})
t.Insert(Player{"Magnus Carlsen", 2882})
t.Insert(Player{"Bobby Fischer", 2785})
t.Insert(Player{"Anatoly Karpov", 2780})
t.Insert(Player{"Mikhail Tal", 2705})

for p := range t.All() {
    fmt.Println(p)
}

t := NewFuncTree(func(a, b Player) int {
	return cmp.Compare(a.Rating, b.Rating)
})
t.Add(Player{"Garry Kasparov", 2851})
t.Add(Player{"Magnus Carlsen", 2882})
t.Add(Player{"Bobby Fischer", 2785})
t.Add(Player{"Anatoly Karpov", 2780})
t.Add(Player{"Mikhail Tal", 2705})
for n := range t.All() {
	fmt.Println(n)
}

Output:

{Mikhail Tal 2705}
{Anatoly Karpov 2780}
{Bobby Fischer 2785}
{Garry Kasparov 2851}
{Magnus Carlsen 2882}

func NewFuncTree[E any](cmp func(E, E) int) *FuncTree[E]

func (t *FuncTree[E]) Add(element E)

func (t *FuncTree[E]) All() iter.Seq[E]

func (t *FuncTree[E]) Has(element E) bool

type MethodTree ¶

type MethodTree[E Comparer[E]] struct {
	// contains filtered or unexported fields
}

The zero value of a MethodTree is a ready-to-use empty tree.

type Player struct {
    Name   string
    Rating int
}
func (p Player) Compare(q Player) int {
     return cmp.Compare(p.Rating, q.Rating)
}

var t MethodTree[Player]
t.Insert(Player{"Garry Kasparov", 2851})
t.Insert(Player{"Magnus Carlsen", 2882})
t.Insert(Player{"Bobby Fischer", 2785})
t.Insert(Player{"Anatoly Karpov", 2780})
t.Insert(Player{"Mikhail Tal", 2705})

for p := range t.All() {
     fmt.Println(p)
}

var t MethodTree[Player]
t.Add(Player{"Garry Kasparov", 2851})
t.Add(Player{"Magnus Carlsen", 2882})
t.Add(Player{"Bobby Fischer", 2785})
t.Add(Player{"Anatoly Karpov", 2780})
t.Add(Player{"Mikhail Tal", 2705})
for n := range t.All() {
	fmt.Println(n)
}

Output:

{Mikhail Tal 2705}
{Anatoly Karpov 2780}
{Bobby Fischer 2785}
{Garry Kasparov 2851}
{Magnus Carlsen 2882}

func (t *MethodTree[E]) Add(e E)

func (t *MethodTree[E]) All() iter.Seq[E]

func (t *MethodTree[E]) Has(element E) bool

type Tree ¶

type Tree[E cmp.Ordered] struct {
	// contains filtered or unexported fields
}

The zero value of a Tree is a ready-to-use empty tree.

var t Tree[string]
t.Insert("Garry Kasparov")
t.Insert("Magnus Carlsen")
t.Insert("Bobby Fischer")
t.Insert("Anatoly Karpov")
t.Insert("Mikhail Tal")
for n := range t.All() {
    fmt.Println(n)
}

var t Tree[string]
t.Add("Garry Kasparov")
t.Add("Magnus Carlsen")
t.Add("Bobby Fischer")
t.Add("Anatoly Karpov")
t.Add("Mikhail Tal")
for n := range t.All() {
	fmt.Println(n)
}

Output:

Anatoly Karpov
Bobby Fischer
Garry Kasparov
Magnus Carlsen
Mikhail Tal

func (t *Tree[E]) Add(element E)

func (t *Tree[E]) All() iter.Seq[E]

func (t *Tree[E]) Has(element E) bool