GO语言-数据结构-队列

最新推荐文章于 2024-04-15 09:34:36 发布
最新推荐文章于 2024-04-15 09:34:36 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： 数据结构与算法 Golang 文章标签： go 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq522044637/article/details/126158885
版权

目录

1.队列的顺序存储结构

1.1 队列顺序存储结构-结构体定义

1.2 队列顺序存储结构--初始化队列

1.3 队列顺序存储结构-入队

1.4 队列顺序存储结构-出队

1.5 完整代码

2.循环队列

2.1 循环队列-入队

2.2 循环队列-出队

2.3 循环队列完整代码

3.队列的链式存储结构

3.1 队列的链式存储结构-结构体定义

3.2 队列的链式存储结构-队列初始化

3.3 队列的链式存储结构-入队

3.4 队列的链式存储结构-出队

3.5 完整代码 

 队列（Queue），是具有一定操作限制的线性表。只能在一端插入，在另一端删除。

  • 插入数据：入队（AddQ）
  • 删除数据：出队（DeleteQ）
  • 先进先出：First In First Out（FIFO）

队列的抽象数据类型描述

数据对象集：一个有0或多个元素的线性表。

操作集：

  1. 生成长度为MaxSize的空队列
  2. 判断队列是否已满
  3. 判断队列是否已空
  4. 将元素插入队列中
  5. 将元素从队列中删除并返回

1.队列的顺序存储结构

队列的顺序存储结构组成：一个一维数组、一个记录队列头元素位置的变量front、一个记录队列尾元素的变量rear。

  • 可以声明front=0，rear=-1。每次入队rear+1，每次出队front+1。
  • rear-front=-1时，队列空。
  • rear+1=MaxSize时，队列满。

1.1 队列顺序存储结构-结构体定义

type Queue struct {
	front      int
	rear       int
	queueArray [6]int
}

1.2 队列顺序存储结构--初始化队列

func initQueue() (queue *Queue) {
	//初始化队列
	queue = &Queue{
		front:      0,
		rear:       -1,
		queueArray: [6]int{},
	}
	return queue
}

1.3 队列顺序存储结构-入队

func (q *Queue) addQueue(v int) error {
	//判断队列是否已满
	if q.Rear+1 == q.MaxSize {
		return errors.New("队列已满")
	}

	q.Rear += 1              //队尾下标+1
	q.QueueArray[q.Rear] = v //数据插入队尾

	return nil
}

1.4 队列顺序存储结构-出队

func (q *Queue) deleteQueue() (int, error) {
	//判断队列否为空
	if q.Rear-q.Front == -1 {
		return -1, errors.New("队列为空")
	}

	v := q.QueueArray[q.Front] //获取队列头部元素值
	q.Front += 1               //队头下标+1

	return v, nil
}

1.5 完整代码

package main

import (
	"errors"
	"fmt"
)

type Queue struct {
	Front      int
	Rear       int
	MaxSize    int
	QueueArray [6]int
}

func main() {
	//初始化队列
	queue := initQueue()

	//队列最大能存储6个元素，最大队尾下标为5
	queue.addQueue(100)
	queue.addQueue(200)
	fmt.Println("入队两个元素")
	fmt.Printf("队列: %v, 队头front: %v, 队尾rear: %v\n", queue.QueueArray, queue.Front, queue.Rear)

	v, err := queue.deleteQueue()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("出队元素: %v, 队头front: %v, 队尾rear: %v\n", v, queue.Front, queue.Rear)
	}

	//入队5个元素
	for i := 1; i <= 5; i++ {
		err := queue.addQueue(i)
		if err != nil {
			fmt.Println(err)
		}
	}
	fmt.Printf("队列: %v, 队头front: %v, 队尾rear: %v\n", queue.QueueArray, queue.Front, queue.Rear)
}

//队列初始化
func initQueue() (queue *Queue) {
	//初始化队列
	queue = &Queue{
		Front:      0,
		Rear:       -1,
		MaxSize:    6,
		QueueArray: [6]int{},
	}
	return queue
}

//队列-入队
func (q *Queue) addQueue(v int) error {
	//判断队列是否已满
	if q.Rear+1 == q.MaxSize {
		return errors.New("队列已满")
	}

	q.Rear += 1              //队尾下标+1
	q.QueueArray[q.Rear] = v //数据插入队尾

	return nil
}

//队列-出队
func (q *Queue) deleteQueue() (int, error) {
	//判断队列否为空
	if q.Rear-q.Front == -1 {
		return -1, errors.New("队列为空")
	}

	v := q.QueueArray[q.Front] //获取队列头部元素值
	q.QueueArray[q.Front] = 0  //出队数据置为0
	q.Front += 1               //队头下标+1

	return v, nil
}

 

2.循环队列

