Skip to content

Latest commit

 

History

History
710 lines (496 loc) · 11.2 KB

set.md

File metadata and controls

710 lines (496 loc) · 11.2 KB
Raw

Set

Set is a data container, like list, but elements of set is not duplicate.

Source

Usage

import (
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

Index

Documentation

New

Create a set instance

Signature:

type Set[T comparable] map[T]struct{}
func New[T comparable](items ...T) Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int](1,2,2,3)
    fmt.Println(st.Values()) //1,2,3
}

FromSlice

Create a set from slice

Signature:

func FromSlice[T comparable](items []T) Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.FromSlice([]int{1, 2, 2, 3})
    fmt.Println(st.Values()) //1,2,3
}

Values

Return slice of all set data.

⚠️ This function is deprecated. use ToSlice instead.

Signature:

func (s Set[T]) Values() []T

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int](1,2,2,3)
    fmt.Println(st.Values()) //1,2,3
}

Add

Add items to set

Signature:

func (s Set[T]) Add(items ...T)

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int]()
    st.Add(1, 2, 3)

    fmt.Println(st.Values()) //1,2,3
}

AddIfNotExist

AddIfNotExist checks if item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.

Signature:

func (s Set[T]) AddIfNotExist(item T) bool

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int]()
    st.Add(1, 2, 3)

    r1 := st.AddIfNotExist(1)
    r2 := st.AddIfNotExist(4)

    fmt.Println(r1) // false
    fmt.Println(r2) // true
    fmt.Println(st.Values()) // 1,2,3,4
}

AddIfNotExistBy

AddIfNotExistBy checks if item exists in the set and pass the `checker` function it adds the item to set and returns true if it does not exists in the set and function `checker` returns true, or else it does nothing and returns false.

Signature:

func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int]()
    st.Add(1, 2)

    ok := st.AddIfNotExistBy(3, func(val int) bool {
        return val%2 != 0
    })
    fmt.Println(ok) // true


    notOk := st.AddIfNotExistBy(4, func(val int) bool {
        return val%2 != 0
    })
    fmt.Println(notOk) // false

    fmt.Println(st.Values()) // 1, 2, 3
}

Delete

Delete item in set

Signature:

func (s Set[T]) Delete(items ...T)

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int]()
    st.Add(1, 2, 3)

    set.Delete(3)
    fmt.Println(st.Values()) //1,2
}

Contain

Check if item is in set or not

Signature:

func (s Set[T]) Contain(item T) bool

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    st := set.New[int]()
    st.Add(1, 2, 3)

    fmt.Println(st.Contain(1)) //true
    fmt.Println(st.Contain(4)) //false
}

ContainAll

Checks if set contains another set

Signature:

func (s Set[T]) ContainAll(other Set[T]) bool

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New(1, 2)
    set3 := set.New(1, 2, 3, 4)

    fmt.Println(set1.ContainAll(set2)) //true
    fmt.Println(set1.ContainAll(set3)) //false
}

Size

Get the number of elements in set

Signature:

func (s Set[T]) Size() int

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)

    fmt.Println(set1.Size()) //3
}

Clone

Make a copy of set

Signature:

func (s Set[T]) Clone() Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set1.Clone()

    fmt.Println(set1.Size() == set2.Size()) //true
    fmt.Println(set1.ContainAll(set2)) //true
}

Equal

Check if two sets has same elements or not

Signature:

func (s Set[T]) Equal(other Set[T]) bool

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New(1, 2, 3)
    set3 := set.New(1, 2, 3, 4)

    fmt.Println(set1.Equal(set2)) //true
    fmt.Println(set1.Equal(set3)) //false
}

Iterate

Call function by every element of set

Signature:

func (s Set[T]) Iterate(fn func(item T))

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    arr := []int{}
    set.Iterate(func(item int) {
        arr = append(arr, item)
    })

    fmt.Println(arr) //1,2,3
}

EachWithBreak

Iterates over elements of a set and invokes function for each element, when iteratee return false, will break the for each loop.

Signature:

func (s Set[T]) EachWithBreak(iteratee func(item T) bool)

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    s := set.New(1, 2, 3, 4, 5)

    var sum int

    s.EachWithBreak(func(n int) bool {
        if n > 3 {
            return false
        }
        sum += n
        return true
    })

    fmt.Println(sum) //6
}

IsEmpty

Check if the set is empty or not

Signature:

func (s Set[T]) IsEmpty() bool

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New()

    fmt.Println(set1.IsEmpty()) //false
    fmt.Println(set2.IsEmpty()) //true
}

Union

Create a new set contain all element of set s and other

Signature:

func (s Set[T]) Union(other Set[T]) Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New(2, 3, 4, 5)
    set3 := set1.Union(set2)

    fmt.Println(set3.Values()) //1,2,3,4,5
}

Intersection

Create a new set whose element both be contained in set s and other

Signature:

func (s Set[T]) Intersection(other Set[T]) Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New(2, 3, 4, 5)
    set3 := set1.Intersection(set2)

    fmt.Println(set3.Values()) //2,3
}

SymmetricDifference

Create a new set whose element is in set1 or set2, but not in both set1 and set2

Signature:

func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New(2, 3, 4, 5)
    set3 := set1.SymmetricDifference(set2)

    fmt.Println(set3.Values()) //1,4,5
}

Minus

Create an set of whose element in origin set but not in compared set

Signature:

func (s Set[T]) Minus(comparedSet Set[T]) Set[T]

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    set1 := set.New(1, 2, 3)
    set2 := set.New(2, 3, 4, 5)
    set3 := set.New(2, 3)

    res1 := set1.Minus(set2)
    fmt.Println(res1.Values()) //1

    res2 := set2.Minus(set3)
    fmt.Println(res2.Values()) //4,5
}

Pop

Delete the top element of set then return it, if set is empty, return nil-value of T and false.

Signature:

func (s Set[T]) Pop() (v T, ok bool)

Example:

package main

import (
    "fmt"
    set "github.com/duke-git/lancet/v2/datastructure/set"
)

func main() {
    s := set.New[int]()
    s.Add(1)
    s.Add(2)
    s.Add(3)

    val, ok = s.Pop()

    fmt.Println(val) // 3
    fmt.Println(ok) // true
}

ToSlice

returns a slice containing all values of the set.

Signature:

func (s Set[T]) ToSlice() (v T, ok bool)

Example:

func main() {
    s := set.New(1, 2, 3, 4, 5)

    val := s.ToSlice()
    fmt.Println(val) // [2 3 4 5 1]
}

ToSortedSlice

returns a sorted slice containing all values of the set

Signature:

func (s Set[T]) ToSortedSlice() (v T, ok bool)

Example:

func main() {
    s1 := set.New(1, 2, 3, 4, 5)
    type Person struct {
		Name string
		Age  int
	}
	s2 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})

    res1 := s1.ToSortedSlice(func(v1, v2 int) bool {
		return v1 < v2
	})
    
    res2 := s2.ToSortedSlice(func(v1, v2 Person) bool {
		return v1.Age < v2.Age
	})
    
    fmt.Println(res1) // [1 2 3 4 5]
    fmt.Println(res2) // [{Jerry 18} {Tom 20} {Spike 25}]
}