队列

概念

队列是一种特殊的线性表，特殊之处在于它遵循先入先出（FIFO）原则，只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列区分

根据队列的存储方式不同可以分为顺序存储（数组）和链式存储（链表），根据链表的形式又可以分为顺队列与循环队列

顺序队列

顺序队列顾名思义就是一条路走到黑，front指向队头，rear指向队尾，通过这两个下标对队列进行操作，如下图所示：

每次在队尾插入一个元素是，rear增1；每次在队头删除一个元素时，front增1。随着插入和删除操作的进行，队列元素的个数不断变化，队列所占的存储空间也在为队列结构所分配的连续空间中移动。当front=rear时，队列中没有任何元素，称为空队列。当rear增加到指向分配的连续空间之外时，队列无法再插入新元素。

顺序队列实现

package queueimport "fmt"type Queue struct {maxSize intfront   int // 队列头节点默认为节点的前一个rear    int // 队列尾节点queue   []int
}func NewQueue(maxSize int) *Queue {q := new(Queue)q.maxSize = maxSizeq.queue = make([]int, 0,maxSize)q.front = -1q.rear = -1return q
}// Add 向队列中添加元素
func (q *Queue) Add (val int)  {if q.isFull() {fmt.Println("当前队列已满！")return}q.queue = append(q.queue, val)q.rear++return
}// Get 从队列中获取元素
func (q *Queue) Get () int {if q.isEmpty() {return -1}q.front++return q.queue[q.front]
}// Show 查看整个队列元素
func (q *Queue) Show() []int{if q.isEmpty() {return []int{}}queues := make([]int, 0,q.maxSize)for i := q.front +1; i <= q.rear; i++{queues = append(queues, q.queue[i])}return queues
}// 队列是否满了？
func (q *Queue) isFull() bool {return q.rear == q.maxSize-1
}// 队列是否为空
func (q *Queue) isEmpty() bool {return q.rear == q.front
}
``
```bash
package mainimport ("Queue/queue""fmt"
)func main()  {fmt.Println("add 添加元素")fmt.Println("get 获取元素")fmt.Println("show 查看所有元素")fmt.Println("exit 退出程序")fmt.Printf("请输入队列长度：")var queueLen intfmt.Scanln(&queueLen)q := queue.NewQueue(queueLen)fmt.Println("队列容积：", queueLen)for {var point stringfmt.Scanln(&point)switch point {case "add":fmt.Printf("输入添加元素：")var val int_, err := fmt.Scanln(&val)if err != nil {continue}q.Add(val)case "get":getVal := q.Get()if getVal == -1{fmt.Println("队列为空，请先添加元素^_^")}else{fmt.Println("获取元素：", getVal)}case "show":vals := q.Show()if len(vals) == 0 {fmt.Println("队列为空，请先添加元素^_^")}else{fmt.Println("队列全部元素为：", vals)}case "exit":fmt.Println("bey~~")returndefault :fmt.Println("输入有误，请重新输入-_-!!")}}
}

运行效果

顺序队列中的溢出现象：

（1） "下溢"现象：当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。
（2）"真上溢"现象：当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。
（3）"假上溢"现象：由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为"假上溢"现象。

可以发现，当rear增加到指向分配的连续空间之外时，队列无法再插入新元素，但这时往往还有大量可用空间未被占用，这些空间是已经出队的队列元素曾经占用过得存储单元。既然这个问题这么明显，肯定会有一个方案去解决。

循环队列

像前面说的，顺序队列很容易就会造成空间的浪费，为了使队列空间能重复使用，需要对顺序队列的使用方法稍加改进：

1. 无论插入或删除，一旦rear指针增1或front指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。
2. 自己真从MaxSize-1增1变到0，可用取余运算rear%MaxSize和front%MaxSize来实现。
   

这实际上是把队列空间想象成一个环形空间，环形空间中的存储单元循环使用，用这种方法管理的队列也就称为循环队列。除了一些简单应用之外，真正实用的队列是循环队列。
在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。
循环的队列的状态如图所示：

循环队列实现

package circleQueueimport "fmt"type CircleQueue struct {front   int //头节点下标rear    int //尾节点下标maxSize int //队列容积queue   []int
}func NewCircleQueue(maxSize int) *CircleQueue {q := new(CircleQueue)q.maxSize = maxSize + 1 // 预留一个空位置做判断q.front = 0q.rear = 0q.queue = make([]int, q.maxSize)return q
}// Add 向队列中添加元素
func (q *CircleQueue) Add(val int) {if q.isFull() {fmt.Println("当前队列已满！")return}q.queue[q.rear] = valq.rear = (q.rear + 1) % q.maxSizereturn
}// Get 从队列中获取元素
func (q *CircleQueue) Get() int {if q.isEmpty() {return -1}defer func() {q.front = (q.front + 1) % q.maxSize}()return q.queue[q.front]
}// Show 查看整个队列元素
func (q *CircleQueue) Show() []int {if q.isEmpty() {return []int{}}// rear = 1   front = 3  1+4-3// rear = 3   front = 1  3+4-1queues := make([]int, 0, q.maxSize)for i := q.front; i < q.front + q.queueSize(); i++ {queues = append(queues, q.queue[i % q.maxSize])}return queues
}// 队列是否满了？
func (q *CircleQueue) isFull() bool {return (q.rear+1)%q.maxSize == q.front
}// 队列是否为空
func (q *CircleQueue) isEmpty() bool {return q.rear == q.front
}// 获取队列元素个数
func (q *CircleQueue) queueSize() int {return (q.rear + q.maxSize - q.front) % q.maxSize
}

package mainimport ("Queue/circleQueue""fmt"
)func main()  {fmt.Println("add 添加元素")fmt.Println("get 获取元素")fmt.Println("show 查看所有元素")fmt.Println("exit 退出程序")fmt.Printf("请输入队列长度：")var queueLen intfmt.Scanln(&queueLen)q := circleQueue.NewCircleQueue(queueLen)fmt.Println("队列容积：", queueLen)for {var point stringfmt.Scanln(&point)switch point {case "add":fmt.Printf("输入添加元素：")var val int_, err := fmt.Scanln(&val)if err != nil {continue}q.Add(val)case "get":getVal := q.Get()if getVal == -1{fmt.Println("队列为空，请先添加元素^_^")}else{fmt.Println("获取元素：", getVal)}case "show":vals := q.Show()if len(vals) == 0 {fmt.Println("队列为空，请先添加元素^_^")}else{fmt.Println("队列全部元素为：", vals)}case "exit":fmt.Println("bey~~")returndefault :fmt.Println("输入有误，请重新输入-_-!!")}}}

运行效果

由于最近在学习go语言，所以就用golang实现了^^_^