经过多次的入队和出队，队尾会达到数组的限制，而对头会空出几个位置。为了更好地利用数组的空间，则引入循环队列的概念。

  • 可以声明front=0，rear=-1。每次入队rear+1，每次出队front+1。
  • 循环存入时，rear和front的值一直累加。需要确定front和rear下标时，使用front和rear与数组MaxSize取模。
  • rear-front=-1时，队列空。
  • rear-front+1=MaxSize时，队列满。

循环队列的实现与常规的使用数组实现的非循环队列的区别就在于，循环队列的出栈和入栈时的队front和rear的操作有所不同。

2.1 循环队列-入队

func (q *Queue) addQueue(v int) error {
	//判断循环队列是否已满
	if q.Rear-q.Frount+1 == q.MaxSize {
		return errors.New("循环队列已满")
	}

	q.Rear += 1                        //队尾下标+1
	q.QueueArray[q.Rear%q.MaxSize] = v //数据入队尾;rear与MaxSize去模，获取实际数组下标

	return nil
}

2.2 循环队列-出队

func (q *Queue) deleteQueue() (int, error) {
	//判断循环队列否为空
	if q.Rear-q.Frount == -1 {
		return -1, errors.New("队列为空")
	}

	v := q.QueueArray[q.Frount%q.MaxSize] //获取队列头部元素值;front与MaxSize去模，获取实际数组下标
	q.QueueArray[q.Frount%q.MaxSize] = 0  //出队数据置为0
	q.Frount += 1                         //队头下标+1

	return v, nil
}

2.3 循环队列完整代码

package main

import (
	"errors"
	"fmt"
)

type Queue struct {
	Frount     int
	Rear       int
	MaxSize    int
	QueueArray [6]int
}

type QueueNode struct {
}

func main() {
	//初始化队列
	queue := initQueue()

	//队列最大能存储6个元素，最大队尾下标为5
	queue.addQueue(100)
	queue.addQueue(200)
	fmt.Println("入队两个元素")
	fmt.Printf("队列: %v, 队头front: %v, 队尾rear: %v\n", queue.QueueArray, queue.Frount, queue.Rear)

	v, err := queue.deleteQueue()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("出队元素: %v, 队头front: %v, 队尾rear: %v\n", v, queue.Frount, queue.Rear)
	}

	//循环：入队2个元素，出队一个元素
	fmt.Println("---循环：入队2个元素，出队一个元素---")
	for i := 1; i <= 5; i++ {
		fmt.Printf("第%v次循环:\n", i)
		err := queue.addQueue(i)
		if err != nil {
			fmt.Println(err)
			break
		}
		fmt.Printf("队列: %v, 队头front: %v, 队尾rear: %v\n", queue.QueueArray, queue.Frount, queue.Rear)

		err = queue.addQueue(i)
		if err != nil {
			fmt.Println(err)
			break
		}
		fmt.Printf("队列: %v, 队头front: %v, 队尾rear: %v\n", queue.QueueArray, queue.Frount, queue.Rear)

		queue.deleteQueue()
		fmt.Printf("队列: %v, 队头front: %v, 队尾rear: %v\n", queue.QueueArray, queue.Frount, queue.Rear)
	}
}

//队列初始化
func initQueue() (queue *Queue) {
	//初始化队列
	queue = &Queue{
		Frount:     0,
		Rear:       -1,
		MaxSize:    6,
		QueueArray: [6]int{},
	}
	return queue
}

//队列-入队
func (q *Queue) addQueue(v int) error {
	//判断循环队列是否已满
	if q.Rear-q.Frount+1 == q.MaxSize {
		return errors.New("循环队列已满")
	}

	q.Rear += 1                        //队尾下标+1
	q.QueueArray[q.Rear%q.MaxSize] = v //数据入队尾;rear与MaxSize去模，获取实际数组下标

	return nil
}

//队列-出队
func (q *Queue) deleteQueue() (int, error) {
	//判断循环队列否为空
	if q.Rear-q.Frount == -1 {
		return -1, errors.New("队列为空")
	}

	v := q.QueueArray[q.Frount%q.MaxSize] //获取队列头部元素值;front与MaxSize去模，获取实际数组下标
	q.QueueArray[q.Frount%q.MaxSize] = 0  //出队数据置为0
	q.Frount += 1                         //队头下标+1

	return v, nil
}

 

如果用非循环队列，数组容量为6，rear为5时就无法再入队元素了。使用了循环队列，只要数组中还有空间，就可以一直循环入队元素。上述例子中rear最终达到了10，也就是一共有11个元素成功入队，充分利用了空间。

 

3.队列的链式存储结构

队列也可以使用一个单链表实现。插入和删除操作分别在链表的两端进行。

