队列与环形队列（golang实现）

一、数组模拟队列

package main

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

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

//从队列添加数据
func (this *Queue) AddQueue(val int) (err error) {
	//先判断队列是否已满
	if this.rear == this.maxSize-1 {
		return errors.New("queue full")
	}
	this.rear++ //rear后移
	this.array[this.rear] = val
	return
}

//从队列取出数据
func (this *Queue) GetQueue() (val int, err error) {
	//先判断队列是否为空
	if this.rear == this.front {
		return -1, errors.New("queue empty")
	}
	this.front++
	val = this.array[this.front]
	return val, err
}

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

测试：

 

 

二、数组模拟环形队列circlequeue

1、循环队列的相关条件和公式：

队尾指针是 rear，队头是front，其中QueueSize为循环队列的最大长度
1）队空条件：rear == front
2）队满条件：（rear + 1）% QueueSize == front
3）计算队列长度： （rear - front + QueueSize）% QueueSize
4）入队： （rear + 1） % QueueSize
5）出队： （front + 1）% QueueSize

2、相关代码

//二、数组模拟环形队列circlequeue
package main

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

type CircleQueue struct {
	maxSize int    //4
	array   [5]int //数组
	head    int    //插向队列队首
	tail    int    //插向队尾
}

//添加 入队列 的方法AddQueue(push)   GetQueue(pop)
func (this *CircleQueue) Push(val int) (err error) {
	if this.IsFull() {
		return errors.New("queue full")
	}

	//this.tail在队列尾部，不包含最后的元素
	this.array[this.tail] = val
	this.tail = (this.tail + 1) % this.maxSize
	return
}

//出队列
func (this *CircleQueue) Pop() (val int, err error) {
	if this.IsEmpty() {
		return -1, errors.New("queue empty")
	}

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

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

//判断是否为空
func (this *CircleQueue) IsEmpty() bool {
	return this.tail == this.head
}

//取出环形队列有多少个元素
func (this *CircleQueue) Size() int {
	return (this.tail + this.maxSize - this.head) % this.maxSize
}

//显示队列
func (this *CircleQueue) ListQueue() {
	fmt.Println("环形队列情况如下")
	//取出当前队列有多少个元素
	size := this.Size()
	if size == 0 {
		fmt.Println("队列为空")
	}
	//设计一个辅助变量，指向head
	tempHead := this.head
	for i := 0; i < size; i++ {
		fmt.Printf("arr[%d]=%d\t", tempHead, this.array[tempHead])
		tempHead = (tempHead + 1) % this.maxSize
	}
	fmt.Println()
}

func main() {
	//先创建一个环形队列
	circlequeue := &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 := circlequeue.Push(val)
			if err != nil {
				fmt.Println(err.Error())
			} else {
				fmt.Println("添加ok")
			}
		case "get":
			val, err := circlequeue.Pop()
			if err != nil {
				fmt.Println(err.Error())
			} else {
				fmt.Printf("取出数据为 %d\n", val)
			}
		case "show":
			circlequeue.ListQueue()
		case "exit":
			os.Exit(0)
		}
	}
}

测试：

 

 

参考：尚硅谷韩顺平Go语言核心编程

 

---

欢迎大家指正补充，感谢阅读