我的Go+语言初体验——GO+实现数据结构之【队列与循环列表】(3)

【我的Go+语言初体验” | 征文活动进行中…】

以写促学,接下来,我将带大家使用 GO+ 逐步 实现常见的数据结构

欢迎关注【我的Go+语言初体验——实现数据结构】系列,持续更新中…


往期文章

我的Go+语言初体验——实现数据结构之【数组 切片 Map】(1)

我的Go+语言初体验——实现数据结构之【栈与其应用】(2)





什么是队列

关于什么是栈, 我们可以先看百度百科给的解释

队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表. 进行插入操作的端称为队尾,进行删除操作的端称为队头

你如果不能理解,暂时可以把它理解为一个拥有排队秩序的, 像是一根水管

在这里插入图片描述

队列讲究的是先进先出,比如你在食堂打饭,肯定是队头的人先打饭.

  • 那么进行插入操作的入口,我们称之为队尾

  • 进行删除操作的出口我们称之为队首




Go+定义队列

实现结构

现在我们来实现出队列数据结构

  • 要设计队列, 我们需要需要有一个变量判断队列的容量大小.

  • 我们要有变量来限制队列的最大容量

  • 一个指向队列的头 front 的变量

  • 一个指向队列的尾 rear的变量

// 定义队列的结构体
type Queue struct {
  // 用来装元素的切片
  queueSet []string
  // 队首标记位
  front int
  // 队尾标记位
  rear int
  // 队列的容量
  queueSize int
}

// 初始化时,要传入容量限制
func NewQueue(QueueMaxSize int) *Queue {
  return &Queue{
    queueSet: make([]string, QueueMaxSize ),
    // 在队列中已经装了多少元素我们可以用queueSize表示
    front:     0,
    rear:      0,
    queueSize: 0,
  }
}

请注意这里的, queueSize 是用来判断的,即可用容量, queueSet: make([]string, QueueMaxSize) 里的 QueueMaxSize 是整个队列的最大容量


队列的基本操作

思想

队列的基本操作包括如下几种

  • 判断队列是否为空: 若队列为空则返回 true,否则返回 false

  • 判断队列是否已满: 若队列为满则返回 true,否则返回 false

  • 入队操作: 在队列的队尾插入元素

  • 出队操作: 将队头元素出队,并返回出元素值

判断队列是否为空

// 判断队列是否为空
func (q *Queue) IsEmpty() bool {
  // 判断容量大小
  if q.queueSize == 0 {
    return true
  }
  return false
}

判断队列是否已满

// 判断队列是否已满
func (q *Queue) IsFull() bool {
  if q.queueSize == len(q.queueSet) {
    return true
  }
  return false
}

入队

// 队尾入队
func (q *Queue) Push(element string) bool {
  // 判断队列是否已满
  if q.IsFull() {
    return false
  }
  // 入队
  q.queueSet[q.rear] = element

  // 队尾地址和容量+1
  q.rear++
  q.queueSize++

  return true
}

出队

// 队首出队
func (q *Queue) Pop() (bool, string) {
  // 判断队列是否为空
  if q.IsEmpty() {
    return false, "null"
  }
  // 获取队首位置数据
  ret := q.queueSet[q.front]

  // 队首+1,容量-1
  q.front++
  q.queueSize--

  return true, ret
}

完整案例

package main

// 定义队列的结构体
type Queue struct {
  // 用来装元素的切片
  queueSet []string
  // 队首标记位
  front int
  // 队尾标记位
  rear int
  // 队列的容量
  queueSize int
}

// 初始化时,要传入容量限制
func NewQueue(QueueMaxSize int) *Queue {
  return &Queue{
    queueSet: make([]string, QueueMaxSize ),
    // 在队列中已经装了多少元素我们可以用queueSize表示
    front:     0,
    rear:      0,
    queueSize: 0,
  }
}

// 判断队列是否为空
func (q *Queue) IsEmpty() bool {
  // 判断容量大小
  if q.queueSize == 0 {
    return true
  }
  return false
}

