Golang实现数组模拟栈和队列_golang 队列-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_61453210/article/details/139222860

栈

栈的介绍

栈是一种后进先出（Last In First Out，LIFO）的数据结构。可以将栈看作是一种容器，可以在容器的顶部进行插入（push）和删除（pop）操作。在栈中，最后插入的元素将首先被删除。栈可以用于实现函数调用、表达式求值等应用场景。常用的栈操作还包括查看栈顶元素（top）和判断栈是否为空。

栈的算法实现

结构体的定义

MaxTop代表栈中最大存储元素数量；Top代表栈顶元素的下标数；arr 代表数组

type Stack struct {
	MaxTop int 
	Top    int 
	arr    [5]int
}

入栈操作

每次压入一个元素

首先判断栈是否为满，如果栈顶元素的下标数+1等于栈的最大存储量即表示栈满。否则将栈顶元素的下标数+1，将要入栈的值压入数组中

func (s *Stack) Push(val int) {
	if s.MaxTop == s.Top+1 {
		fmt.Println("stack overflow")
		return
	}
	s.Top++
	s.arr[s.Top] = val
}

一次性压入多个元素

前置条件和上面的相同，入栈的时候通过循环将元素压入栈中。

func (s *Stack) Push2(val ...int) {
	if s.MaxTop == s.Top+1 {
		fmt.Println("stack overflow")
		return
	}
	for _, v := range val {
		s.Push(v)
	}
}

出栈操作

首先判断栈是否为空，然后将栈顶元素弹出栈，将栈顶元素的下标减一。

func (s *Stack) Pop() int {
	if s.Top == -1 {
		fmt.Println("空栈")
		return 0
	}
	v := s.arr[s.Top]
	s.Top--
	return v
}

显示栈中元素操作

首先还是判断是否为空栈，然后通过循环进行输出栈中元素

func (s *Stack) Peek() {
	if s.Top == -1 {
		fmt.Println("空栈")
		return
	}
	fmt.Println("栈中元素：")
	for i := s.Top; i >= 0; i-- {
		fmt.Printf("arr[%d]=%d\n", i, s.arr[i])
	}
	//下面的显示栈效果一样
	//for k, v := range s.arr {
	//	fmt.Printf("arr[%d]=%d\n", k, v)
	//}
}

整体代码

package main

import "fmt"

type Stack struct {
	MaxTop int 
	Top    int 
	arr    [5]int
}

// Push 入栈
func (s *Stack) Push(val int) {
	if s.MaxTop == s.Top+1 {
		fmt.Println("stack overflow")
		return
	}
	s.Top++
	s.arr[s.Top] = val
}

// Push2 一次性入栈多个元素
func (s *Stack) Push2(val ...int) {
	if s.MaxTop == s.Top+1 {
		fmt.Println("stack overflow")
		return
	}
	for _, v := range val {
		s.Push(v)
	}
}

// Pop 出栈
func (s *Stack) Pop() int {
	if s.Top == -1 {
		fmt.Println("空栈")
		return 0
	}
	v := s.arr[s.Top]
	s.Top--
	return v
}

// Peek 显示栈
func (s *Stack) Peek() {
	if s.Top == -1 {
		fmt.Println("空栈")
		return
	}
	fmt.Println("栈中元素：")
	for i := s.Top; i >= 0; i-- {
		fmt.Printf("arr[%d]=%d\n", i, s.arr[i])
	}
	//下面的显示栈效果一样
	//for k, v := range s.arr {
	//	fmt.Printf("arr[%d]=%d\n", k, v)
	//}
}

func main() {
	stack := &Stack{
		MaxTop: 5,
		Top:    -1, //当栈顶为-1,表示空栈
	}
	stack.Push(1)
	stack.Push(2)
	stack.Push(3)
	stack.Push(4)
	stack.Push(5)
	stack.Peek()
	v := stack.Pop()
	fmt.Println("出栈元素为", v)
	stack.Peek()
}

运行结果

队列

队列的介绍

队列是一种先进先出（First In First Out，FIFO）的数据结构。可以将队列看作是一种容器，可以在容器的尾部进行插入（enqueue）操作，在容器的头部进行删除（dequeue）操作。在队列中，最先插入的元素将首先被删除。队列可以用于实现任务调度、消息传递等应用场景。常用的队列操作还包括查看队列头部元素（front）和判断队列是否为空。

队列的算法实现

结构体的定义

maxSize代表数组的最大长度；arr代表操作的数组；front代表队列的队首的前一个元素下标；rear代表队列的队尾的下标。

type Queue struct {
	maxSize int
	arr     [4]int
	front   int 
	rear    int 
}

入队列操作

首先通过队尾元素和队列的长度进行判断队列是否为满，如果未满将队尾元素的下标+1，并将要压入的数据添加进队列

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

出队列操作

判断队列是否为空，然后将front++，然后将弹出队列的值输出

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

显示队列操作

通过循环输出队列的元素

func (this *Queue) ShowQueue() {
	fmt.Println("队列的当前情况是:")
	for i := this.front + 1; i <= this.rear; i++ {
		fmt.Printf("arr[%d]=%d\t", i, this.arr[i])
	}
	fmt.Println()
}

整体代码

package main

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

// Queue 使用结构体管理队列
type Queue struct {
	maxSize int
	arr     [4]int
	front   int 
	rear    int 
}

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

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

// ShowQueue 显示队列
func (this *Queue) ShowQueue() {
	fmt.Println("队列的当前情况是:")
	for i := this.front + 1; i <= this.rear; i++ {
		fmt.Printf("arr[%d]=%d\t", i, this.arr[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.Println("----------------------------")
		fmt.Println("请输入要执行的操作：")
		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("加入队列成功")

			}
		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)
		}
	}
}