Go标准容器之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

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()
}

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
        }
    }
}

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();
}

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);
}

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);
}