Go标准容器之Ring的使用说明


Posted in Golang onMay 05, 2021

简介

Go的标准包Container中包含了常用的容器类型,包括conatiner/list,container/heap,container/ring,本篇讲解container/ring的使用。

ring包

ring包提供了环形链表的操作。它仅导出了一个类型,Ring:

// Ring表示环形链表中的元素。
type Ring struct {
    Value interface{} // Value类型为interface{},因此可以接受任意类型
}
// 创建一个长度为n的环形链表
func New(n int) *Ring
// 针对环形链表中的每一个元素x进行f(x)操作
func (r *Ring) Do(f func(interface{}))
// 获取环形链表长度
func (r *Ring) Len() int
// 如果r和s在同一环形链表中,则删除r和s之间的元素,
// 被删除的元素组成一个新的环形链表,返回值为该环形链表的指针(即删除前,r->Next()表示的元素)
// 如果r和s不在同一个环形链表中,则将s插入到r后面,返回值为
// 插入s后,s最后一个元素的下一个元素(即插入前,r->Next()表示的元素)
func (r *Ring) Link(s *Ring) *Ring
// 移动 n % r.Len() 个位置,n正负均可
func (r *Ring) Move(n int) *Ring
// 返回下一个元素
func (r *Ring) Next() *Ring
// 返回前一个元素
func (r *Ring) Prev() *Ring
// 删除r后面的 n % r.Len() 个元素
func (r *Ring) Unlink(n int) *Ring

示例

Ring的用法

package main
import (
    "container/ring"
    "fmt"
)
func main() {
    const rLen = 3
    // 创建新的Ring
    r := ring.New(rLen)
    for i := 0; i < rLen; i++ {
        r.Value = i
        r = r.Next()
    }
    fmt.Printf("Length of ring: %d\n", r.Len()) // Length of ring: 3
    // 该匿名函数用来打印Ring中的数据
    printRing := func(v interface{}) {
        fmt.Print(v, " ")
    }
    r.Do(printRing) // 0 1 2
    fmt.Println()
    // 将r之后的第二个元素的值乘以2
    r.Move(2).Value = r.Move(2).Value.(int) * 2
    r.Do(printRing) // 0 1 4
    fmt.Println()
    // 删除 r 与 r+2 之间的元素,即删除 r+1
    // 返回删除的元素组成的Ring的指针
    result := r.Link(r.Move(2))
    r.Do(printRing) // 0 4
    fmt.Println()
    result.Do(printRing) // 1
    fmt.Println()
    another := ring.New(rLen)
    another.Value = 7
    another.Next().Value = 8 // 给 another + 1 表示的元素赋值,即第二个元素
    another.Prev().Value = 9 // 给 another - 1 表示的元素赋值,即第三个元素
    another.Do(printRing) // 7 8 9
    fmt.Println()
    // 插入another到r后面,返回插入前r的下一个元素
    result = r.Link(another)
    r.Do(printRing) // 0 7 8 9 4
    fmt.Println()
    result.Do(printRing) // 4 0 7 8 9
    fmt.Println()
    // 删除r之后的三个元素,返回被删除元素组成的Ring的指针
    result = r.Unlink(3)
    r.Do(printRing) // 0 4
    fmt.Println()
    result.Do(printRing) // 7 8 9
    fmt.Println()
}

模拟约瑟夫问题

环形列表可以模拟约瑟夫问题。约瑟夫问题描述如下:

来自百度:

据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始,越过k-2个人(因为第一个人已经被越过),并杀掉第k个人。接着,再越过k-1个人,并杀掉第k个人。这个过程沿着圆圈一直进行,直到最终只剩下一个人留下,这个人就可以继续活着。问题是,给定了和,一开始要站在什么地方才能避免被处决?Josephus要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,于是逃过了这场死亡游戏。

用代码模拟如下:

package main
import (
    "container/ring"
    "fmt"
)
type Player struct {
    position int  // 位置
    alive    bool // 是否存活
}
func main() {
    const (
        playerCount = 41  // 玩家人数
        startPos    = 1  // 开始报数位置
    )
    deadline := 3
    r := ring.New(playerCount)
    // 设置所有玩家初始值
    for i := 1; i <= playerCount; i++ {
        r.Value = &Player{i, true}
        r = r.Next()
    }
    // 如果开始报数的位置不为1,则设置开始位置
    if startPos > 1 {
        r = r.Move(startPos - 1)
    }
    counter := 1  // 报数从1开始,因为下面的循环从第二个开始计算
    deadCount := 0  // 死亡人数,初始值为0
    for deadCount < playerCount {  // 直到所有人都死亡,否则循环一直执行
        r = r.Next() // 跳到下一个人
        // 如果是活着的人,则报数
        if r.Value.(*Player).alive {
            counter++
        }
        // 如果报数为deadline,则此人淘汰出局
        if counter == deadline {
            r.Value.(*Player).alive = false
            fmt.Printf("Player %d died!\n", r.Value.(*Player).position)
            deadCount++
            counter = 0  // 报数置成0
        }
    }
}

