Go The Way 之 队列

原创 Go The Way 之 队列

队列是一个有序列表，可以用数组或者链表来实现
遵循先进先出的远程，即： 先存入队列的数据，要先取出，后存入的数据要后取出

简单队列（数组实现）

package main

import (
	"errors"
	"fmt"
)
type Queue struct {
	maxSize int
	array [5]int
	front int //表示指向队列首
	rear int  // 表示指向队列的尾部

}
func (this *Queue) AddQueue(val int) error {
	// 先判断队列是否已经满了
	if this.rear == this.maxSize - 1 {
		return errors.New("队列已满")
	}
	this.rear++

	this.array[this.rear] = val
	return nil
}
// 出队列
func (this *Queue) GetQueue() (int, error) {
	if this.front == this.rear {
		if this.rear ==  this.maxSize - 1 {
			fmt.Println("开始初始化队列。。")
			this.rear = -1
			this.front = -1
			return 0, errors.New("队列已初始化")
		}
		return 0, errors.New("队列已空")
	}
	this.front++
	val := this.array[this.front]
	return val, nil
}
func (this *Queue) ShowQueue() {

	fmt.Println("队列当前的情况是：---")
	// this.front 虽然表示队首，但是不包含队首的元素
	for i:= this.front+1; i<= this.rear;i++ {
		fmt.Printf("array[%d] = %d\n", i, this.array[i])
	}
}
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.Println("请输入你的操作!\n")

		fmt.Scanln(&key)
		switch key {
			case "add":
				fmt.Println("请输入你要加入的值：")
				fmt.Scanln(&val)
				err := queue.AddQueue(val)
				if err != nil {
					fmt.Println(err)
				}
			case "get":
				val, err := queue.GetQueue()
				if err != nil {
					fmt.Println(err)
				}
				fmt.Printf("取出的数据为: %d, 此时队列还有的数据为 ：\n", val)
				queue.ShowQueue()

			case "show":
				queue.ShowQueue()
			case "exit":
				return
		}

	}
}

循环队列（数组实现）

package main

import (
	"errors"
	"fmt"
)

/**
环形队列
 */
type CircleQueue struct {
	maxSize 	int
	array 		[5]int
	head 		int // 指向队列的队首
	tail 		int //指向队列的队尾
}

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) Push(val int) error {
	if this.ISFull() {
		return errors.New("队列已满")
	}

	this.array[this.tail] = val
	// 环形队列
	this.tail = (this.tail + 1) % this.maxSize

	return nil
}

//从队列中取出
func (this *CircleQueue) Pop() (int, error) {
	if this.IsEmpty() {
		return -1, errors.New("队列已空")
	}

	// 取出数据，head 是指向队首的，队首中有值
	val := this.array[this.head]
	// 环形队列
	this.head = (this.head + 1) % this.maxSize

	return val, nil
}

func (this *CircleQueue) Show() {
	fmt.Println("环形队列此时数据如下：")
	size := this.Size()
	if size == 0 {
		fmt.Println("队列已为空")
	}

	// 设置一个辅助变量
	temHead := this.head

	for i:=0 ;i< size;i++ {
		fmt.Printf("array[%d] = %d \n", temHead, this.array[temHead])
		temHead = (temHead + 1) % this.maxSize
	}
}



func main()  {

	queue := &CircleQueue{
		maxSize: 5,
		tail: 0,
		head: 0,
	}
	// 由于使用数组作为存储环形队列的容器， 为了实现需要空出最后一个索引代表的位置，作为队列的连接处。
	// 所以这里这个队列最多存储 4个值
	var key string
	var val  int

	for {
		fmt.Println("1. 输入add 表示添加队列")
		fmt.Println("2. 输入get 表示获取队列的值")
		fmt.Println("3. 输入show 表示显示队列的值")
		fmt.Println("4. 输入exit 表示结束程序")
		fmt.Println("请输入你的操作!\n")

		fmt.Scanln(&key)
		switch key {
		case "add":
			fmt.Println("请输入你要加入的值：")
			fmt.Scanln(&val)
			err := queue.Push(val)
			if err != nil {
				fmt.Println(err)
			}
		case "get":
			val, err := queue.Pop()
			if err != nil {
				fmt.Println(err)
			}
			fmt.Printf("取出的数据为: %d, 此时队列还有的数据为 ：\n", val)
			queue.Show()

		case "show":
			queue.Show()
		case "exit":
			return
		}

	}
}