数据结构与算法：单向队列和环形队列

以下演示的是添加到末尾，若采用双向可以从前后任意方向取和追加（先进先出和先进后出）

单向队列的增删

package main

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

const (
	MaxQueueSize = 10
)

type Queue struct {
	maxSize int
	front   int
	rear    int
	array   [MaxQueueSize]string
}

//goland:noinspection ALL
func (this *Queue) addQueue(val string) (err error) {
	if this.rear == this.maxSize-1 {
		err = errors.New("队列已满")
	} else {
		this.rear++
		this.array[this.rear] = val
	}
	return
}

func (this *Queue) getQueue() (val string, err error) {
	if this.front == this.maxSize-1 {
		err = errors.New("队列已空")
	} else {
		this.front++
		val = this.array[this.front]
		this.array[this.front] = ""
	}
	return
}

func (this *Queue) showQueue() {
	for i := this.front + 1; i <= this.rear; i++ {
		fmt.Println(i, this.array[i])
	}
	fmt.Println()
}
func main() {
	queue := Queue{maxSize: MaxQueueSize, front: -1, rear: -1}

	for {
		var key string
		var val string
		fmt.Println("1、输入add  添加对列")
		fmt.Println("2、输入get  获取对列")
		fmt.Println("3、输入show 显示对列")
		fmt.Println("4、输入exit 退出系统")
		fmt.Print("请输入选项：")
		_, err := fmt.Scanln(&key)
		if err != nil {
			fmt.Println("未知错误：", err, "\t请重新输入")
		}
		switch key {
		case "add":
			_, err := fmt.Scanln(&val)
			if err != nil {
				fmt.Println("未知错误：", err, "\t请重新输入")
			} else {
				err = queue.addQueue(val)
				if err != nil {
					fmt.Println(err)
				}
			}
		case "get":
			val, err := queue.getQueue()
			if err != nil {
				fmt.Println(err)
			}
			fmt.Println(val)
			fmt.Println()
		case "show":
			queue.showQueue()
		case "exit":
			os.Exit(0)
		}
	}
}

环形队列的增删

package main

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

const (
	maxSize = 4
)

type CircleQueue struct {
	head    int
	tail    int
	maxSize int
	array   [maxSize]string
}

func (this *CircleQueue) Push(val string) (err error) {
	if this.IsFull() {
		return errors.New("queue is fulled...")

	}
	this.array[this.tail] = val
	this.tail = (this.tail + 1) % this.maxSize
	return
}
func (this *CircleQueue) Pop() (val string, err error) {
	if this.IsEmpty() {
		return "", errors.New("queue is empty...")
	}
	val = this.array[this.head]
	this.head = (this.head + 1) % this.maxSize
	return val, nil
}
func (this *CircleQueue) IsFull() (bol bool) {
	return (this.tail+1)%this.maxSize == this.head
}
func (this *CircleQueue) IsEmpty() (bol bool) {
	return this.head == this.tail
}
func (this *CircleQueue) Size() (size int) {
	return (this.tail + this.maxSize - this.head) % this.maxSize
}

func (this *CircleQueue) ListQueue() (err error) {
	if this.IsEmpty() {
		return errors.New("queue is empty...")
	}
	var end int
	if this.head > this.tail {
		end = this.tail + this.maxSize
	} else {
		end = this.tail
	}
	for i := this.head; i < end; i++ {
		fmt.Println(i%this.maxSize, this.array[i%this.maxSize])
	}
	return
}

func main() {
	CircleQueue := CircleQueue{maxSize: maxSize, head: 0, tail: 0}

	for {
		var key string
		var val string
		fmt.Println("1、输入add  添加对列")
		fmt.Println("2、输入get  获取对列")
		fmt.Println("3、输入show 显示对列")
		fmt.Println("4、输入exit 退出系统")
		fmt.Print("请输入选项：")
		_, err := fmt.Scanln(&key)
		if err != nil {
			fmt.Println("未知错误：", err, "\t请重新输入")
		}
		switch key {
		case "add":
			_, err := fmt.Scanln(&val)
			if err != nil {
				fmt.Println("未知错误：", err, "\t请重新输入")
			} else {
				err = CircleQueue.Push(val)
				if err != nil {
					fmt.Println(err)
				}
			}
		case "get":
			val, err := CircleQueue.Pop()
			if err != nil {
				fmt.Println(err)
			}
			fmt.Println(val)
			fmt.Println()
		case "show":
			err := CircleQueue.ListQueue()
			if err != nil {
				fmt.Println(err)
			}
		case "exit":
			os.Exit(0)
		}
	}
}