输出如下,可以看到16和31是最后两个出队列的,因此Josephus将他的朋友与自己安排在第16个与第31个位置是安全的。

Player 3 died!
Player 6 died!
Player 9 died!
Player 12 died!
Player 15 died!
Player 18 died!
Player 21 died!
Player 24 died!
Player 27 died!
Player 30 died!
Player 33 died!
Player 36 died!
Player 39 died!
Player 1 died!
Player 5 died!
Player 10 died!
Player 14 died!
Player 19 died!
Player 23 died!
Player 28 died!
Player 32 died!
Player 37 died!
Player 41 died!
Player 7 died!
Player 13 died!
Player 20 died!
Player 26 died!
Player 34 died!
Player 40 died!
Player 8 died!
Player 17 died!
Player 29 died!
Player 38 died!
Player 11 died!
Player 25 died!
Player 2 died!
Player 22 died!
Player 4 died!
Player 35 died!
Player 16 died!
Player 31 died!

补充:go语言中container容器数据结构heap、list、ring

heap堆的使用:

package main 
import (
    "container/heap"
    "fmt"
)
 
type IntHeap []int 
//我们自定义一个堆需要实现5个接口
//Len(),Less(),Swap()这是继承自sort.Interface
//Push()和Pop()是堆自已的接口
 
//返回长度
func (h *IntHeap) Len() int {
    return len(*h);
}
 
//比较大小(实现最小堆)
func (h *IntHeap) Less(i, j int) bool {
    return (*h)[i] < (*h)[j];
}
 
//交换值
func (h *IntHeap) Swap(i, j int) {
    (*h)[i], (*h)[j] = (*h)[j], (*h)[i];
}
 
//压入数据
func (h *IntHeap) Push(x interface{}) {
    //将数据追加到h中
    *h = append(*h, x.(int))
}
 
//弹出数据
func (h *IntHeap) Pop() interface{} {
    old := *h;
    n := len(old);
    x := old[n-1];
    //让h指向新的slice
    *h = old[0: n-1];
    //返回最后一个元素
    return x;
}
 
//打印堆
func (h *IntHeap) PrintHeap() {
    //元素的索引号
    i := 0
    //层级的元素个数
    levelCount := 1
    for i+1 <= h.Len() {
        fmt.Println((*h)[i: i+levelCount])
        i += levelCount
        if (i + levelCount*2) <= h.Len() {
            levelCount *= 2
        } else {
            levelCount = h.Len() - i
        }
    }
}
 
func main() {
    a := IntHeap{6, 2, 3, 1, 5, 4};
    //初始化堆
    heap.Init(&a);
    a.PrintHeap();
    //弹出数据,保证每次操作都是规范的堆结构
    fmt.Println(heap.Pop(&a));
    a.PrintHeap();
    fmt.Println(heap.Pop(&a));
    a.PrintHeap();
    heap.Push(&a, 0);
    heap.Push(&a, 8);
    a.PrintHeap();
}

list链表的使用:

package main; 
import (
    "container/list"
    "fmt"
)
 
func printList(l *list.List) {
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ");
    }
    fmt.Println();
}
 
func main() {
    //创建一个链表
    l := list.New();
 
    //链表最后插入元素
    a1 := l.PushBack(1);
    b2 := l.PushBack(2);
 
    //链表头部插入元素
    l.PushFront(3);
    l.PushFront(4);
 
    printList(l);
 
    //取第一个元素
    f := l.Front();
    fmt.Println(f.Value);
 
    //取最后一个元素
    b := l.Back();
    fmt.Println(b.Value);
 
    //获取链表长度
    fmt.Println(l.Len());
 
    //在某元素之后插入
    l.InsertAfter(66, a1);
 
    //在某元素之前插入
    l.InsertBefore(88, a1);
 
    printList(l);
 
    l2 := list.New();
    l2.PushBack(11);
    l2.PushBack(22);
    //链表最后插入新链表
    l.PushBackList(l2);
    printList(l);
 
    //链表头部插入新链表
    l.PushFrontList(l2);
    printList(l);
 
    //移动元素到最后
    l.MoveToBack(a1);
    printList(l);
 
    //移动元素到头部
    l.MoveToFront(a1);
    printList(l);
 
    //移动元素在某元素之后
    l.MoveAfter(b2, a1);
    printList(l);
 
    //移动元素在某元素之前
    l.MoveBefore(b2, a1);
    printList(l);
 
    //删除某元素
    l.Remove(a1);
    printList(l);
}

ring环的使用:

package main; 
import (
    "container/ring"
    "fmt"
)
 
func printRing(r *ring.Ring) {
    r.Do(func(v interface{}) {
        fmt.Print(v.(int), " ");
    });
    fmt.Println();
}
 