// 判断队列是否已满
func (q *Queue) IsFull() bool {
  if q.queueSize == len(q.queueSet) {
    return true
  }
  return false
}

// 队尾入队
func (q *Queue) Push(element string) bool {
  // 判断队列是否已满
  if q.IsFull() {
    return false
  }
  // 入队
  q.queueSet[q.rear] = element

  // 队尾地址和容量+1
  q.rear++
  q.queueSize++

  return true
}

// 队首出队
func (q *Queue) Pop() (bool, string) {
  // 判断队列是否为空
  if q.IsEmpty() {
    return false, "null"
  }
  // 获取队首位置数据
  ret := q.queueSet[q.front]

  // 队首+1,容量-1
  q.front++
  q.queueSize--

  return true, ret
}

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

  // 入队
  queue.Push("您好,我是uiu")
  queue.Push("我的网站是:uiuing.com")

  // 出队
  println queue.Pop()
  println queue.Pop()

  // 检查队列空的情况下能否继续删除
  println queue.Pop()
}

运行结果

在这里插入图片描述




思考

经测试,队列已经可正常的运行了,但我们在每次让元素出队的时候,队列的头指针是不断的在往后移。当队头指向的索引值比我们的容器长度还要大,那种情况出现的时候要怎么办呢?

不只是这种情况,看如下的情况

  // 初始化队列
  queue := NewQueue(2)

  println "-------空队列-------"
  println "front: ", queue.front
  println "rear: ", queue.rear
  println "queueSize: ", queue.queueSize

  println "-------入队+出队一次-------"
  queue.Push("您好,我是uiu")
  queue.Pop()
  println "front: ", queue.front
  println "rear: ", queue.rear
  println "queueSize: ", queue.queueSize

  println "-------入队+出队一次-------"
  queue.Push("我的网站是:uiuing.com")
  queue.Pop()
  println "front: ", queue.front
  println "rear: ", queue.rear
  println "queueSize: ", queue.queueSize

  println "-------这将会引起错误-------"
  queue.Push("我的网站是:uiuing.com")

在这里插入图片描述

为什么会出现这个错误信息呢?

你仔细看能看出, 在初始化容量为2的情况下, 执行两次入队+出队操作之后,容量确实为0,但是却存储不进, 发生了越界的情况, 这是因为在rear为2的情况下, 在队列中再无法添加, 这就导致了资源的浪费.

那既然在使用过程中,front 和 rear 都只能往后移导致有用的空间被浪费了,那么我们可以去做一个可以再利用,不浪费一点空间的队列呢?

也就是我们可以做一个循环队列

循环队列,顾名思义,它长得像一个环, 原本数组是有头有尾的,是一条直线, 现在我们把首尾相连.

在这里插入图片描述

像不像一根圆形的水管, 在设定的最大容量之类,空间可循环利用




实现循环队列

思想

我们假设循环队列里目前 **front **在索引 2, rear 在索引 6,那么新的元素入队时,新元素将被加入到索引 0 的位置。

在这里插入图片描述

这在上面的队列中是会出现错误的,因为并不循环,一旦但当queueSize=6的时候,是会出现数组越界情况的

我们得存储到0里去, 通过这样的方法,实现循环队列,我们成功避免了数据搬移操作, 看起来不难理解,我们接下来要弄清楚两件事情

  • 判断队列是否为空是否为满,

  • 让两个指针可以在堆里中循环起来.


判断队列状态

思想

我们之所以要用 queueSize 表示队列的实际长度,而不是rear - front就是为了循环队列

在循环时,rear 和 front 是不能比较的,我们独立出来一个queueSize 就不会出现这种问题,因为只有入队操作才会让 queueSize + 1, 也只有出队操作能让 queueSize - 1, 所以这里我们的判断队列状态的函数可以直接不变就拿来使用.

判断是否为空

// 检查循环队列是否为空
func (this *Queue) IsEmpty() bool {
  if this.queueSize == 0 {
    return true
  }
  return false
}

判断是否已满

