链表类

package
v0.0.0-...-2910145 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 14, 2024 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

包glist提供了最常用的双向链表容器，同时支持并发安全/非安全模式切换功能。

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Element 

type Element = list.Element

Element 表示列表中元素的类型。

type List 

type List struct {
	// contains filtered or unexported fields
}

List 是一个包含并发安全/不安全切换功能的双向链表。 这个切换开关应在初始化时设定，并且之后不能更改。 在这里，“并发安全”意味着这个链表在多线程或协程环境下可以安全地进行读写操作，而“并发不安全”则表示在未采取额外同步措施的情况下，同时访问可能会导致数据竞争问题。初始化后不允许改变这个安全属性设置。

func New 

func New(safe ...bool) *List

New 创建并返回一个新的空双向链表。

Example 
n := 10
l := 链表类.New()
for i := 0; i < n; i++ {
	l.PushBack(i)
}

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.FrontAll())
fmt.Println(l.BackAll())

for i := 0; i < n; i++ {
	fmt.Print(l.PopFront())
}

fmt.Println()
fmt.Println(l.Len())

Output:

10
[0,1,2,3,4,5,6,7,8,9]
[0 1 2 3 4 5 6 7 8 9]
[9 8 7 6 5 4 3 2 1 0]
0123456789
0

func NewFrom 

func NewFrom(array []interface{}, safe ...bool) *List

NewFrom 函数通过复制给定的切片 `array` 创建并返回一个列表。 参数 `safe` 用于指定是否在并发安全模式下使用该列表，默认情况下为 false。

Example 
n := 10
l := 链表类.NewFrom(数组类.X创建并按范围(1, 10, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.FrontAll())
fmt.Println(l.BackAll())

for i := 0; i < n; i++ {
	fmt.Print(l.PopFront())
}

fmt.Println()
fmt.Println(l.Len())

Output:

10
[1,2,3,4,5,6,7,8,9,10]
[1 2 3 4 5 6 7 8 9 10]
[10 9 8 7 6 5 4 3 2 1]
12345678910
0

func (*List) Back 

func (l *List) Back() (e *Element)

Back 返回列表 `l` 的最后一个元素，如果列表为空则返回 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Back().Value)
fmt.Println(l)

e := l.Back()
l.InsertBefore(e, "a")
l.InsertAfter(e, 6)

fmt.Println(l)

Output:

5
[1,2,3,4,5]
[1,2,3,4,a,5,6]

func (*List) BackAll 

func (l *List) BackAll() (values []interface{})

BackAll 从切片 `l` 的末尾开始复制所有元素的值，并以一个新的切片形式返回。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l)
fmt.Println(l.BackAll())

Output:

[1,2,3,4,5]
[5 4 3 2 1]

func (*List) BackValue 

func (l *List) BackValue() (value interface{})

BackValue 返回 `l` 列表最后一个元素的值，如果列表为空则返回 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l)
fmt.Println(l.BackValue())

Output:

[1,2,3,4,5]
5

func (*List) Clear 

func (l *List) Clear()

Clear 是 RemoveAll 的别名。

func (*List) DeepCopy 

func (l *List) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (*List) Front 

func (l *List) Front() (e *Element)

Front 返回列表 `l` 的第一个元素，如果列表为空，则返回 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Front().Value)
fmt.Println(l)

e := l.Front()
l.InsertBefore(e, 0)
l.InsertAfter(e, "a")

fmt.Println(l)

Output:

1
[1,2,3,4,5]
[0,1,a,2,3,4,5]

func (*List) FrontAll 

func (l *List) FrontAll() (values []interface{})

FrontAll 从切片 `l` 的开头复制并返回所有元素的值作为新的切片。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l)
fmt.Println(l.FrontAll())

Output:

[1,2,3,4,5]
[1 2 3 4 5]

func (*List) FrontValue 

func (l *List) FrontValue() (value interface{})

FrontValue 返回 `l`（链表）的第一个元素的值，如果链表为空则返回 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l)
fmt.Println(l.FrontValue())

Output:

[1,2,3,4,5]
1

func (*List) InsertAfter 

func (l *List) InsertAfter(p *Element, v interface{}) (e *Element)