func main() {
    //创建环形链表
    r := ring.New(5);
    //循环赋值
    for i := 0; i < 5; i++ {
        r.Value = i;
        //取得下一个元素
        r = r.Next();
    }
    printRing(r);
    //环的长度
    fmt.Println(r.Len());
 
    //移动环的指针
    r.Move(2);
 
    //从当前指针删除n个元素
    r.Unlink(2);
    printRing(r);
 
    //连接两个环
    r2 := ring.New(3);
    for i := 0; i < 3; i++ {
        r2.Value = i + 10;
        //取得下一个元素
        r2 = r2.Next();
    }
    printRing(r2);
 
    r.Link(r2);
    printRing(r);
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持三水点靠木。如有错误或未考虑完全的地方,望不吝赐教。

Golang 相关文章推荐
Golang二维切片初始化的实现
Apr 08 Golang
Go语言操作数据库及其常规操作的示例代码
Apr 21 Golang
解决Golang中ResponseWriter的一个坑
Apr 27 Golang
golang 生成对应的数据表struct定义操作
Apr 28 Golang
Go语言中break label与goto label的区别
Apr 28 Golang
浅谈golang 中time.After释放的问题
May 05 Golang
go select编译期的优化处理逻辑使用场景分析
Jun 28 Golang
golang内置函数len的小技巧
Jul 25 Golang
Go语言 详解net的tcp服务
Apr 14 Golang
GO语言字符串处理函数之处理Strings包
Apr 14 Golang
Go语言怎么使用变长参数函数
Jul 15 Golang
go语言中GOPATH GOROOT的作用和设置方式
go设置多个GOPATH的方式
May 05 #Golang
浅谈golang 中time.After释放的问题
May 05 #Golang
golang 定时任务方面time.Sleep和time.Tick的优劣对比分析
May 05 #Golang
golang日志包logger的用法详解
May 05 #Golang
golang elasticsearch Client的使用详解
May 05 #Golang
goland设置颜色和字体的操作
You might like
浅析php学习的路线图
2013/07/10 PHP
无刷新动态加载数据 滚动条加载适合评论等页面
2013/10/16 PHP
浅谈PHP中其他类型转化为Bool类型
2016/03/28 PHP
js wmp操作代码小结(音乐连播功能)
2008/11/08 Javascript
JavaScript 对象链式操作测试代码
2010/04/25 Javascript
基于jQuery实现的水平和垂直居中的div窗口
2011/08/08 Javascript
jQuery+CSS实现菜单滑动伸展收缩(仿淘宝)
2013/03/22 Javascript
js unicode 编码解析关于数据转换为中文的两种方法
2014/04/21 Javascript
js事件监听机制(事件捕获)总结
2014/08/08 Javascript
jQuery实现按键盘方向键翻页特效
2015/03/18 Javascript
js轮盘抽奖实例分析
2020/04/17 Javascript
深入浅析Vue组件开发
2016/11/25 Javascript
JS出现失效的情况总结
2017/01/20 Javascript
jQuery插件FusionWidgets实现的Bulb图效果示例【附demo源码下载】
2017/03/23 jQuery
将angular-ui的分页组件封装成指令的方法详解
2017/05/10 Javascript
jQuery EasyUI Layout实现tabs标签的实例
2017/09/26 jQuery
脚手架vue-cli工程webpack的基本用法详解
2018/09/29 Javascript
vue-cli3添加模式配置多环境变量的方法
2019/06/05 Javascript
小程序中canvas的drawImage方法参数使用详解
2019/07/04 Javascript
关于layui 实现点击按钮添加一行(方法渲染创建的table)
2019/09/29 Javascript
深度解读vue-resize的具体用法
2020/07/08 Javascript
js删除指定位置超链接中含有百度与360的标题
2021/01/06 Javascript
python 生成不重复的随机数的代码
2011/05/15 Python
Python pass详细介绍及实例代码
2016/11/24 Python
Python实现图片转字符画的示例
2017/08/22 Python
Python使用pandas处理CSV文件的实例讲解
2018/06/22 Python
Python实现字符型图片验证码识别完整过程详解
2019/05/10 Python
python图形工具turtle绘制国际象棋棋盘
2019/05/23 Python
python数据库操作mysql:pymysql、sqlalchemy常见用法详解
2020/03/30 Python
win7上tensorflow2.2.0安装成功 引用DLL load failed时找不到指定模块 tensorflow has no attribute xxx 解决方法
2020/05/20 Python
Pytorch 卷积中的 Input Shape用法
2020/06/29 Python
python自动提取文本中的时间(包含中文日期)
2020/08/31 Python
HTML5 canvas 基本语法
2009/08/26 HTML / CSS
索尼巴西商店:Sony巴西
2019/06/21 全球购物
高中课前三分钟演讲稿
2014/08/18 职场文书
2014社会治安综合治理工作总结
2014/12/04 职场文书