链表的特点是：在链表的头部，做插入、删除操作都方便；在链表的尾部，做插入操作方便，做删除操作不方便。

  • 在链表头部进行出队操作
  • 在链表尾部进行入队操作
  • 需要front和rear分别指向链的头节点的和尾节点。当front不指向任何节点时，队列为空。

3.1 队列的链式存储结构-结构体定义

//队列-链式存储结构-结构体
type LinkQueue struct {
	Frount *QueueNode
	Rear   *QueueNode
}

//队列-链式存储结构-每个结点结构体
type QueueNode struct {
	data int
	next *QueueNode
}

3.2 队列的链式存储结构-队列初始化

func initQueue() (queue *LinkQueue) {
	//初始化队列
	queue = &LinkQueue{
		Frount: nil,
		Rear:   nil,
	}
	return queue
}

3.3 队列的链式存储结构-入队

func (lq *LinkQueue) addQueue(v int) {
	//链式存储结构，暂不考虑队列是否已满

	//新建入队节点
	newNode := &QueueNode{
		data: v,
		next: nil,
	}

	//如果Frount为空，表明为入队的第一个节点
	if lq.Frount == nil {
		lq.Frount = newNode
		lq.Rear = newNode
	}

	//原队尾指向新入队节点
	lq.Rear.next = newNode
	lq.Rear = newNode
}

3.4 队列的链式存储结构-出队

func (lq *LinkQueue) deleteQueue() (int, error) {
	//判断循环队列否为空
	if lq.Frount == nil {
		return -1, errors.New("队列为空")
	}

	v := lq.Frount.data        //获取队列头部元素值
	lq.Frount = lq.Frount.next //frount指向下一个结点

	return v, nil
}

3.5 完整代码 

package main

import (
	"errors"
	"fmt"
)

type LinkQueue struct {
	Frount *QueueNode
	Rear   *QueueNode
}

type QueueNode struct {
	data int
	next *QueueNode
}

func main() {
	//初始化队列
	queue := initQueue()

	//循环入队&出队
	fmt.Println("---入队---")
	for i := 100; i <= 105; i++ {
		queue.addQueue(i)
		fmt.Println("入队元素:", queue.Rear.data)
	}

	fmt.Println("---出队---")
	for queue.Frount != nil {
		v, err := queue.deleteQueue()
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println("出队元素:", v)
		}
	}
}

//队列初始化
func initQueue() (queue *LinkQueue) {
	//初始化队列
	queue = &LinkQueue{
		Frount: nil,
		Rear:   nil,
	}
	return queue
}

//队列-入队
func (lq *LinkQueue) addQueue(v int) {
	//链式存储结构，暂不考虑队列是否已满

	//新建入队节点
	newNode := &QueueNode{
		data: v,
		next: nil,
	}

	//如果Frount为空，表明为入队的第一个节点
	if lq.Frount == nil {
		lq.Frount = newNode
		lq.Rear = newNode
	}

	//原队尾指向新入队节点
	lq.Rear.next = newNode
	lq.Rear = newNode
}

//队列-出队
func (lq *LinkQueue) deleteQueue() (int, error) {
	//判断循环队列否为空
	if lq.Frount == nil {
		return -1, errors.New("队列为空")
	}

	v := lq.Frount.data        //获取队列头部元素值
	lq.Frount = lq.Frount.next //frount指向下一个节点

	return v, nil
}

 