InsertAfter 在元素 `p` 后立即插入一个新元素 `e`，其值为 `v`，并返回 `e`。 若 `p` 不是列表 `l` 的成员，则列表不会被修改。 参数 `p` 必须不为空。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.InsertAfter(l.Front(), "a")
l.InsertAfter(l.Back(), "b")

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
7
[1,a,2,3,4,5,b]

func (*List) InsertBefore 

func (l *List) InsertBefore(p *Element, v interface{}) (e *Element)

InsertBefore在元素`p`之前立即插入一个新元素`e`，其值为`v`并返回`e`。 如果`p`不是列表`l`中的元素，则列表不会被修改。 参数`p`必须不为nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.InsertBefore(l.Front(), "a")
l.InsertBefore(l.Back(), "b")

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
7
[a,1,2,3,4,b,5]

func (*List) IteratorAsc 

func (l *List) IteratorAsc(f func(e *Element) bool)

IteratorAsc 以升序遍历列表，并使用给定的回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止遍历。

Example 
// 并发安全列表。
l := 链表类.NewFrom(数组类.X创建并按范围(1, 10, 1).X取切片(), true)
// 使用IteratorAsc从头部开始进行迭代读取。
l.IteratorAsc(func(e *链表类.Element) bool {
	fmt.Print(e.Value)
	return true
})

Output:

12345678910

func (*List) IteratorDesc 

func (l *List) IteratorDesc(f func(e *Element) bool)

IteratorDesc 以降序方式遍历给定的只读列表，并使用回调函数 `f` 进行处理。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

Example 
// 并发安全列表。
l := 链表类.NewFrom(数组类.X创建并按范围(1, 10, 1).X取切片(), true)
// 使用IteratorDesc从尾部开始迭代读取
l.IteratorDesc(func(e *链表类.Element) bool {
	fmt.Print(e.Value)
	return true
})

Output:

10987654321

func (*List) Join 

func (l *List) Join(glue string) string

Join通过字符串`glue`连接列表元素。

Example 
var l 链表类.List
l.PushBacks(g.Slice别名{"a", "b", "c", "d"})

fmt.Println(l.Join(","))

Output:

a,b,c,d

func (*List) Len 

func (l *List) Len() (length int)

Len 返回列表 `l` 的元素个数。 时间复杂度为 O(1)。

Example 
l := 链表类.NewFrom(g.Slice别名{1, 2, 3, 4, 5})

fmt.Println(l.Len())

Output:

5

func (*List) LockFunc 

func (l *List) LockFunc(f func(list *list.List))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

Example 
// 并发安全列表。
l := 链表类.NewFrom(数组类.X创建并按范围(1, 10, 1).X取切片(), true)
// 从头部开始进行迭代写入。
l.LockFunc(func(list *list.List) {
	length := list.Len()
	if length > 0 {
		for i, e := 0, list.Front(); i < length; i, e = i+1, e.Next() {
			if e.Value == 6 {
				e.Value = "M"
				break
			}
		}
	}
})
fmt.Println(l)

Output:

[1,2,3,4,5,M,7,8,9,10]

func (List) MarshalJSON 

func (l List) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

func (*List) MoveAfter 

func (l *List) MoveAfter(e, p *Element)

MoveAfter 将元素 `e` 移动到新位置，即在元素 `p` 之后。 如果 `e` 或 `p` 不是列表 `l` 的成员，或者 `e` 和 `p` 相等，则列表不会被修改。 元素 `e` 和 `p` 都不能为空（nil）。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Size())
fmt.Println(l)

// element of `l`
e := l.PushFront(0)
fmt.Println(l.Size())
fmt.Println(l)

l.MoveAfter(e, l.Back())

fmt.Println(l.Size())
fmt.Println(l)

// 不是 `l` 的元素
e = &链表类.Element{Value: -1}
l.MoveAfter(e, l.Back())

fmt.Println(l.Size())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
6
[0,1,2,3,4,5]
6
[1,2,3,4,5,0]
6
[1,2,3,4,5,0]

func (*List) MoveBefore 

func (l *List) MoveBefore(e, p *Element)

MoveBefore 将元素 `e` 移动到其在 `p` 之前的新位置。 如果 `e` 或 `p` 不是 `l` 列表中的元素，或者 `e` 和 `p` 相等，则列表不会被修改。 元素 `e` 和 `p` 都必须不为 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Size())
fmt.Println(l)

