sll

README

= A generics based Go Singly Linked List

A simple singlely linked list (SLL)  with IsEmpty, AppendSLL, HeadSLL, Length

Documentation

Index

• Variables
• type Sll
  • func NewSll[T comparable.Equality]() *Sll[T]
  • func (ns *Sll[T]) Current(el *SllElement[T], pos int) *SllIter[T]
  • func (ns *Sll[T]) Delete(t *T) (err error)
  • func (ns *Sll[T]) DeleteFound(t *SllElement[T]) (err error)
  • func (tt *Sll[T]) Dump(fp io.Writer)
  • func (ns *Sll[T]) Front() *SllIter[T]
  • func (ns *Sll[T]) InsertAfterTail(t *T)
  • func (ns *Sll[T]) InsertBeforeHead(t *T)
  • func (ns *Sll[T]) IsEmpty() bool
  • func (ns *Sll[T]) IterateOver() iter.Seq2[int, T]
  • func (ns *Sll[T]) IteratePtr() iter.Seq2[int, *T]
  • func (ns *Sll[T]) Length() int
  • func (ns *Sll[T]) Peek() (rv *T, err error)
  • func (ns *Sll[T]) Pop() (rv *T, err error)
  • func (ns *Sll[T]) Push(t *T)
  • func (ns *Sll[T]) Reverse()
  • func (ns *Sll[T]) Search(t *T) (rv *SllElement[T], pos int)
  • func (ns *Sll[T]) Truncate()
• type SllElement
  • func (ee *SllElement[T]) GetData() *T
• type SllIter
  • func (iter *SllIter[T]) Done() bool
  • func (iter *SllIter[T]) Next()
  • func (iter *SllIter[T]) Pos() int
  • func (iter *SllIter[T]) Value() *T

Variables

var ErrEmptySll = errors.New("Empty Sll")

An error to indicate that the stack is empty

var ErrNotFound = errors.New("Not Found")

Types

type Sll

type Sll[T comparable.Equality] struct {
	// contains filtered or unexported fields
}

Sll is a generic type buildt on top of a slice

func NewSll

func NewSll[T comparable.Equality]() *Sll[T]

Create a new SLL and return it. Complexity is O(1).

func (*Sll[T]) Current

func (ns *Sll[T]) Current(el *SllElement[T], pos int) *SllIter[T]

Current will take the node returned from Search or RevrseSearch

func (ns *Sll[T]) Search( t *T ) (rv *SllElement[T], pos int) {

and allow you to start an iteration process from that point.

func (*Sll[T]) Delete

func (ns *Sll[T]) Delete(t *T) (err error)

func (*Sll[T]) DeleteFound

func (ns *Sll[T]) DeleteFound(t *SllElement[T]) (err error)

func (*Sll[T]) Dump

func (tt *Sll[T]) Dump(fp io.Writer)

Dump prints out the list. O(n)

func (*Sll[T]) Front

func (ns *Sll[T]) Front() *SllIter[T]

Front will start at the beginning of a list for iteration over list.

func (*Sll[T]) InsertAfterTail

func (ns *Sll[T]) InsertAfterTail(t *T)

InsertAfterTail will append a new node to the end of the list.

func (*Sll[T]) InsertBeforeHead

func (ns *Sll[T]) InsertBeforeHead(t *T)

InsertBeforeHead will append a new node to the end of the list.

func (*Sll[T]) IsEmpty

func (ns *Sll[T]) IsEmpty() bool

------------------------------------------------------------------------------------------------------- IsEmpty will return true if the stack is empty

func (*Sll[T]) IterateOver

func (ns *Sll[T]) IterateOver() iter.Seq2[int, T]

func (*Sll[T]) IteratePtr

func (ns *Sll[T]) IteratePtr() iter.Seq2[int, *T]

func (*Sll[T]) Length

func (ns *Sll[T]) Length() int

Length returns the number of elements in the list.

func (*Sll[T]) Peek

func (ns *Sll[T]) Peek() (rv *T, err error)

Peek returns the top element of the stack or an error indicating that the stack is empty. O(1)

func (*Sll[T]) Pop

func (ns *Sll[T]) Pop() (rv *T, err error)

Pop will remove the top element from the stack. An error is returned if the stack is empty.

func (*Sll[T]) Push

func (ns *Sll[T]) Push(t *T)

Push will append a new node to the end of the list.

func (*Sll[T]) Reverse

func (ns *Sll[T]) Reverse()

Reverse - effeciently reverse direciotn on a list. O(n) with storage O(1)

func (*Sll[T]) Search

func (ns *Sll[T]) Search(t *T) (rv *SllElement[T], pos int)

Search — Returns the given element from a linked list. Search is from head to tail. O(n)

func (*Sll[T]) Truncate

func (ns *Sll[T]) Truncate()

Truncate removes all data from the list. O(1)

type SllElement

type SllElement[T comparable.Equality] struct {
	// contains filtered or unexported fields
}

A node in the singly linked list

func (*SllElement[T]) GetData

func (ee *SllElement[T]) GetData() *T

Complexity is O(1).

type SllIter

type SllIter[T comparable.Equality] struct {
	// contains filtered or unexported fields
}

An iteration type that allows a for loop to walk the list.

func (*SllIter[T]) Done

func (iter *SllIter[T]) Done() bool

Done returns true if the end of the list has been reached.

func (*SllIter[T]) Next

func (iter *SllIter[T]) Next()

Next advances to the next element in the list.

func (*SllIter[T]) Pos

func (iter *SllIter[T]) Pos() int

Pos returns the current "index" of the elemnt being iterated on. So if the list has 3 elements, a, b, c and we start at the head of the list 'a' will have a Pos() of 0, 'b' will have a Pos() of 1 etc.

func (*SllIter[T]) Value

func (iter *SllIter[T]) Value() *T

Value returns the current data for this element in the list.