Lancet

English

简体中文

English

简体中文

Appearance

List ​

List is a linear table, implemented with slice.

Source ​

Usage ​

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

Index ​

Documentation ​

NewList ​

List is a linear table, implemented with slice. NewList function return a list pointer

Signature:

go
type List[T any] struct {
    data []T
}
func NewList[T any](data []T) *List[T]

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    fmt.Println(li)
}

Contain ​

Check if the value in the list or not

Signature:

go
func (l *List[T]) Contain(value T) bool

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})

    fmt.Println(li.Contain(1)) //true
    fmt.Println(li.Contain(0)) //false
}

Data ​

Return slice of list data

Signature:

go
func (l *List[T]) Data() []T

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    data := li.Data()

    fmt.Println(data) //[]int{1, 2, 3}
}

ValueOf ​

Return the value pointer at index in list

Signature:

go
func (l *List[T]) ValueOf(index int) (*T, bool)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    v, ok := li.ValueOf(0)

    fmt.Println(*v) //1
    fmt.Println(ok) //true
}

IndexOf ​

Returns the index of value in the list. if not found return -1

Signature:

go
func (l *List[T]) IndexOf(value T) int

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})

    fmt.Println(li.IndexOf(1)) //0
    fmt.Println(li.IndexOf(0)) //-1
}

LastIndexOf ​

Returns the index of the last occurrence of the value in this list if not found return -1

Signature:

go
func (l *List[T]) LastIndexOf(value T) int

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3, 1})

    fmt.Println(li.LastIndexOf(1)) // 3
    fmt.Println(li.LastIndexOf(0)) //-1
}

IndexOfFunc ​

IndexOfFunc returns the first index satisfying f(v). if not found return -1

Signature:

go
func (l *List[T]) IndexOfFunc(f func(T) bool) int

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})

    fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 1 })) //0
    fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
}

LastIndexOfFunc ​

LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying f(data[i]). if not found return -1

Signature:

go
func (l *List[T]) LastIndexOfFunc(f func(T) bool) int

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3, 1})

    fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
    fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 0 })) //-1
}

Push ​

Append value to the list

Signature:

go
func (l *List[T]) Push(value T)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    li.Push(4)

    fmt.Println(li.Data()) //[]int{1, 2, 3, 4}
}

PopFirst ​

Delete the first value of list and return it

Signature:

go
func (l *List[T]) PopFirst() (*T, bool)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    v, ok := li.PopFirst()

    fmt.Println(*v) //1
    fmt.Println(ok) //true
    fmt.Println(li.Data()) //2, 3
}

PopFirst ​

Delete the last value of list and return it

Signature:

go
func (l *List[T]) PopLast() (*T, bool)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    v, ok := li.PopLast()

    fmt.Println(*v) //3
    fmt.Println(ok) //true
    fmt.Println(li.Data()) //1, 2
}

DeleteAt ​

Delete the value of list at index, if index is not between 0 and length of list data, do nothing

Signature:

go
func (l *List[T]) DeleteAt(index int)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3, 4})

    li.DeleteAt(-1)
    fmt.Println(li.Data()) //1,2,3,4

    li.DeleteAt(4)
    fmt.Println(li.Data()) //1,2,3,4

    li.DeleteAt(0)
    fmt.Println(li.Data()) //2,3,4

    li.DeleteAt(2)
    fmt.Println(li.Data()) //2,3
}

InsertAt ​

Insert value into list at index, if index is not between 0 and length of list data, do nothing

Signature:

go
func (l *List[T]) InsertAt(index int, value T)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})

    li.InsertAt(-1, 0)
    fmt.Println(li.Data()) //1,2,3

    li.InsertAt(4, 0)
    fmt.Println(li.Data()) //1,2,3

    li.InsertAt(3, 4)
    fmt.Println(li.Data()) //1,2,3,4

    // li.InsertAt(2, 4)
    // fmt.Println(li.Data()) //1,2,4,3
}

UpdateAt ​

Update value of list at index, index shoud between 0 and list size - 1

Signature:

