循环队列——Golang实现

用数组实现的队列叫作顺序队列，用链表实现的队列叫作链式队列。

由于顺序队列采用连续的空间存储数据，CPU处理速度快于链式队列，且用处比较多，比如Go语言中的有缓冲channel类型，因此本文主要讲解基于顺序循环队列。

循环队列，顾名思义，它长得像一个环。原本数组是有头有尾的，是一条直线。现在我们把首尾相连，扳成了一个环。我画了一张图，你可以直观地感受一下。

 在用数组实现的非循环队列中，队满的判断条件是 tail == n，队空的判断条件是 head == tail。那针对循环队列，如何判断队空和队满呢？

队列为空的判断条件仍然是 head == tail。但队列满的判断条件就稍微有点复杂了。我画了一张队列满的图，你可以看一下，试着总结一下规律。

就像我图中画的队满的情况，tail=3，head=4，n=8，所以总结一下规律就是：(3+1)%8=4。多画几张队满的图，你就会发现，当队满时，(tail+1)%n=head。

你有没有发现，当队列满时，图中的 tail 指向的位置实际上是没有存储数据的。所以，循环队列会浪费一个数组的存储空间。

package main

import "fmt"

type Queue struct {
	Array []interface{}
	Head  int
	Tail  int
}

func newQueue(n uint16) *Queue {
	arr := make([]interface{}, n, n)
	newQueue := &Queue{
		Array: arr,
		Head:  0,
		Tail:  0,
	}
	return newQueue
}

//循环队列的是否满的判断条件为： （tail+1）%n==head
func (q *Queue) Push(data interface{}) {
	n := cap(q.Array)
	if (q.Tail+1)%n == q.Head {
		fmt.Println("队列已满")
		return
	}
	q.Array[q.Tail] = data
	if q.Tail >= cap(q.Array)-1 {
		q.Tail = 0
	} else {
		q.Tail++
	}
}

//队列为空的判断条件：tail==head
func (q *Queue) Pop() interface{} {
	if q.Tail == q.Head {
		fmt.Println("队列为空")
		return nil
	}
	data := q.Array[q.Head]
	q.Array[q.Head]=nil
	if q.Head >= cap(q.Array)-1 {
		q.Head = 0
	} else {
		q.Head++
	}
	return data
}
func main() {
	queue := newQueue(3)
	queue.Push(1)
	queue.Push(2)

	fmt.Println(queue.Pop())
	queue.Push("333")
	fmt.Println(queue.Pop())
	queue.Push(333)
	fmt.Println(queue.Pop())
	fmt.Println(queue.Pop())
	queue.Push("hello")
	queue.Push("golang")
	fmt.Println(queue.Pop())
	queue.Push("OK")
	fmt.Println(queue.Pop())
	fmt.Println(queue.Pop())
}