Go数据结构之数组队列

一：队列介绍

之前的随笔有提过简单提过队列

①：队列是一个有序的表可以通过数组和链表来表现；

②：遵循先进先出原则

二：非环形队列

①：若使用数组结构存储队列数据，则队列数组的必须声明一个最大队列容量如maxSize,因为队列的输出输入是分别从前后端来处理，因此需要两个变量来记录队列前后端的下标，如front(head)记录前端，rear(tail)记录后端；

②：示意图

③：使用细节

数据存入非环形数组队列时要有两个步骤

③-1：将尾指针往后移：rear++,当front==rear时表明队列为空

③-2：若尾指针rear小于等于队列maxSize-1,则将存入数据rear所在的数组元素中；当rear==maxSize-1时代表队列已满

④：使用举例

package main

import (
	"fmt"
	"errors"
)

//定义数组队列
type QueueArr struct{
	MaxSize int
	array [5]int
	front int 
	rear int
}
//添加
func (this *QueueArr) AddQueue(val int) (err error){
	if this.rear+1 == this.MaxSize {
		return errors.New("队列已满")
	}

	this.rear++
	this.array[this.rear] = val
	return 
}
//展示所有
func (this *QueueArr) GetQueue() (err error){
	if this.rear == this.front {
		return errors.New("队列为空")
	}

	for i := this.front+1; i <= this.rear; i++ {
		fmt.Printf("队列第%d=%v\n", i+1, this.array[i]);
	}
	return
}
//获取一个数据
func (this *QueueArr) GetOneQueue() (val int, err error){
	if this.rear == this.front {
		return -1, errors.New("队列为空")
	}
	this.front++
	val = this.array[this.front]
	return val, err
}

func main() {
	//初始化队列
	queueArr := &QueueArr{
		MaxSize : 5,
		front : -1,
		rear : -1,
	}
	//添加三个数据到队列
	err := queueArr.AddQueue(0)
	err = queueArr.AddQueue(1)
	err = queueArr.AddQueue(2)
	if err != nil {
		fmt.Println("添加数据到队列错误：", err)
	}
	//读取所有队列数据
	err = queueArr.GetQueue()
	if err != nil {
		fmt.Println("读取数据到队列错误：", err)
	}
	// 联系多次获取单个数据
	val, err := queueArr.GetOneQueue()
	if err != nil {
		fmt.Println(err)
	}else{
		fmt.Println("获取当个数据：", val)
	}
	val, err = queueArr.GetOneQueue()
	if err != nil {
		fmt.Println(err)
	}else{
		fmt.Println("获取当个数据：", val)
	}
	val, err = queueArr.GetOneQueue()
	if err != nil {
		fmt.Println(err)
	}else{
		fmt.Println("获取当个数据：", val)
	}
	val, err = queueArr.GetOneQueue()
	if err != nil {
		fmt.Println(err)
	}else{
		fmt.Println("获取当个数据：", val)
	}
	val, err = queueArr.GetOneQueue()
	if err != nil {
		fmt.Println(err)
	}else{
		fmt.Println("获取当个数据：", val)
	}
}

结果
[ `go run queueArr.go` | done ]
	队列第1=0
	队列第2=1
	队列第3=2
	获取当个数据： 0
	获取当个数据： 1
	获取当个数据： 2
	队列为空
	队列为空

 三：环形数组队列

①：环形数组队列时对非环形数组队列的升级，可以有效的提高资源利用率，而不是一次性使用；

②：和非环形数组不同的是，环形数组需要预留一个空间作为尾索引(约定)；

③：使用细节

　　③-1：(tail+1)%maxSize==head代表队列已满；

　　③-2：tail==head代表队列为空；

　　③-3：初始化时tail=0,head=0，不同于非环形队列的-1；

　　③-4：计算队列还有多少个元素(tail+maxSize-head)%maxSize

④：使用举例

package main
 
import (
    "fmt"
    "errors"
)
 
type CircleQueue struct{
    MaxSize int
    array [5]int
    head int
    tail int
}
 
//添加
func (this *CircleQueue) AddQueue(val int) (err error){
    if (this.tail+1)%this.MaxSize == this.head{
        return errors.New("队列已满")
    }

    // if(this.tail == this.MaxSize){
    //     this.tail = 0
    // }
    this.array[this.tail] = val

    this.tail = (this.tail+1)%this.MaxSize
    return
}
//展示所有
func (this *CircleQueue) GetQueue() (err error){
    if this.head == this.tail {
        return errors.New("队列为空")
    }
 
    for i := this.head; i != this.tail; i = (i+1)%this.MaxSize {
        fmt.Printf("队列第%d=%v\n", i, this.array[i]);
    }
    return
}
//获取一个数据
func (this *CircleQueue) GetOneQueue() (val int, err error){
    fmt.Println("index=", (this.head+this.MaxSize)%this.MaxSize)
    if this.tail == this.head {
        return 0, errors.New("队列为空")
    }
    val = this.array[(this.head+this.MaxSize)%this.MaxSize]
    this.head = (this.head+1)%this.MaxSize

    return val, err
}
 
func (this *CircleQueue) GetNum() (val int){
    return (this.tail+this.MaxSize-this.head)%this.MaxSize
}

func main() {
    //初始化环形队列
    circleQueue := &CircleQueue{
        MaxSize : 5,
        head : 0,
        tail : 0,  
    }
 
    //添加数据
    circleQueue.AddQueue(1)
    circleQueue.AddQueue(2)
    circleQueue.AddQueue(3)
    circleQueue.AddQueue(4)
    // circleQueue.AddQueue(5)
    //读取所有数据
    circleQueue.GetQueue()
    //获取4个单个数据
    val, err := circleQueue.GetOneQueue()
    if err != nil {
        fmt.Println(err)
    }else{
        fmt.Println(val)
    }

    err = circleQueue.AddQueue(5)
    if err != nil {
        fmt.Println(err)
    }
    circleQueue.GetQueue()
}
结果
[ `go run circleQueue.go` | done ]
队列第0=1
队列第1=2
队列第2=3
队列第3=4
index= 0
1
队列第1=2
队列第2=3
队列第3=4
队列第4=5