【数据结构连载一线性表】【单向循环链表】golang

package main

import (
	"fmt"
	"strconv"
)

type Node struct {
	data interface{}
	next *Node
}

type CycleLinkedList struct {
	length int
	rear   *Node
}

func NewCycleLinkedList() CycleLinkedList {
	node := Node{}
	l := CycleLinkedList{
		length: 0,
		rear:   &node,
	}
	l.rear.next = l.rear
	return l
}

func (l *CycleLinkedList) Head() *Node {
	return l.rear.next
}

func (l *CycleLinkedList) Tail() *Node {
	return l.rear
}

func (l *CycleLinkedList) Length() int {
	return l.length
}

func (l *CycleLinkedList) empty() bool {
	return l.rear == l.rear.next
}

func (l *CycleLinkedList) exist(value interface{}) bool {
	cur := l.rear.next
	tail := l.rear
	for {
		if cur == tail {
			return false
		}
		if cur.data == value {
			return true
		}
		cur = cur.next
	}
}

func (l *CycleLinkedList) Get(index int) interface{} {
	n := 0
	cur := l.rear.next
	if index >= l.length {
		return -1
	}
	tail := l.rear
	for {
		if tail == cur {
			return -1
		}
		if n == index {
			return cur.data
		}
		n++
		cur = cur.next
	}
}

func (l *CycleLinkedList) Add(value interface{}) {
	cur := l.rear
	newNode := Node{
		data: value,
		next: cur.next,
	}
	cur.next = &newNode
	l.length++

}

func (l *CycleLinkedList) Append(value interface{}) {
	cur := l.rear
	tail := l.rear
	for {
		if cur.next == tail {
			break
		}
		cur = cur.next
	}
	newNode := Node{value, cur.next}
	cur.next = &newNode
	l.length++
}

func (l *CycleLinkedList) Insert(index int, value interface{}) {
	if index < 0 {
		panic("位置插入不能为:" + strconv.Itoa(index))
	}
	newNode := Node{
		data: value,
	}
	cur := l.rear
	tail := l.rear
	n := 0
	for {
		if cur.next == tail {
			break
		}
		if n == index {
			newNode.next = cur.next
			cur.next = &newNode
			l.length++
			return
		}
		n++
		cur = cur.next
	}
	newNode.next = cur.next
	cur.next = &newNode
	l.length++
}

func (l *CycleLinkedList) Index(value interface{}) int {
	cur := l.rear.next
	tail := l.rear
	n := 0
	for {
		if cur == tail {
			return -1
		}
		if cur.data == value {
			return n
		}
		n++
		cur = cur.next
	}
}

func (l *CycleLinkedList) Delete(index int) {
	if index >= l.length {
		panic("下标不存在" + strconv.Itoa(index))
	}
	cur := l.rear
	tail := l.rear
	n := 0
	for {
		if cur.next == tail {
			panic("下标不存在" + strconv.Itoa(index))
		}
		if n == index {
			cur.next = cur.next.next
			l.length--
			break
		}
		n++
		cur = cur.next
	}
}

func (l *CycleLinkedList) Remove(value interface{}) {
	cur := l.rear
	tail := l.rear
	for {
		if cur.next == tail {
			panic(fmt.Sprintf("数据不存在: %v", value))
		}
		if cur.next.data == value {
			cur.next = cur.next.next
			l.length--
			break
		}
		cur = cur.next
	}
}

func (l *CycleLinkedList) Pop() interface{} {
	if l.length == 0 {
		panic("链表为空")
	}
	cur := l.rear
	tail := l.rear
	for {
		if cur.next.next == tail {
			break
		}
		cur = cur.next
	}
	data := cur.next.data
	cur.next = cur.next.next
	l.length--
	return data
}

func (l *CycleLinkedList) Show() {
	cur := l.rear.next
	tail := l.rear
	for {
		if tail == cur {
			break
		}
		fmt.Print(cur.data, " ")
		cur = cur.next
	}
	fmt.Println()
}
func main() {
	l := NewCycleLinkedList()
	l.Add(10)
	l.Add(9)
	l.Add(8)
	l.Append(7)
	l.Insert(1, 19)
	fmt.Println(l.Index(1))
	l.Show()
	l.Delete(3)
	l.Remove(19)
	l.Show()
	fmt.Println(l.Pop())
	fmt.Println(l.Pop())
	l.Show()
}