综合技术

golang中container/ring包

微信扫一扫,分享到朋友圈

golang中container/ring包
0

ring包实现了环形双向链表的功能。

type Ring
        func New(n int) *Ring
        func (r *Ring) Do(f func(interface{}))
        func (r *Ring) Len() int
        func (r *Ring) Link(s *Ring) *Ring
        func (r *Ring) Move(n int) *Ring
        func (r *Ring) Next() *Ring
        func (r *Ring) Prev() *Ring
        func (r *Ring) Unlink(n int) *Ring

结构体:

type Ring

// 环形双向链表
type Ring struct {
        next, prev *Ring
        Value interface{}
}

1)next *Ring:指向链表中的下一个节点的指针
2)prev *Ring:指向链表中的上一个节点的指针
3)Value interface{}:该节点中存储的内容,可以是任何对象

方法:

(1)func (r *Ring) New(int) *Ring

参数列表:

n:环形双向链表的节点的个数

返回值:

*Ring:空链表的指针

功能说明:

创建一个有n个节点的环形双向链表,链表上的每个元素的初始值是nil

(2)func (r *Ring) Do(f func(interface{}))

参数列表:

f:一个回调函数,该函数的参数为环形双向链表中的节点的Value字段值

功能说明:

正向遍历环形双向链表,并对每个链表中的元素执行回调函数f,如果这个函数f会修改链表r,那这个回调函数的行为将不可确定

为环形双向链表实例并初始化以及将环形双向链表数据打印出来

package main

import (
    "container/ring"
    "fmt"
)

func main() {
    r := ring.New(10)
    for i := 1;i <= 10;i++ {
        r.Value = i
        r = r.Next()
    }
    r.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
}

(3)func (r *Ring) Len() int

返回值:

int:环形链表中元素的个数

功能说明:获取环形链表中元素的个数

package main

import (
    "container/ring"
    "fmt"
)

func main() {
    r := ring.New(10)
    fmt.Println(r.Len())
}

(4)func (r *Ring) Move(n int) *Ring

参数列表:

n:指针r在双向链表上移动的位置的个数。当n>0时,为正向移动;反之为反向移动。

返回值:

*Ring:移动结束后,指针r指向的节点

功能说明:

指向节点r的指针,正向或者逆向移动n%r.Len()个节点,并返回指针移动后指向的节点,但是r.Move(n)不对改变r的值,r不能为空

package main

import (
    "container/ring"
    "fmt"
)

func main() {
    // 创建一个循环双向链表,并初始化
    r := ring.New(10)
    for i := 1;i <= 10;i++{
        r.Value = i
        r = r.Next()
    }

    // 输出内容
    r.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r = r.Move(3)
    r.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()
}
输出结果:
1 2 3 4 5 6 7 8 9 10 
4 5 6 7 8 9 10 1 2 3

(5)func (r *Ring) Next() *Ring

返回值:

*Ring:指向下一个节点的指针

功能说明:

获得指向下一个节点的指针

(6)func (r *Ring) Prev() *Ring

返回值:

*Ring:指向上一个节点的指针

功能说明:

获得指向上一个节点的指针

(7)func (r *Ring) Link(s *Ring) *Ring

参数列表:

s:环形双向链表

返回值:

*Ring:s和r相连前s.Next()的值

功能说明:

把一个环形双向链表s与环形双向链表r相链接,并返回相连前时s.Next()的值。r不能为空。

环形双向链表r与s的关系存在以下几种情况:

1)如果s和r不是同一个环形链表,则相连后,值产生一个环形链表,并返回相连前时s.Next()的值,

2)如果s和r是同一个环形链表,但s!=r时,相连后,产生两个环形链表,并返回相连前的s.Next()

package main

import (
    "container/ring"
    "fmt"
)

func main() {
    // 创建一个循环双向链表,并初始化
    r1 := ring.New(10)
    r2 := ring.New(10)
    for i := 1;i <= 10;i++{
        r1.Value = i
        r1 = r1.Next()
        r2.Value = i + 20
        r2 = r2.Next()
    }
    /* 情况一 */
    fmt.Println("情况一:")
    r := r1.Link(r2)
    r.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r1.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r2.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()
    /* 情况2 */
    fmt.Println("情况二:")
    r3 := ring.New(10)
    for i := 1;i <= 10;i++ {
        r3.Value = i
        r3 = r3.Next()
    }
    r4 := r3.Move(2)
    r = r3.Link(r4)
    r.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r3.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r4.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()
    /* 情况3 */
    fmt.Println("情况三:")
    r5 := ring.New(10)
    for i := 1;i <= 10;i++ {
        r5.Value = i
        r5 = r5.Next()
    }
    r6 := r5
    r = r5.Link(r6)
    r.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })

    r5.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r6.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()
}
输出内容:
情况一:
2 3 4 5 6 7 8 9 10 1 21 22 23 24 25 26 27 28 29 30 
1 21 22 23 24 25 26 27 28 29 30 2 3 4 5 6 7 8 9 10 
21 22 23 24 25 26 27 28 29 30 2 3 4 5 6 7 8 9 10 1 
情况二:
2 
1 3 4 5 6 7 8 9 10 
3 4 5 6 7 8 9 10 1 
情况三:
2 3 4 5 6 7 8 9 10 1 
1

(8)func (r *Ring) Unlink(n int) *Ring

参数列表:

n:要被移除的节点的个数

功能说明:从节点r的下一个节点(包含该节点r.Next())开始移除 n % r.Len() 个节点。如果 n % r.Len() == 0,则链表不会有改变。r 不能为空。

package main

import (
    "container/ring"
    "fmt"
)

func main() {
    r1 := ring.New(10)
    for i := 1;i <= 10;i++ {
        r1.Value = i
        r1 = r1.Next()
    }
    r2 := r1.Unlink(22)
    r1.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()

    r2.Do(func(i interface{}) {
        fmt.Print(i, " ")
    })
    fmt.Println()
}
输出结果:
1 4 5 6 7 8 9 10 
2 3

参考来自: https://github.com/astaxie/gopkg/blob/master/container

阅读原文...

Go语言中文网

帮助企业绘制软件架构,SaaS公司LeanIX获3000万美元C轮融资

上一篇

记一次Kubernetes/Docker网络排障

下一篇

您也可能喜欢

评论已经被关闭。

插入图片
golang中container/ring包

长按储存图像,分享给朋友