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