// 检查循环队列是否已满
func (this *Queue) IsFull() bool {
  if this.queueSize == len(this.queueSet ) {
    return true
  }
  return false
}

计算索引

思想

解决了判断状态问题,我们可以继续解决索引值的计算问题了.

入队操作

  • 在入队时. 我们只要对 rear 先对队列的容量取余计算出的索引值就是我们要插入的位置.

出队操作

  • 要出队的元素是 front 对队列容量取余所指向的元素,取出之后下一个 front 的值需要先对队列的容量取余再加 1

入队

// 入队操作
func (this *Queue) Push(value string) bool {

  // 排除结构体为空 或者 队列为满的情况
  if this.queueSet  == nil || this.IsFull() {
    return false
  }

  //  对 rear 先对队列的容量取余
  this.queueSet[this.rear%len(this.queueSet )] = value

  // rear位置取余量后 + 1
  this.rear = this.rear%len(this.queueSet ) + 1
  // queueSize大小 + 1
  this.queueSize++

  return true
}

出队

// 出队操作
func (this *Queue) Pop() (bool, string) {
  
  // 排除结构体为空 或者 队列为空的情况
  if this.queueSet  == nil || this.IsEmpty() {
    return false, "null"
  }

  // 求出 front 对队列容量取余所指向的元素
  ret := this.queueSet[this.front%len(this.queueSet )]

  // 对 front 重新定位
  this.front = this.front%len(this.queueSet ) + 1
  // queunSize大小 - 1
  this.queueSize--

  return true, ret
}

完整案例

// 定义队列的结构体
type Queue struct {
  // 用来装元素的切片
  queueSet []string
  // 队首标记位
  front int
  // 队尾标记位
  rear int
  // 队列的容量
  queueSize int
}

// 初始化时,要传入容量限制
func NewQueue(QueueMaxSize int) *Queue {
  return &Queue{
    queueSet: make([]string, QueueMaxSize ),
    // 在队列中已经装了多少元素我们可以用queueSize表示
    front:     0,
    rear:      0,
    queueSize: 0,
  }
}

// 检查循环队列是否为空
func (this *Queue) IsEmpty() bool {
  if this.queueSize == 0 {
    return true
  }
  return false
}

// 检查循环队列是否已满
func (this *Queue) IsFull() bool {
  if this.queueSize == len(this.queueSet) {
    return true
  }
  return false
}

// 入队操作
func (this *Queue) Push(value string) bool {

  // 排除结构体为空 或者 队列已满的情况
  if this.queueSet == nil || this.IsFull() {
    return false
  }

  //  对 rear 先对队列的容量取余
  this.queueSet[this.rear%len(this.queueSet)] = value

  // rear位置取余量后 + 1
  this.rear = this.rear%len(this.queueSet) + 1
  // queueSize大小 + 1
  this.queueSize++

  return true
}

// 出队操作
func (this *Queue) Pop() (bool, string) {

  // 排除结构体为空 或者 队列为空的情况
  if this.queueSet == nil || this.IsEmpty() {
    return false, "null"
  }

  // 求出 front 对队列容量取余所指向的元素
  ret := this.queueSet[this.front%len(this.queueSet)]

  // 对 front 重新定位
  this.front = this.front%len(this.queueSet) + 1
  // queunSize大小 - 1
  this.queueSize--

  return true, ret
}

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

  println "-------空队列-------"
  println "front: ", queue.front
  println "rear: ", queue.rear
  println "queueSize: ", queue.queueSize

  println "-------入队+出队一次-------"
  queue.Push("您好,我是uiu")
  queue.Pop()
  println "front: ", queue.front
  println "rear: ", queue.rear
  println "queueSize: ", queue.queueSize

  println "-------入队+出队一次-------"
  queue.Push("我的网站是:uiuing.com")
  queue.Pop()
  println "front: ", queue.front
  println "rear: ", queue.rear
  println "queueSize: ", queue.queueSize

  println "-------在循环队列中并不会产生这样的错误-------"
  queue.Pop()

}

在这里插入图片描述

  • 5
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我想养只猫 •͓͡•ʔ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值