go 环形队列

package circleQueue

import (
	"errors"
)

// 环形队列
type CircleQueue struct {
	length int   // 队列长度
	head   int   // 指向队列首 0
	tail   int   // 指向队列尾 0
	data   []any // 数组 => 模拟队列
}

func New(length int) *CircleQueue {
	return &CircleQueue{
		length: length,
		data:   make([]any, length),
	}
}

// 队列是否为空
func (s *CircleQueue) IsEmpty() bool {
	return s.head == s.tail
}

// 队列是否已经满了, 采用空一格的方式
func (s *CircleQueue) IsFull() (res bool) {
	return s.head == (s.tail+1)%s.length
}

// 环形队列长度
func (s *CircleQueue) Len() (res int) {
	return (s.tail - s.head + s.length) % s.length
}

// 队列尾新增元素
func (s *CircleQueue) Push(val any) (b error) {
	if s.IsFull() {
		return errors.New("队列已满！")
	}
	s.data[s.tail] = val
	s.tail = (s.tail + 1) % s.length
	return
}

// 队列头弹出元素
func (s *CircleQueue) Pop() (val any, err error) {
	if s.IsEmpty() {
		return nil, errors.New("队列为空！")
	}
	val = s.data[s.head]
	s.head = (s.head + 1) % s.length
	return
}

func (s *CircleQueue) Each(fn func(node any)) {
	for i := s.head; i < s.tail+s.length; i++ {
		fn(s.data[i%s.length])
	}
}

// 清空
func (s *CircleQueue) Clear() {
	s.head = 0
	s.tail = 0
	s.data = make([]any, s.length)
}

package circleQueue

import (
	"fmt"
	"testing"
)

func TestNew(t *testing.T) {

	queue := New(5)
	err := queue.Push(1)
	err = queue.Push(2)
	err = queue.Push(3)
	err = queue.Push(4)
	if err != nil {
		t.Error(err)
	}
	err = queue.Push(5)
	if err != nil {
		t.Error(err)
	}

	fn := func(node any) {
		fmt.Println(node)
	}
	queue.Each(fn)

	t.Log("Push End: ")
	val, err := queue.Pop()
	if err != nil {
		t.Error(err)
		return
	}
	t.Log(val)
	t.Log("Pop End: ")

	err = queue.Push(6)
	if err != nil {
		t.Error(err)
	}
	t.Log("Len: ", queue.Len())
	t.Log("Each End: ")

	queue.Pop()
	queue.Pop()
	t.Log("Len: ", queue.Len())
	queue.Push(7)
	queue.Push(8)
	t.Log("Len: ", queue.Len())

	queue.Clear()
	t.Log("Clear End: ")
	t.Log("Len: ", queue.Len())

}