gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/container/linked-list.go

package container

type LinkedListEntry[E any] struct {
	elem E
	next *LinkedListEntry[E]
	prev *LinkedListEntry[E]
}

func NewLinkedListEntry[E any](e E) *LinkedListEntry[E] {
	return &LinkedListEntry[E]{elem: e}
}

func (e *LinkedListEntry[E]) Value() E {
	return e.elem
}

func (e *LinkedListEntry[E]) Set(elem E) {
	e.elem = elem
}

func (e *LinkedListEntry[E]) Next() *LinkedListEntry[E] {
	if e.next == nil || e.next.next == nil {
		return nil
	}
	return e.next
}

func (e *LinkedListEntry[E]) Prev() *LinkedListEntry[E] {
	if e.prev == nil || e.prev.prev == nil {
		return nil
	}
	return e.prev
}

func (e *LinkedListEntry[E]) Removed() bool {
	return e.next == nil && e.prev == nil
}

type LinkedList[E any] struct {
	entries []*LinkedListEntry[E]
	head    *LinkedListEntry[E]
	tail    *LinkedListEntry[E]
}

func NewLinkedList[E any](entries int) *LinkedList[E] {
	l := &LinkedList[E]{
		entries: make([]*LinkedListEntry[E], entries),
		head:    new(LinkedListEntry[E]),
		tail:    new(LinkedListEntry[E]),
	}
	l.init()
	return l
}

func (l *LinkedList[E]) init() {
	rawEntries := make([]LinkedListEntry[E], len(l.entries))
	for i := range rawEntries {
		l.entries[i] = &rawEntries[i]
	}
	l.entries = l.entries[:0]
	l.head.next = l.tail
	l.tail.prev = l.head
}

func (l *LinkedList[E]) Init(entries int) {
	*l = LinkedList[E]{
		entries: make([]*LinkedListEntry[E], entries),
		head:    new(LinkedListEntry[E]),
		tail:    new(LinkedListEntry[E]),
	}
	l.init()
}

func (l *LinkedList[E]) IsNil() bool {
	return l.head == nil
}

func (l *LinkedList[E]) Len() int {
	return len(l.entries)
}

func (l *LinkedList[E]) Empty() bool {
	return len(l.entries) == 0
}

func (l *LinkedList[E]) Head() (e E, exist bool) {
	return l.head.next.elem, len(l.entries) != 0
}

func (l *LinkedList[E]) HeadEntry() *LinkedListEntry[E] {
	if len(l.entries) == 0 {
		return nil
	}
	return l.head.next
}

func (l *LinkedList[E]) Tail() (e E, exist bool) {
	return l.tail.prev.elem, len(l.entries) != 0
}

func (l *LinkedList[E]) TailEntry() *LinkedListEntry[E] {
	if len(l.entries) == 0 {
		return nil
	}
	return l.tail.prev
}

func (l *LinkedList[E]) Range(f func(elem E) bool) bool {
	var next *LinkedListEntry[E]
	for cur := l.head.next; cur.next != nil; cur = next {
		next = cur.next
		if !f(cur.elem) {
			return false
		}
	}
	return true
}

func (l *LinkedList[E]) RangeEntries(f func(e *LinkedListEntry[E]) bool) bool {
	var next *LinkedListEntry[E]
	for cur := l.head.next; cur.next != nil; cur = next {
		next = cur.next
		if !f(cur) {
			return false
		}
	}
	return true
}

func (l *LinkedList[E]) Elems() (elems []E) {
	for cur := l.head.next; cur.next != nil; cur = cur.next {
		elems = append(elems, cur.elem)
	}
	return
}

func (l *LinkedList[E]) grow() int {
	el := len(l.entries)
	if el == cap(l.entries) {
		l.entries = append(l.entries, nil)
		l.entries = l.entries[:cap(l.entries)]
		rawEntries := make([]LinkedListEntry[E], cap(l.entries)-el)
		for i := range rawEntries {
			l.entries[i+el] = &rawEntries[i]
		}
		l.entries = l.entries[:el]
	}
	return el
}

func (l *LinkedList[E]) newEntry(elem E) (e *LinkedListEntry[E]) {
	el := l.grow()
	l.entries = l.entries[:el+1]
	e = l.entries[el]
	e.elem = elem
	return l.entries[el]
}

func (l *LinkedList[E]) freeEntry(e *LinkedListEntry[E]) {
	el := len(l.entries)
	l.entries[el-1] = e
	l.entries = l.entries[:el-1]
}

func (l *LinkedList[E]) addLink(e, p *LinkedListEntry[E]) {
	e.prev = p
	e.next = p.next
	p.next.prev = e
	p.next = e
}

func (l *LinkedList[E]) removeLink(e *LinkedListEntry[E]) {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next, e.prev = nil, nil
}

func (l *LinkedList[E]) insert(e, p *LinkedListEntry[E]) {
	l.addLink(e, p)
}

func (l *LinkedList[E]) remove(e *LinkedListEntry[E]) {
	l.removeLink(e)
	l.freeEntry(e)
}

func (l *LinkedList[E]) Push(e E) {
	l.insert(l.newEntry(e), l.tail.prev)
}

func (l *LinkedList[E]) Unshift(e E) {
	l.insert(l.newEntry(e), l.head)
}

func (l *LinkedList[E]) InsertBack(e E, ref *LinkedListEntry[E]) {
	l.insert(l.newEntry(e), ref)
}

func (l *LinkedList[E]) InsertFront(e E, ref *LinkedListEntry[E]) {
	l.insert(l.newEntry(e), ref.prev)
}

func (l *LinkedList[E]) RemoveEntry(e *LinkedListEntry[E]) bool {
	if e.Removed() {
		return false
	}
	l.remove(e)
	return true
}

func (l *LinkedList[E]) Shift() (e E, exist bool) {
	if len(l.entries) == 0 {
		return
	}
	entry := l.head.next
	e, exist = entry.elem, true
	l.remove(entry)
	return
}

func (l *LinkedList[E]) Pop() (e E, exist bool) {
	if len(l.entries) == 0 {
		return
	}
	entry := l.tail.prev
	e, exist = entry.elem, true
	l.remove(entry)
	return
}

func (l *LinkedList[E]) Clear() {
	for _, e := range l.entries {
		e.next, e.prev = nil, nil
	}
	l.entries = l.entries[:0]
	l.head.next = l.tail
	l.tail.prev = l.head
}