I was going to look at the heap first and found that sort was referenced. Wait, let's watch ring first, then sort.
First look at the data structure:
type Ring struct {
next, prev *Ring
Value interface{} // for use by client; untouched by this library
}
Simple, much like a linked list. ring.
Simple initialization:
func (r *Ring) init() *Ring {
r.next = r
r.prev = r
return r
}
The iterative function is also relatively simple:
func (r *Ring) Next() *Ring {
if r.next == nil {
return r.init()
}
return r.next
}
func (r *Ring) Prev() *Ring {
if r.next == nil {
return r.init()
}
return r.prev
}
Move move function, less than 0 forward, greater than 0 backward:
func (r *Ring) Move(n int) *Ring {
if r.next == nil {
return r.init()
}
switch {
case n < 0:
for ; n < 0; n++ {
r = r.prev
}
case n > 0:
for ; n > 0; n-- {
r = r.next
}
}
return n
}
Create n elements:
func New(n int) *Ring {
if n <= 0 {
return nil
}
r := new(Ring)
p := r
for i := 1; i < n; i++ {
p.next = &Ring{prev: p}
p = p.next
}
p.next = r
r.prev = p
return r
}
link和unlink:
func (r *Ring) Link(s *Ring) *Ring {
n := r.Next()
if s != nil {
p := s.Prev()
// Note: Cannot use multiple assignment because
// evaluation order of LHS is not specified.
r.next = s
s.prev = r
n.prev = p
p.next = n
}
return n
}
func (r *Ring) Unlink(n int) *Ring {
if n <= 0 {
return nil
}
return r.Link(r.Move(n + 1))
}
Note that unlink uses link.
Calculate the length of the ring:
func (r *Ring) Len() int {
n := 0
if r != nil {
n = 1
for p := r.Next(); p != r; p = p.next {
n++
}
}
return n
}
Time complexity is n
A little special is this do function, which calls the specified func for each element in the ring:
func (r *Ring) Do(f func(interface{})) {
if r != nil {
f(r.Value)
for p := r.Next(); p != r; p = p.next {
f(p.Value)
}
}
}