Package list implements a doubly linked list.

To iterate over a list (where l is a *List):


Example:

  1. // Create a new list and put some numbers in it.
  2. l := list.New()
  3. e4 := l.PushBack(4)
  4. e1 := l.PushFront(1)
  5. l.InsertBefore(3, e4)
  8. // Iterate through list and print its contents.
  9. for e := l.Front(); e != nil; e = e.Next() {
  10.     fmt.Println(e.Value)
  11. }
  13. // Output:
  14. // 1
  15. // 2
  16. // 3
  17. // 4

Package files

  1. type Element struct {
  2.     // The value stored with this element.
  3.     Value interface{}
  4.     // contains filtered or unexported fields
  5. }

Element is an element of a linked list.

func (*Element) Next

  1. func (e *Element) Next() *

Next returns the next list element or nil.

func (*Element) Prev

  1. func (e *Element) Prev() *

Prev returns the previous list element or nil.

  1. type List struct {
  2.     // contains filtered or unexported fields
  3. }

List represents a doubly linked list. The zero value for List is an empty list
ready to use.

func New

  1. func New() *List

New returns an initialized list.

func (*List)

Back returns the last element of list l or nil if the list is empty.

  1. func (l *) Front() *Element

Front returns the first element of list l or nil if the list is empty.

func (*List) 

  1. func (l *) Init() *List

Init initializes or clears list l.

func (*List) 

  1. func (l *) InsertAfter(v interface{}, mark *Element) *

InsertAfter inserts a new element e with value v immediately after mark and
returns e. If mark is not an element of l, the list is not modified. The mark
must not be nil.

func (*List) InsertBefore

  1. func (l *List) InsertBefore(v interface{}, mark *) *Element

InsertBefore inserts a new element e with value v immediately before mark and
returns e. If mark is not an element of l, the list is not modified. The mark
must not be nil.

func (*List) 

  1. func (l *) Len() int

Len returns the number of elements of list l. The complexity is O(1).

func (*List) 

  1. func (l *) MoveAfter(e, mark *Element)

MoveAfter moves element e to its new position after mark. If e or mark is not an
element of l, or e == mark, the list is not modified. The element and mark must
not be nil.

func (*List) 

  1. func (l *) MoveToBack(e *Element)

MoveToBack moves element e to the back of list l. If e is not an element of l,
the list is not modified. The element must not be nil.

func (*List) 

  1. func (l *) MoveToFront(e *Element)

MoveToFront moves element e to the front of list l. If e is not an element of l,
the list is not modified. The element must not be nil.

func (*List) 

  1. func (l *) PushBack(v interface{}) *Element

PushBack inserts a new element e with value v at the back of list l and returns
e.

func (*List) 

  1. func (l *) PushBackList(other *List)

PushBackList inserts a copy of an other list at the back of list l. The lists l
and other may be the same. They must not be nil.

func (*List) 

  1. func (l *) PushFront(v interface{}) *Element

PushFront inserts a new element e with value v at the front of list l and
returns e.

    PushFrontList inserts a copy of an other list at the front of list l. The lists
    l and other may be the same. They must not be nil.

    func (*List)

    Remove removes e from l if e is an element of list l. It returns the element
    value e.Value. The element must not be nil.