Go数据结构与算法之队列

概述

队列是一个有序列表，可以用数组或是链表来实现。

遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入的要后取出。

数组模拟队列

队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下，其中 MaxSize 是该队列的最大容量。

因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 rear 分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear 则是随着数据输入而改变。

非环形队列

当我们将数据存入队列时称为 “addqueue”，addqueue 的处理需要有两个步骤：

1. 将尾指针往后移：rear+1, front == rear【空】
2. 若尾指针 rear 小于等于队列的最大下标 MaxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 rear == MaxSize - 1 【队列满】

package main

import (
	"errors"
	"fmt"
	"os"
)

// 使用一个结构体管理队列
type Queue struct {
	maxSize int
	array   [5]int // 数组（模拟队列）
	front   int    // 表示指向队列首部
	rear    int    // 表示指向队列的尾部
}

// 添加数据到队列
func (queue *Queue) AddQueue(val int) (err error) {
	// 先判断队列是否已满
	if queue.rear == queue.maxSize {
		return errors.New("queue full")
	}

	queue.rear++
	queue.array[queue.rear] = val
	return
}

// 从队列中取出数据
func (queue *Queue) GetQueue() (val int, err error) {
	// 先判断队列是否已满
	if queue.rear == queue.front {
		return -1, errors.New("queue full")
	}

	queue.front++
	val = queue.array[queue.front]
	return val, err
}

// 显示队列，找到队首，然后到遍历到队尾
func (queue *Queue) ShowQueue() {
	fmt.Println("队列当前的情况是：")
	for i := queue.front + 1; i <= queue.rear; i++ {
		fmt.Printf("array[%d]=%d", i, queue.array[i])
	}
	fmt.Println()
}

func main() {
	queue := &Queue{
		maxSize: 5,
		front:   -1,
		rear:    -1,
	}

	var key string
	var val int

	for {
		fmt.Println("1.输入 add 表示添加数据到队列")
		fmt.Println("2.输入 get 表示从队列获取数据")
		fmt.Println("3.输入 show 表示显示队列")
		fmt.Println("4.输入 exit 表示显示队列")

		fmt.Scanln(&key)
		switch key {
		case "add":
			fmt.Println("输入你要入队列数")
			fmt.Scanln(&val)
			err := queue.AddQueue(val)
			if err != nil {
				fmt.Println(err.Error())
			} else {
				fmt.Println("加入队列 ok")
			}
		case "get":
			val, err := queue.GetQueue()
			if err != nil {
				fmt.Println(err.Error())
			} else {
				fmt.Println("从队列中取出了一个数=", val)
			}
		case "show":
			queue.ShowQueue()
		case "exit":
			os.Exit(0)
		}
	}
}

**不足之处：**虽然实现了基本队列结构，但是没有有效的利用数组空间。

环形队列

对于非环形队列(数组)的优化，充分利用数组，因此将数组看做是一个环形的。（通过取模的方式来实现）

1. 尾索引的下一个为索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意 (tail + 1) % MaxSize == head
2. tail == head 表示空

package main

import (
	"errors"
	"fmt"
	"os"
)

// 使用一个结构体管理环形队列
type CircleQueue struct {
	maxSize int    // 4
	array   [5]int // 数组
	head    int    // 指向队列队首 0
	tail    int    // 指向队尾 0
}

// 入队列
func (queue *CircleQueue) Push(val int) (err error) {
	// 先判断队列是否已满
	if queue.IsFull() {
		return errors.New("queue full")
	}

	// 分析出 queue.tail 在队列尾部，但是包含最后的元素
	queue.array[queue.tail] = val // 把值给尾部
	queue.tail = (queue.tail + 1) % queue.maxSize
	return
}

// 出队列
func (queue *CircleQueue) Pop() (val int, err error) {
	// 先判断队列是否已满
	if queue.IsFull() {
		return 0, errors.New("queue full")
	}

	// 取出 head 是指向队首，并且含队首元素
	val = queue.array[queue.head]
	queue.head = (queue.head + 1) % queue.maxSize
	return
}

// 显示队列
func (queue *CircleQueue) ListQueue() {
	fmt.Println("环形队列情况如下：")
	// 取出当前队列有多少个元素
	size := queue.Size()
	if size == 0 {
		fmt.Println("队列为空")
	}

	// 设计一个辅助的变量，指向 head
	tempHead := queue.head
	for i := 0; i < size; i++ {
		fmt.Printf("arr[%d]=%d\t", tempHead, queue.array[tempHead])
		tempHead = (tempHead + 1) % queue.maxSize
	}
	fmt.Println()
}

// 判断环形队列为满
func (queue *CircleQueue) IsFull() bool {
	return (queue.tail+1)%queue.maxSize == queue.head
}

// 判断环形队列是空
func (queue *CircleQueue) IsEmpty() bool {
	return queue.tail == queue.head
}

// 取出环形队列有多少个元素
func (queue *CircleQueue) Size() int {
	// 这是一个关键的算法
	return (queue.tail + queue.maxSize - queue.head) % queue.maxSize
}

func main() {
	// 初始化一个环形队列
	queue := &CircleQueue{
		maxSize: 5,
		head:    0,
		tail:    0,
	}
    
	var key string
	var val int
    
	for {
		fmt.Println("1.输入 add 表示添加数据到队列")
		fmt.Println("2.输入 get 表示从队列获取数据")
		fmt.Println("3.输入 show 表示显示队列")
		fmt.Println("4.输入 exit 表示显示队列")

		fmt.Scanln(&key)
		switch key {
		case "add":
			fmt.Println("输入你要入队列数")
			fmt.Scanln(&val)
			err := queue.Push(val)
			if err != nil {
				fmt.Println(err.Error())
			} else {
				fmt.Println("加入队列 ok")
			}
		case "get":
			val, err := queue.Pop()
			if err != nil {
				fmt.Println(err.Error())
			} else {
				fmt.Println("从队列中取出了一个数=", val)
			}
		case "show":
			queue.ListQueue()
		case "exit":
			os.Exit(0)
		}
	}
}