队列

package queue

import "fmt"

// ArrayQueue 定义一个结构体
type ArrayQueue struct {
	// 表示数组最大容量
	maxSize int
	// 表示数组定位
	front int
	// 表示队列尾
	rear int
	// 切片
	array []int
}

// NewArrayQueue 写一个工厂模式创建结构体
func NewArrayQueue(maxSize int) *ArrayQueue {
	return &ArrayQueue{
		maxSize: maxSize,
		front:   -1,
		rear:    -1,
		array:   make([]int, maxSize),
	}
}

// IsFull 判断队列是否已经满了
func (arrayQueue *ArrayQueue) IsFull() bool {
	return arrayQueue.rear == arrayQueue.maxSize-1
}

// IsEmpty 判断队列是否为空
func (arrayQueue *ArrayQueue) IsEmpty() bool {
	return arrayQueue.front == arrayQueue.rear
}

// Enqueue 从队列中添加一个数据
func (arrayQueue *ArrayQueue) Enqueue(data int) bool {
	if arrayQueue.IsFull() {
		return false
	}
	arrayQueue.rear++
	arrayQueue.array[arrayQueue.rear] = data
	return true
}

// Dequeue 从队列中删除一个数据
func (arrayQueue *ArrayQueue) Dequeue() (int, bool) {
	if arrayQueue.IsEmpty() {
		return 0, false
	}
	arrayQueue.front++
	data := arrayQueue.array[arrayQueue.front]
	return data, true
}

// GetSize 获取队列的大小
func (arrayQueue *ArrayQueue) GetSize() int {
	return arrayQueue.rear - arrayQueue.front + 1
}

// Print 打印队列数据
func (arrayQueue *ArrayQueue) Print() {
	for i := arrayQueue.front + 1; i <= arrayQueue.rear; i++ {
		fmt.Println(arrayQueue.array[i])
	}
}

package main

import (
	"fmt"
	"my-practice/3.queue/arrayqueue/queue"
)

// 使用数组实现队列
func main() {

	queue := queue.NewArrayQueue(3)

	queue.Enqueue(1)
	queue.Enqueue(2)
	queue.Enqueue(3)
	queue.Enqueue(4)
	dequeue, _ := queue.Dequeue()
	fmt.Println(dequeue)
	queue.Print()
	queue.Enqueue(5)
	queue.Print()

}

package queue

import "fmt"

type RingQueue struct {
	data []interface{}
	size int
	head int
	next int
}

func NewRingQueue(size int) *RingQueue {
	return &RingQueue{
		data: make([]interface{}, size),
		size: size,
		head: 0,
		next: 0,
	}
}

func (q *RingQueue) IsFull() bool {
	return (q.next+1)%q.size == q.head
}

func (q *RingQueue) IsEmpty() bool {
	return q.head == q.next
}

func (q *RingQueue) Push(v interface{}) {
	if q.IsFull() {
		return
	}
	q.data[q.next] = v
	q.next = (q.next + 1) % q.size
}

func (q *RingQueue) Pop() interface{} {
	if q.IsEmpty() {
		return nil
	}
	v := q.data[q.head]
	q.head = (q.head + 1) % q.size
	return v
}

func (q *RingQueue) Len() int {
	return (q.next - q.head + q.size) % q.size
}

func (q *RingQueue) Print() {
	for i := q.head; i < q.head+q.Len(); i++ {
		fmt.Println(q.data[i%q.size])
	}
}

package main

import (
	"fmt"
	"my-practice/3.queue/arrayqueue/queue"
	"testing"
)

func TestArrayQueue(t *testing.T) {
	queue := queue.NewArrayQueue(3)

	queue.Enqueue(1)
	queue.Enqueue(2)
	queue.Enqueue(3)
	queue.Enqueue(4)
	dequeue, _ := queue.Dequeue()
	fmt.Println(dequeue)
	queue.Print()
	queue.Enqueue(5)
	queue.Print()
}

func TestRingQueue(t *testing.T) {
	ringQueue := queue.NewRingQueue(5)
	ringQueue.Push(1)
	ringQueue.Push("2")
	ringQueue.Push(3)
	ringQueue.Push(4)
	ringQueue.Push(5)
	ringQueue.Push(6)
	ringQueue.Print()
	fmt.Println("开始输出。。。。。")
	for i := 0; i < 5; i++ {
		fmt.Println(ringQueue.Pop())
	}
}