go
func (l *List[T]) UpdateAt(index int, value T)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})

    li.UpdateAt(-1, 0)
    fmt.Println(li.Data()) //1,2,3

    li.UpdateAt(2, 4)
    fmt.Println(li.Data()) //1,2,4

    li.UpdateAt(3, 5)
    fmt.Println(li.Data()) //1,2,4
}

Equal ​

Compare a list to another list, use reflect.DeepEqual on every element

Signature:

go
func (l *List[T]) Equal(other *List[T]) bool

Example:

go
package main

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

func main() {
    li1 := list.NewList([]int{1, 2, 3, 4})
    li2 := list.NewList([]int{1, 2, 3, 4})
    li3 := list.NewList([]int{1, 2, 3})

    fmt.Println(li1.Equal(li2)) //true
    fmt.Println(li1.Equal(li3)) //false
}

IsEmpty ​

Check if a list is empty or not

Signature:

go
func (l *List[T]) IsEmpty() bool

Example:

go
package main

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

func main() {
    li1 := list.NewList([]int{1, 2, 3})
    li2 := list.NewList([]int{})

    fmt.Println(li1.IsEmpty()) //false
    fmt.Println(li2.IsEmpty()) //true
}

Clear ​

Clear the data of list

Signature:

go
func (l *List[T]) Clear()

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    li.Clear()

    fmt.Println(li.Data()) // empty
}

Clone ​

Return a copy of list

Signature:

go
func (l *List[T]) Clone() *List[T]

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3})
    cloneList := li.Clone()

    fmt.Println(cloneList.Data()) // 1,2,3
}

Merge ​

Merge two list, return new list, don't change original list

Signature:

go
func (l *List[T]) Merge(other *List[T]) *List[T]

Example:

go
package main

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

func main() {
    li1 := list.NewList([]int{1, 2, 3, 4})
    li2 := list.NewList([]int{4, 5, 6})
    li3 := li1.Merge(li2)

    fmt.Println(li3.Data()) //1, 2, 3, 4, 4, 5, 6
}

Size ​

Return number of list data items

Signature:

go
func (l *List[T]) Size() int

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3, 4})

    fmt.Println(li.Size()) //4
}

Cap ​

Cap return cap of the inner data

Signature:

go
func (l *List[T]) Cap() int

Example:

go
package main

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

func main() {
    data := make([]int, 0, 100)
    
    li := list.NewList(data)

    fmt.Println(li.Cap()) // 100
}

Swap ​

Swap the value at two index in list

Signature:

go
func (l *List[T]) Swap(i, j int)

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3, 4})
    li.Swap(0, 3)

    fmt.Println(li.Data()) //4, 2, 3, 1
}

Reverse ​

Reverse the data item order of list

Signature:

go
func (l *List[T]) Reverse()

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 3, 4})
    li.Reverse()

    fmt.Println(li.Data()) //4, 3, 2, 1
}

Unique ​

Remove duplicate items in list

Signature:

go
func (l *List[T]) Unique()

Example:

go
package main

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

func main() {
    li := list.NewList([]int{1, 2, 2, 3, 4})
    li.Unique()

    fmt.Println(li.Data()) //1,2,3,4
}

Union ​

Creates a new list contain all elements in list l and other, remove duplicate element

Signature:

go
func (l *List[T]) Union(other *List[T]) *List[T]

Example:

go
package main

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

func main() {
    li1 := list.NewList([]int{1, 2, 3, 4})
    li2 := list.NewList([]int{4, 5, 6})
    li3 := li1.Union(li2)

    fmt.Println(li3.Data()) //1,2,3,4,5,6
}

Intersection ​

Creates a new list whose element both be contained in list l and other

Signature:

go
func (l *List[T]) Intersection(other *List[T]) *List[T]

Example:

go
package main

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

func main() {
    li1 := list.NewList([]int{1, 2, 3, 4})
    li2 := list.NewList([]int{4, 5, 6})
    li3 := li1.Intersection(li2)

    fmt.Println(li3.Data()) //4
}

Difference ​

Return a list whose element in the original list, not in the given list.

Signature:

go
func (l *List[T]) Difference(other *List[T]) *List[T]

