import{_ as l,o as p,c as o,k as s,a,X as n}from"./chunks/framework.6e839c56.js";const S=JSON.parse('{"title":"Set","description":"","frontmatter":{},"headers":[],"relativePath":"api/packages/datastructure/set.md","filePath":"api/packages/datastructure/set.md"}'),e={name:"api/packages/datastructure/set.md"},t=s("h1",{id:"Set",tabindex:"-1"},[a("Set "),s("a",{class:"header-anchor",href:"#Set","aria-label":'Permalink to "Set"'},"​")],-1),c=s("p",null,"Set 集合数据结构，类似列表。Set 中元素不重复。",-1),r=s("div",{STYLE:"page-break-after: always;"},null,-1),y=s("h2",{id:"源码",tabindex:"-1"},[a("源码 "),s("a",{class:"header-anchor",href:"#源码","aria-label":'Permalink to "源码"'},"​")],-1),F=s("ul",null,[s("li",null,[s("a",{href:"https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go",target:"_blank",rel:"noreferrer"},"https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go")])],-1),i=s("div",{STYLE:"page-break-after: always;"},null,-1),A=n(`

用法 ​

go
import (
    set "github.com/duke-git/lancet/v2/datastructure/set"
)
import (
    set "github.com/duke-git/lancet/v2/datastructure/set"
)
`,2),E=s("div",{STYLE:"page-break-after: always;"},null,-1),d=n('

目录 ​

',2),u=s("div",{STYLE:"page-break-after: always;"},null,-1),g=n(`

文档 ​

NewSet ​

返回Set结构体对象

函数签名:

go
type Set[T comparable] map[T]bool
func NewSet[T comparable](items ...T) Set[T]
type Set[T comparable] map[T]bool
func NewSet[T comparable](items ...T) Set[T]

示例:

go
package main

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

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

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

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

NewSetFromSlice ​

基于切片创建集合

函数签名:

go
func NewSetFromSlice[T comparable](items []T) Set[T]
func NewSetFromSlice[T comparable](items []T) Set[T]

示例:

go
package main

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

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

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

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

Values ​

获取集合中所有元素的切片

函数签名:

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

示例:

go
package main

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

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

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

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

Add ​

向集合中添加元素

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

AddIfNotExist ​

如果集合中不存在元素，则添加该元素返回true, 如果集合中存在元素, 不做任何操作，返回false

函数签名:

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

示例:

go
package main

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

func main() {
    st := set.NewSet[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
}
package main

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

func main() {
    st := set.NewSet[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 ​

根据checker函数判断元素是否在集合中，如果集合中不存在元素且checker返回true，则添加该元素返回true, 否则不做任何操作，返回false

函数签名:

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

示例:

go
package main

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

func main() {
    st := set.NewSet[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
}
package main

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

func main() {
    st := set.NewSet[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 ​

删除集合中元素

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Contain ​

判断集合是否包含某个值

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

ContainAll ​

判断集合是否包含另一个集合

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Size ​

获取集合中元素的个数

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Clone ​

克隆一个集合

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Equal ​

比较两个集合是否相等，包含相同元素为相等

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Iterate ​

迭代结合，在每个元素上调用函数

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

EachWithBreak ​

遍历集合的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。

函数签名:

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

示例:

go
package main

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

func main() {
    s := set.NewSet(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
}
package main

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

func main() {
    s := set.NewSet(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 ​

判断集合是否为空

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Union ​

求两个集合的并集

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Intersection ​

求两个集合的交集

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

SymmetricDifference ​

返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

Minus ​

创建一个集合，其元素在原始集中但不在比较集中

函数签名:

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

示例:

go
package main

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

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

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

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

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

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

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

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

Pop ​

删除并返回集合中的顶部元素

函数签名:

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

示例:

go
package main

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

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

    val, ok = s.Pop()

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

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

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

    val, ok = s.Pop()

    fmt.Println(val) // 3
    fmt.Println(ok) // true
}
`,121),h=[t,c,r,y,F,i,A,E,d,u,g];function m(f,B,v,b,C,k){return p(),o("div",null,h)}const D=l(e,[["render",m]]);export{S as __pageData,D as default};