// element of `l`
e := l.PushBack(6)
fmt.Println(l.Size())
fmt.Println(l)

l.MoveBefore(e, l.Front())

fmt.Println(l.Size())
fmt.Println(l)

// 不是 `l` 的元素
e = &链表类.Element{Value: 7}
l.MoveBefore(e, l.Front())

fmt.Println(l.Size())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
6
[1,2,3,4,5,6]
6
[6,1,2,3,4,5]
6
[6,1,2,3,4,5]

func (*List) MoveToBack 

func (l *List) MoveToBack(e *Element)

MoveToBack 将元素 `e` 移动到列表 `l` 的末尾。 如果 `e` 不是列表 `l` 中的元素，则列表不会被修改。 此元素必须不为 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Size())
fmt.Println(l)

// element of `l`
l.MoveToBack(l.Front())

fmt.Println(l.Size())
fmt.Println(l)

// 不是 `l` 的元素
e := &链表类.Element{Value: 0}
l.MoveToBack(e)

fmt.Println(l.Size())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
5
[2,3,4,5,1]
5
[2,3,4,5,1]

func (*List) MoveToFront 

func (l *List) MoveToFront(e *Element)

MoveToFront 将元素 `e` 移动到列表 `l` 的前端。 如果 `e` 不是列表 `l` 的一个元素，则列表不会被修改。 此元素必须不为空（nil）。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Size())
fmt.Println(l)

// element of `l`
l.MoveToFront(l.Back())

fmt.Println(l.Size())
fmt.Println(l)

// 不是 `l` 的元素
e := &链表类.Element{Value: 6}
l.MoveToFront(e)

fmt.Println(l.Size())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
5
[5,1,2,3,4]
5
[5,1,2,3,4]

func (*List) PopBack 

func (l *List) PopBack() (value interface{})

PopBack从`l`的末尾移除元素，并返回该元素的值。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.PopBack())
fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
5
4
[1,2,3,4]

func (*List) PopBackAll 

func (l *List) PopBackAll() []interface{}

PopBackAll 从 `l` 的后部移除所有元素，并将移除元素的值以切片形式返回。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.PopBackAll())
fmt.Println(l.Len())

Output:

5
[1,2,3,4,5]
[5 4 3 2 1]
0

func (*List) PopBacks 

func (l *List) PopBacks(max int) (values []interface{})

PopBacks 从 `l` 的尾部移除最多 `max` 个元素， 并将移除元素的值以切片形式返回。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.PopBacks(2))
fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
[5 4]
3
[1,2,3]

func (*List) PopFront 

func (l *List) PopFront() (value interface{})

PopFront从`l`的前端移除元素，并返回该元素的值。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.PopFront())
fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
1
4
[2,3,4,5]

func (*List) PopFrontAll 

func (l *List) PopFrontAll() []interface{}

PopFrontAll从`l`的前端移除所有元素，并将已移除元素的值以切片形式返回。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.PopFrontAll())
fmt.Println(l.Len())

Output:

5
[1,2,3,4,5]
[1 2 3 4 5]
0

func (*List) PopFronts 

func (l *List) PopFronts(max int) (values []interface{})

PopFronts 从 `l`（列表）的前端移除最多`max`个元素， 并将已移除元素的值以切片形式返回。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)
fmt.Println(l.PopFronts(2))
fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
[1 2]
3
[3,4,5]

func (*List) PushBack 

func (l *List) PushBack(v interface{}) (e *Element)

PushBack在列表`l`的尾部插入一个新元素，并将该元素的值设为`v`，然后返回这个新插入的元素`e`。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.PushBack(6)

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
6
[1,2,3,4,5,6]

func (*List) PushBackList 

func (l *List) PushBackList(other *List)

PushBackList将另一个列表的副本插入到列表`l`的末尾。 列表`l`和`other`可以是同一个列表，但它们都必须不为nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Size())
fmt.Println(l)

other := 链表类.NewFrom(g.Slice别名{6, 7, 8, 9, 10})

fmt.Println(other.Size())
fmt.Println(other)

l.PushBackList(other)