Example:

go
package main

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

func main() {
    list1 := NewList([]int{1, 2, 3})
    list2 := NewList([]int{1, 2, 4})

    list3 := list1.Intersection(list2)

    fmt.Println(list3.Data()) //3
}

SymmetricDifference ​

Oppoiste operation of intersection function.

Signature:

go
func (l *List[T]) SymmetricDifference(other *List[T]) *List[T]

Example:

go
package main

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

func main() {
    list1 := NewList([]int{1, 2, 3})
    list2 := NewList([]int{1, 2, 4})

    list3 := list1.Intersection(list2)

    fmt.Println(list3.Data()) //3, 4
}

RetainAll ​

Retains only the elements in this list that are contained in the given list.

Signature:

go
func (l *List[T]) RetainAll(list *List[T]) bool

Example:

go
package main

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

func main() {
    list := NewList([]int{1, 2, 3, 4})
    list1 := NewList([]int{1, 2, 3, 4})
    list2 := NewList([]int{1, 2, 3, 4})

    retain := NewList([]int{1, 2})
    retain1 := NewList([]int{2, 3})
    retain2 := NewList([]int{1, 2, 5})

    list.RetainAll(retain)
    list1.RetainAll(retain1)
    list2.RetainAll(retain2)

    fmt.Println(list.Data()) //1, 2
    fmt.Println(list1.Data()) //2, 3
    fmt.Println(list2.Data()) //1, 2
}

DeleteAll ​

Removes from this list all of its elements that are contained in the given list.

Signature:

go
func (l *List[T]) DeleteAll(list *List[T]) bool

Example:

go
package main

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

func main() {
    list := NewList([]int{1, 2, 3, 4})
    list1 := NewList([]int{1, 2, 3, 4})
    list2 := NewList([]int{1, 2, 3, 4})

    del := NewList([]int{1})
    del1 := NewList([]int{2, 3})
    del2 := NewList([]int{1, 2, 5})

    list.DeleteAll(del)
    list1.DeleteAll(del1)
    list2.DeleteAll(del2)

    fmt.Println(list.Data()) //2,3,4
    fmt.Println(list1.Data()) //1,4
    fmt.Println(list2.Data()) //3,4
}

ForEach ​

Performs the given action for each element of the list.

Signature:

go
func (l *List[T]) ForEach(consumer func(T))

Example:

go
package main

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

func main() {
    list := NewList([]int{1, 2, 3, 4})

    result := make([]int, 0)
    list.ForEach(func(i int) {
        result = append(result, i)
    })

    fmt.Println(result.Data()) //1,2,3,4
}

Iterator ​

Returns an iterator over the elements in this list in proper sequence.

Signature:

go
func (l *List[T]) Iterator() iterator.Iterator[T]

Example:

go
package main

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

func main() {
    list := NewList([]int{1, 2, 3, 4})

    iterator := list.Iterator()

    result := make([]int, 0)
    for iterator.HasNext() {
        item, _ := iterator.Next()
        result = append(result, item)
    }

    fmt.Println(result.Data()) //1,2,3,4
}

ListToMap ​

Converts a list to a map based on iteratee function.

Signature:

go
func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V

Example:

go
package main

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

func main() {
    list := NewList([]int{1, 2, 3, 4})

    result := ListToMap(list, func(n int) (int, bool) {
        return n, n > 1
    })

    fmt.Println(result) //map[int]bool{1: false, 2: true, 3: true, 4: true}
}

SubList ​

SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.

Signature:

go
func (l *List[T]) SubList(fromIndex, toIndex int) *List[T]

Example:

go
package main

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

func main() {
    l := list.NewList([]int{1, 2, 3, 4, 5, 6})
   
    fmt.Println(l.SubList(2, 5)) // []int{3, 4, 5}
}

DeleteIf ​

DeleteIf delete all satisfying f(data[i]), returns count of removed elements

Signature:

go
func (l *List[T]) DeleteIf(f func(T) bool) int

Example:

go
package main

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

func main() {
    l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})

    fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
    fmt.Println(l.Data()) // []int{2, 3, 4}
}