In Go,containerThe standard package provides developers with three very useful data structures: heap, linked list, and ring. The implementations of these data structures are located incontainer/heap、container/listandcontainer/ringmiddle. Understanding these data structures and how they are implemented can help us handle a variety of complex data storage and operational tasks more efficiently.
Introduction to the ring link list
A ring is a special linked list, its last element points to the first element, which means it has no clear starting point and end point. Each node in the ring-link list is logically equivalent, and the entire ring can be traversed from any node. Through this structure, we can easily loop through the data.
Application of linked lists
Ringlists are very useful in many practical applications. For example, suppose you have a fixed-sized set of data and want to keep looping between the set of data, a circular list can avoid the overhead of reinitializing the data. In addition, ring-linked lists are very common in certain game loops, operating system schedulers, etc. where tasks need to be processed in a loop.
Get started with container/ring
Next, we will use code examples to describe how to use itcontainer/ringBag. Before this, let’s briefly explain its basic operations.container/ringThe package provides a small number of functions, the most important of which isNext()andDo()。Next()The function is used to get the next node of the current node.Do()The function is used to perform specified operations on each node in the ring.
Sample code: Create a ring link list
First, we define the size of a circular linked list and use()To initialize a ring:
package main
import (
"container/ring"
"fmt"
)
var size int = 10 // The size of the ring
func main() {
myRing := (size + 1) // Create a ring with size +1 ("Empty Ring:", *myRing)
// Assign values to each node of the circular linked list for i := 0; i < ()-1; i++ {
= i
myRing = ()
}
= 2 // Assign value at the last node}
In this code snippet, we first create a size ofsize+1ring. Then, through aforThe loop assigns a value to each node in the loop. In the last step, we manually set the value of the last node to2, although this value has appeared in the loop.
Use the Do() function to traverse the loop
We can use()Iterate through each node in the ring and operate on the node value. The following code will traverse each node in the ring and calculate the sum of the node values:
sum := 0
(func(x interface{}) {
t := x.(int) // Type assertion, ensuring that the value of the node is an integer sum += t //Accumulate the value of each node})
("sum:", sum)
()It is a very concise way of traversing, which processes each element in the ring in turn by passing in a function. If you don't modify the structure in the ring,Do()Functions can be used safely, and the code is more concise.
Use the Next() function to traverse the loop
AlthoughDo()It's a simple way to traverse the ring, but you can alsoNext()Functions manually traverse the ring:
for i := 0; i < ()+2; i++ {
myRing = () // Get the next node (, " ")
}
()
In this example, we useNext()The function traverses the loop and outputs the value of each node. It should be noted that since the ring does not have a clear end point, theNext()Can be looped infinitely, so we passLen()Function to control the number of loops.
Execution results
When you run the above code, the output may look like this:
Empty ring: {0xc00000a080 0xc00000a1a0 <nil>}
Total: 45
0 1 2 3 4 5 6 7 8 9 2 0 1
It can be seen that the ring can contain repeated values, and during the traversal process, the ring will continue to cycle, unless we set the end condition artificially.
Implementation of linked lists using container/list
Unlike circular linked lists, a linked list is a linear data structure where each node points to the next node. In Gocontainer/listIn the package, a double linked list is implemented, which can be traversed from the beginning to the end or from the end to the beginning. The advantage of a two-way linked list is that we can easily insert and delete elements.
Basic operations of linked lists
container/listThe package provides basic operations of linked lists, such as insertion, deletion, traversal, etc. Below we use a complete example to demonstrate how to use these operations.
Sample code: Creation and operation of linked lists
package main
import (
"container/list"
"fmt"
"strconv"
)
func printList(l *) {
//Travel from the tail to the head for t := (); t != nil; t = () {
(, " ")
}
()
//Travel from the head to the tail for t := (); t != nil; t = () {
(, " ")
}
()
}
func main() {
values := () // Create a new link e1 := ("one") // Insert element to the end of the linked list e2 := ("two")
("three") // Insert element to the header of the linked list ("Four", e1) // Insert "four" before e1 ("five", e2) // Insert "five" after e2
(e2) // Remove element e2 printList(values)
() // Initialize the link list ("After the linked list is initialized:", values)
// Insert a set of numbers for i := 0; i < 10; i++ {
((i))
}
printList(values)
}
In this code segment, we demonstrate common operations for linked lists, including inserting elements at the head and tail of a linked list, inserting new elements before and after a specified element, removing elements, and traversing the linked list.
Execution results
When you run the above code, the output may be as follows:
5413
Three, one, four, five
After the linked list is initialized: &{{0xc000012000 0xc000012000 <nil> <nil>} 0}
9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9
As you can see, the initialization of the linked list clears the linked list, and the subsequent loop insertion operation refills the linked list.
Through the introduction of this article, we have explained in detail the Go languagecontainerImplementation and application of circular and bidirectional linked lists of packages. Once you master these data structures, you can efficiently select the appropriate structure when you need flexible data storage and traversal.
This is the end of this article about a container package in depth understanding of Go. For more related Go languages, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!