一边学习一边哭
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础篇——Go语言队列实现
magic的博客
07-22 9686
理论介绍 队列(queue)， 是一种先进先出的线性表。通常用数据或者链表来实现队列。 队列只允许在后端插入，前端删除操作。 性质： 先进先出 代码实现 了解了队列的概念，实现一个队列也相当简单，下面看代码 package queue type Item interface { } // Item the type of the queue type ItemQueue...
Go-GoQ在Golang中的轻量级消息队列
08-14
GoQ 在Golang中的轻量级消息队列
探索高效Go语言队列库——go-queue
最新发布
gitblog_00088的博客
04-15 454
探索高效Go语言队列库——go-queue 项目地址:https://gitcode.com/zeromicro/go-queue 在构建高并发、实时性要求较高的系统时，消息队列往往是必不可少的一部分。它可以帮助我们解耦组件，平滑处理流量峰值，并提供可靠的消息传输。而今天我们要介绍的项目，就是一款由ZeroMQ启发并用Go语言实现的轻量级消息队列库——go-queue。 项目简介 go-queue...
Go语言 大话数据结构——循环队列
weixin_42117918的博客
08-20 2382
画图： 小汽车是线性排列，而且只能从一端进，另一端出，这就是"队列"，队列也是一种线性表，只不过它是操作受限的线性表，只能在两端操作，先进先出（First In First Out，FIFO）。 进的一端称为队尾（rear），出的一端称为队头（front）。队列可以用顺序存储，也可以用链式存储。 1. 顺序队列 队列的顺序存储形式，可以用一个一维数组存储数据元素，用两个整型变量记录队头...
数据结构之Go实现队列
qq_46457076的博客
03-29 938
关于使用Go语言实现数据结构之队列的基本操作！
GO语言数据结构之队列
zlyGOGOGO的博客
08-16 738
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 顺序队列 在顺序队列中，为了降低运算的复杂度，元素入队时，只修改队尾指针；元素出对时，只修改队头指针。由于顺序队列的存储空间是提前设定的，因此队尾指针会有一个上限值，当队尾指针达到其上限时，就不能只通过修改队尾指针来实现新元素的入队操作了。 代码实现 //定义队列结构 type queue struct {
go-queue:Golang的优先级和延迟队列
03-04
排队 Golang的优先级和延迟队列
Go语言数据结构-队列
jeremy_ke的博客
10-25 670
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列本身是有序列表，数组或链表实现，若使用数组的结构来存储队列的数据，则队列数组的声明如上图, 其中 maxSize 是该队列的最大容量。队列增加数据时候 rear增加；队列消费数据时候 front改变。
go实现队列
空山新雨后，天气晚来秋
03-02 1175
上代码 package main import ( "fmt" "os" ) type Queue struct { List []int } // 创建一个新队列 func newQueue(len int) *Queue { // 这里加了个判断，创建时可以传入队列长度，满了就不能添加。你也可以不用传参，直接list := make([]int, 0)，然后不用判断满没满即可......
go-zero 消息队列使用
lisus2007的专栏
09-14 533
Brokers: kafka 的多个 Broker 节点Group：消费者组Topic：订阅的 Topic 主题Offset：如果新的 topic kafka 没有对应的 offset 信息,或者当前的 offset 无效了(历史数据被删除),那么需要指定从头(first)消费还是从尾(last)部消费Conns: 一个 kafka queue 对应可对应多个 consumer，Conns 对应 kafka queue 数量，可以同时初始化多个 kafka queue，默认只启动一个。
分布式任务 + 消息队列框架 go-queue
我心飞翔
03-22 2635
为什么写这个库 应用场景有哪些 如何使用 总结 为什么要写这个库？ 在开始自研 go-queue 之前，针对以下我们调研目前的开源队列方案： beanstalkd beanstalkd 有一些特殊好用功能：支持任务priority、延时(delay)、超时重发(time-to-run)和预留(buried)，能够很好的支持分布式的后台任务和定时任务处理。如下是 beanstalkd 基本部分： job：任务单元； tube：任务队列，存储统一类型 job。producer 和 consumer 操..
用go实现常见的数据结构.md
11-02
golang常见数据结构实现 链表，可变数组，栈和队列，字典Map和集合Set
go语言通过数组和链表的方式实现队列 数组和链表.pdf
04-18
go语言通过数组和链表的方式实现队列 数组和链表.pdf
学习数据结构与算法的代码示例，目前提供 Java、Python、Go、C++ 多种语言支持。.zip
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
数据结构与算法源码.zip
06-26
多种语言包括java、python、c语言、go语言、php等来实现的数据结构的源码，包含数组、 链表、栈、队列、递归、排序、二分查找、散列表、二叉树、堆、图、回溯、分治、动态规划的实现方法。非常适合学习数据结构的小...
Learning-Go-Data-Structures-and-Algorithms:Packt出版的《学习Go数据结构和算法》
05-28
继续学习，您将学习Go中链表和双链表的功能，然后学习实现线性数据结构，例如堆栈和队列。 另外，实现二进制搜索和树，并将详细探讨排序算法。 从这里，您将了解图算法，还将向您介绍在处理字符串时使用的一些常见...
Go数据结构与算法—队列
qq_31639829的博客
10-16 495
介绍 队列（queue），是一种特殊的线性表。队列只允许在一端插入数据，另一端取出数据，并且队列中的数据遵循先进先出（First In First Our, FIFO）的规则。其中取出数据的一端称为队头，插入数据的一端称为队尾。 队列可以分为：顺序队列、循环队列、链式队列。 顺序队列 type Queue struct { MaxSize int Front int Rear int Element []int } // 初始化队列 func (q *Queue) initQueue(m
数据结构与算法基础-Go语言版-3.队列
qq_41736299的博客
11-22 347
本文将展示如何使用go语言实现队列的结构以及队列的基本方法：如入队，出队等
数据结构【Golang实现】(六)——队列
脑袋装水的博客
03-16 2362
《Go语言》实现顺序队列、链式队列、循环队列
go语言实现数据结构
10-20
在Go语言中，数据结构的实现非常灵活，可以使用内置的数据结构，也可以手动实现自己的数据结构。常见的数据结构包括数组、链表、栈、队列、树、图等。在实现数据结构时，可以使用Go语言提供的接口，也可以手动实现。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值