fmt.Println(l.Size())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
5
[6,7,8,9,10]
10
[1,2,3,4,5,6,7,8,9,10]

func (*List) PushBacks 

func (l *List) PushBacks(values []interface{})

PushBacks在列表`l`的尾部插入多个新元素，其值为`values`。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.PushBacks(g.Slice别名{6, 7, 8, 9, 10})

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
10
[1,2,3,4,5,6,7,8,9,10]

func (*List) PushFront 

func (l *List) PushFront(v interface{}) (e *Element)

PushFront在列表`l`的前端插入一个具有值`v`的新元素`e`，并返回`e`。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.PushFront(0)

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
6
[0,1,2,3,4,5]

func (*List) PushFrontList 

func (l *List) PushFrontList(other *List)

PushFrontList 将另一个列表的副本插入到列表 `l` 的前端。 列表 `l` 和 `other` 可能相同，但它们都必须不为 nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Size())
fmt.Println(l)

other := 链表类.NewFrom(g.Slice别名{-4, -3, -2, -1, 0})

fmt.Println(other.Size())
fmt.Println(other)

l.PushFrontList(other)

fmt.Println(l.Size())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
5
[-4,-3,-2,-1,0]
10
[-4,-3,-2,-1,0,1,2,3,4,5]

func (*List) PushFronts 

func (l *List) PushFronts(values []interface{})

PushFronts 在列表 `l` 的前端插入多个新元素，这些元素的值为 `values`。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.PushFronts(g.Slice别名{0, -1, -2, -3, -4})

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
10
[-4,-3,-2,-1,0,1,2,3,4,5]

func (*List) RLockFunc 

func (l *List) RLockFunc(f func(list *list.List))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

Example 
// 并发安全列表。
l := 链表类.NewFrom(数组类.X创建并按范围(1, 10, 1).X取切片(), true)
// 从头部开始迭代读取
l.RLockFunc(func(list *list.List) {
	length := list.Len()
	if length > 0 {
		for i, e := 0, list.Front(); i < length; i, e = i+1, e.Next() {
			fmt.Print(e.Value)
		}
	}
})
fmt.Println()
// 从尾部开始迭代读取
l.RLockFunc(func(list *list.List) {
	length := list.Len()
	if length > 0 {
		for i, e := 0, list.Back(); i < length; i, e = i+1, e.Prev() {
			fmt.Print(e.Value)
		}
	}
})

fmt.Println()

Output:

12345678910
10987654321

func (*List) Remove 

func (l *List) Remove(e *Element) (value interface{})

Remove从列表`l`中删除元素`e`，如果`e`是列表`l`中的一个元素。 它返回元素的值e.Value。 该元素必须不为nil。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

fmt.Println(l.Remove(l.Front()))
fmt.Println(l.Remove(l.Back()))

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
1
5
3
[2,3,4]

func (*List) RemoveAll 

func (l *List) RemoveAll()

RemoveAll 从列表 `l` 中移除所有元素。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.RemoveAll()

fmt.Println(l.Len())

Output:

5
[1,2,3,4,5]
0

func (*List) Removes 

func (l *List) Removes(es []*Element)

Removes 从列表 `l` 中移除多个元素 `es`，条件是 `es` 是列表 `l` 中的元素。

Example 
l := 链表类.NewFrom(数组类.X创建并按范围(1, 5, 1).X取切片())

fmt.Println(l.Len())
fmt.Println(l)

l.Removes([]*链表类.Element{l.Front(), l.Back()})

fmt.Println(l.Len())
fmt.Println(l)

Output:

5
[1,2,3,4,5]
3
[2,3,4]

func (*List) Size 

func (l *List) Size() int

Size 是 Len 的别名。

Example 
l := 链表类.NewFrom(g.Slice别名{1, 2, 3, 4, 5})

fmt.Println(l.Size())

Output:

5

func (*List) String 

func (l *List) String() string

String 函数返回当前列表作为字符串表示。

func (*List) UnmarshalJSON 

func (l *List) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

func (*List) UnmarshalValue 

func (l *List) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为列表设置任何类型的值。

func (*List) X遍历 

func (l *List) X遍历(f func(e *Element) bool)

Iterator 是 IteratorAsc 的别名。

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.