Package ring implements operations on circular lists.
Package files
A Ring is an element of a circular list, or ring. Rings do not have a beginning
or end; a pointer to any ring element serves as reference to the entire ring.
Empty rings are represented as nil Ring pointers. The zero value for a Ring is a
one-element ring with a nil Value.
func
¶
- func New(n ) *Ring
New creates a ring of n elements.
- func (r *) Do(f func(interface{}))
Do calls function f on each element of the ring, in forward order. The behavior
of Do is undefined if f changes *r.
// Create a new ring of size 5
r := ring.New(5)
// Get the length of the ring
n := r.Len()
// Initialize the ring with some integer values
for i := 0; i < n; i++ {
r.Value = i
r = r.Next()
}
// Iterate through the ring and print its contents
r.Do(func(p interface{}) {
fmt.Println(p.(int))
})
// Output:
// 0
// 1
// 2
// 3
// 4
func (*Ring) Len
- func (r *Ring) Len()
Len computes the number of elements in ring r. It executes in time proportional
to the number of elements.
func (*Ring)
¶
- func (r *) Link(s *Ring) *
Link connects ring r with ring s such that r.Next() becomes s and returns the
original value for r.Next(). r must not be empty.
If r and s point to the same ring, linking them removes the elements between r
and s from the ring. The removed elements form a subring and the result is a
reference to that subring (if no elements were removed, the result is still the
original value for r.Next(), and not nil).
If r and s point to different rings, linking them creates a single ring with the
elements of s inserted after r. The result points to the element following the
last element of s after insertion.
// Create two rings, r and s, of size 2
r := ring.New(2)
s := ring.New(2)
lr := r.Len()
ls := s.Len()
// Initialize r with 0s
for i := 0; i < lr; i++ {
r.Value = 0
r = r.Next()
}
// Initialize s with 1s
for j := 0; j < ls; j++ {
s.Value = 1
s = s.Next()
}
// Link ring r and ring s
rs := r.Link(s)
// Iterate through the combined ring and print its contents
rs.Do(func(p interface{}) {
fmt.Println(p.(int))
})
// Output:
// 0
// 0
// 1
// 1
- func (r *) Move(n int) *
// Create a new ring of size 5
r := ring.New(5)
// Get the length of the ring
n := r.Len()
// Initialize the ring with some integer values
for i := 0; i < n; i++ {
r.Value = i
r = r.Next()
}
// Move the pointer forward by three steps
r = r.Move(3)
// Iterate through the ring and print its contents
r.Do(func(p interface{}) {
fmt.Println(p.(int))
})
// Output:
// 3
// 0
// 1
// 2
func (*Ring)
¶
Next returns the next ring element. r must not be empty.
Example:
// Create a new ring of size 5
r := ring.New(5)
n := r.Len()
// Initialize the ring with some integer values
for i := 0; i < n; i++ {
r.Value = i
r = r.Next()
}
// Iterate through the ring and print its contents
for j := 0; j < n; j++ {
fmt.Println(r.Value)
r = r.Next()
}
// Output:
// 0
// 1
// 2
// 3
// 4
func (*Ring) Prev
- func (r *Ring) Prev() *
Prev returns the previous ring element. r must not be empty.
// Create a new ring of size 5
r := ring.New(5)
// Get the length of the ring
n := r.Len()
// Initialize the ring with some integer values
for i := 0; i < n; i++ {
r.Value = i
r = r.Next()
}
// Iterate through the ring backwards and print its contents
for j := 0; j < n; j++ {
r = r.Prev()
fmt.Println(r.Value)
}
// Output:
// 4
// 3
// 2
- func (r *) Unlink(n int) *
Unlink removes n % r.Len() elements from the ring r, starting at r.Next(). If n
% r.Len() == 0, r remains unchanged. The result is the removed subring. r must
not be empty.