Instructions for use of Go standard container Ring

// Ring represents the elements in the ring-linked list.type Ring struct {
    Value interface{} // Value type is interface{}, so it can accept any type}
// Create a circular link table of length nfunc New(n int) *Ring
// F(x) operation for each element x in the circular linked listfunc (r *Ring) Do(f func(interface{}))
// Get the length of the ring link listfunc (r *Ring) Len() int
// If r and s are in the same ring list, the elements between r and s are deleted.// The deleted elements form a new circular linked list, and the return value is the pointer to the circular linked list (that is, the element represented by r->Next() before deletion)// If r and s are not in the same circular list, then s is inserted after r and the return value is// After inserting s, the next element of the last element of s (that is, the element represented by r->Next() before insertion)func (r *Ring) Link(s *Ring) *Ring
// Move n % () positions, both positive and negative can befunc (r *Ring) Move(n int) *Ring
// Return to the next elementfunc (r *Ring) Next() *Ring
// Return to the previous elementfunc (r *Ring) Prev() *Ring
// Delete n % () elements after rfunc (r *Ring) Unlink(n int) *Ring

package main
import (
    "container/ring"
    "fmt"
)
func main() {
    const rLen = 3
    // Create a new Ring    r := (rLen)
    for i := 0; i < rLen; i++ {
         = i
        r = ()
    }
    ("Length of ring: %d\n", ()) // Length of ring: 3
    // This anonymous function is used to print data in Ring    printRing := func(v interface{}) {
        (v, " ")
    }
    (printRing) // 0 1 2
    ()
    // Multiply the value of the second element after r by 2    (2).Value = (2).Value.(int) * 2
    (printRing) // 0 1 4
    ()
    // Delete the elements between r and r+2, that is, delete r+1    // Returns the Ring pointer composed of deleted elements    result := ((2))
    (printRing) // 0 4
    ()
    (printRing) // 1
    ()
    another := (rLen)
     = 7
    ().Value = 8 // Assign a value to the element represented by another + 1, that is, the second element    ().Value = 9 // Assign a value to the element represented by another - 1, that is, the third element    (printRing) // 7 8 9
    ()
    // Insert another to the back of r, return to the next element before inserting r    result = (another)
    (printRing) // 0 7 8 9 4
    ()
    (printRing) // 4 0 7 8 9
    ()
    // Delete the three elements after r and return the Ring pointer composed of the deleted elements    result = (3)
    (printRing) // 0 4
    ()
    (printRing) // 7 8 9
    ()
}

package main
import (
    "container/ring"
    "fmt"
)
type Player struct {
    position int  // Location    alive    bool // Whether to survive}
func main() {
    const (
        playerCount = 41  // Number of players        startPos    = 1  // Start counting position    )
    deadline := 3
    r := (playerCount)
    // Set the initial value of all players    for i := 1; i <= playerCount; i++ {
         = &Player{i, true}
        r = ()
    }
    // If the starting number position is not 1, set the starting position    if startPos > 1 {
        r = (startPos - 1)
    }
    counter := 1  // The number starts at 1, because the following loop starts at the second    deadCount := 0  // The number of deaths, the initial value is 0    for deadCount < playerCount {  // until everyone dies, otherwise the loop will be executed        r = () // Jump to the next person        // If it is a living person, then the number will be reported        if .(*Player).alive {
            counter++
        }
        // If the report is deadline, the person will be eliminated        if counter == deadline {
            .(*Player).alive = false
            ("Player %d died!\n", .(*Player).position)
            deadCount++
            counter = 0  // Set the number to 0        }
    }
}

package main 
import (
    "container/heap"
    "fmt"
)
 
type IntHeap []int 
//We need to implement 5 interfaces for customizing a heap//Len(),Less(),Swap() is inherited from//Push() and Pop() are the interfaces of the heap 
//Return lengthfunc (h *IntHeap) Len() int {
    return len(*h);
}
 
//Compare size (to implement the minimum heap)func (h *IntHeap) Less(i, j int) bool {
    return (*h)[i] < (*h)[j];
}
 
//Swap valuesfunc (h *IntHeap) Swap(i, j int) {
    (*h)[i], (*h)[j] = (*h)[j], (*h)[i];
}
 
//Press in datafunc (h *IntHeap) Push(x interface{}) {
    //Append data to h    *h = append(*h, x.(int))
}
 
//Popt datafunc (h *IntHeap) Pop() interface{} {
    old := *h;
    n := len(old);
    x := old[n-1];
    //Let h point to the new slice    *h = old[0: n-1];
    //Return the last element    return x;
}
 
//Print stackfunc (h *IntHeap) PrintHeap() {
    //Element index number    i := 0
    //The number of elements at the level    levelCount := 1
    for i+1 <= () {
        ((*h)[i: i+levelCount])
        i += levelCount
        if (i + levelCount*2) <= () {
            levelCount *= 2
        } else {
            levelCount = () - i
        }
    }
}
 
func main() {
    a := IntHeap{6, 2, 3, 1, 5, 4};
    //Initialize the heap    (&a);
    ();
    //Popt out data to ensure that every operation is a standard heap structure    ((&a));
    ();
    ((&a));
    ();
    (&a, 0);
    (&a, 8);
    ();
}

package main; 
import (
    "container/list"
    "fmt"
)
 
func printList(l *) {
    for e := (); e != nil; e = () {
        (, " ");
    }
    ();
}
 
func main() {
    //Create a linked list    l := ();
 
    //Elements are inserted at the end of the linked list    a1 := (1);
    b2 := (2);
 
    //Insert elements at the head of the linked list    (3);
    (4);
 
    printList(l);
 
    //Take the first element    f := ();
    ();
 
    //Take the last element    b := ();
    ();
 
    //Get the linked list length    (());
 
    //Insert after an element    (66, a1);
 
    //Insert before an element    (88, a1);
 
    printList(l);
 
    l2 := ();
    (11);
    (22);
    //A new link is inserted at the end    (l2);
    printList(l);
 
    //Insert a new link to the header of the link    (l2);
    printList(l);
 
    //Move the element to the end    (a1);
    printList(l);
 
    //Move the element to the head    (a1);
    printList(l);
 
    //Move the element after a certain element    (b2, a1);
    printList(l);
 
    //Move the element before a certain element    (b2, a1);
    printList(l);
 
    //Delete an element    (a1);
    printList(l);
}

package main; 
import (
    "container/ring"
    "fmt"
)
 
func printRing(r *) {
    (func(v interface{}) {
        (v.(int), " ");
    });
    ();
}
 
func main() {
    //Create a ring link table    r := (5);
    //Cyclic assignment    for i := 0; i < 5; i++ {
         = i;
        //Get the next element        r = ();
    }
    printRing(r);
    //Length of the ring    (());
 
    //The pointer of the moving ring    (2);
 
    //Delete n elements from the current pointer    (2);
    printRing(r);
 
    //Connect two rings    r2 := (3);
    for i := 0; i < 3; i++ {
         = i + 10;
        //Get the next element        r2 = ();
    }
    printRing(r2);
 
    (r2);
    printRing(r);
}