数据结构之Go实现队列

已于 2023-04-19 13:12:51 修改
阅读量924 收藏
点赞数
分类专栏： 数据结构与算法系列 文章标签： 数据结构 golang 链表 算法
于 2023-03-29 00:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46457076/article/details/129826807
版权

文章目录

队列的基础知识

队列的基本概念

（1）队列的定义

队列简称队，是一种操作受限的线性表，其限制为仅允许在表的一端进行插入，在表的另一端进行删除。可进行插入的一端称为队尾（ Rear ），可进行删除的一端称为队头（ Front ）。

向队列中插入新的元素称为进队，新元素进队后就成为新的队尾元素；从队列中删除元素称为出队，元素出队后，其后继元素就成为新的队头元素。

（2）队列的特征

队列的特点是先进先出（ FIFO ）。

（3） 队列的存储结构

队列按存储结构可分为顺序队和链队两种，可用顺序表和链表来存储队列。

队列的结构体定义

（1）顺序队列

// Array
type SeqQueue struct {
		Data [MaxSize]interface{}
		Length int
}

type SeqQueue struct{
		Data []interface{}
		Front int
		Rear int
}

// Slice
type SliceQueue struct {
		Data []interface{}
		Length int
}

（2）链表队列

type LinkedQueueNode struct {
		Value interface{}
		Next *LinkedQueueNode
}

type LinkedQueueNode struct {
		Front *LinkedQueueNode
		Rear *LinkedQueueNode
}

队列的实现

数组队列

（1）数组队列的基本操作如下代码所示。

type Operate interface {
		// 初始化队列
        InitSeqQueue()
        // 判断队列是否为空
        IsEmpty() bool
        // 获取队列的长度
        Len() int
        // 输出队列
        DisplayQueue()
        // 获取对首元素
        GetFrontElem() interface{}
        // 获取对尾元素
        GetRearElem() interface{}
        // 元素进队
        EnterQueue(v interface{})
        // 元素出队
        RemoveQueue() interface{}
}

（2）在任意目录下创建一个项目，在该项目下创建一个名为 seqqueue.go 的程序编写实现以上的功能，该程序的具体代码如下所示。

package SeqQueue

import (
        "errors"
        "fmt"
)

const MaxSize = 20

type SeqQueue struct {
        Data   [MaxSize]interface{}
        Length int
}

func NewSeqQueue() *SeqQueue {
        return new(SeqQueue)
}

type Operate interface {
        InitSeqQueue()
        IsEmpty() bool
        Len() int
        DisplayQueue()
        GetFrontElem() interface{}
        GetRearElem() interface{}
        EnterQueue(v interface{})
        RemoveQueue() interface{}
}

func (q *SeqQueue) InitSeqQueue() {
        q.Length = 0
}

func (q *SeqQueue) IsEmpty() bool {
        return q.Length == 0
}

func (q *SeqQueue) Len() int {
        return q.Length
}

func (q *SeqQueue) DisplayQueue() {
        if q.IsEmpty() {
                fmt.Println("The SeqQueue is empty!")
        } else {
                fmt.Printf("队列中的元素为: ")
                for i := 0; i < q.Length; i++ {
                        fmt.Printf("%d ", q.Data[i])
                }
                fmt.Println()
        }
}

func (q *SeqQueue) GetFrontElem() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SeqQueue is empty!\n"))
        }
        return q.Data[0]
}

func (q *SeqQueue) GetRearElem() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SeqQueue is empty!\n"))
        }
        return q.Data[q.Length-1]
}

func (q *SeqQueue) EnterQueue(v interface{}) {
        if q.Length > MaxSize {
                panic(errors.New("The SeqQueue is full!\n"))
        } else {
                q.Data[q.Length] = v
                q.Length++
                fmt.Printf("Elem %d is entered into the SeqQueue!\n", v)
        }
}

func (q *SeqQueue) RemoveQueue() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SeqQueue is empty!\n"))
        } else {
                v := q.Data[0]
                for i := 1; i < q.Length; i++ {
                        q.Data[i-1] = q.Data[i]
                }
                q.Length--
                fmt.Printf("Elem %d is removed from the SeqQueue!\n", v)
                return v
        }
}

（3）在该项目的目录下创建一个名为 seqqueue_test.go 的程序测试以上的功能逻辑是否正确，该程序的具体代码如下所示。

package SeqQueue

import (
        "fmt"
        "testing"
)

func TestNewSeqQueue(t *testing.T) {
        var q Operate
        q = NewSeqQueue()
        q.InitSeqQueue()
        q.DislpayQueue()
        q.EnterQueue(12)
        q.EnterQueue(24)
        q.EnterQueue(33)
        q.DisplayQueue()
        fmt.Printf("THe SeqQueue front elem is %d\n", q.GetFrontElem())
        fmt.Printf("The SeqQueue rear elem is %d\n", q.GetRearElem())
        fmt.Printf("The SeqQueue's length is %d\n", q.Len())
        q.EnterQueue(22)
        q.RemoveQueue()
        q.EnterQueue(55)
        q.DisplayQueue()
}

（4）在项目的目录下执行 go test 命令进行测试验证，程序运行的结果如下所示。

The SeqQueue is empty!
Elem 12 is entered into the SeqQueue!
Elem 24 is entered into the SeqQueue!
Elem 33 is entered into the SeqQueue!
队列中的元素为: 12 24 33 
THe SeqQueue front elem is 12
The SeqQueue rear elem is 33
The SeqQueue's length is 3
Elem 22 is entered into the SeqQueue!
Elem 12 is removed from the SeqQueue!
Elem 55 is entered into the SeqQueue!
队列中的元素为: 24 33 22 55

切片队列

  • 不带头结点

（1）切片队列的基本操作如下代码所示。

type Operate interface {
		// 初始化队列
        InitSliceQueue()
        // 判断队列是否为空
        IsEmpty() bool
        // 获取队列的长度
        Len() int
        // 输出队列
        DisplayQueue()
        // 获取对首元素
        GetFrontElem() interface{}
        // 获取对尾元素
        GetRearElem() interface{}
        // 元素进队
        EnterQueue(v interface{})
        // 元素出队
        RemoveQueue() interface{}
}

（2）在任意目录下创建一个项目，在该项目下创建一个名为 slicequeue.go 的程序编写实现以上的功能，该程序的具体代码如下所示。

package SliceQueue

import (
        "errors"
        "fmt"
)

type SliceQueue struct {
        Data   []interface{}
        Length int
}

func NewSliceQueue() *SliceQueue {
        q := &SliceQueue{}
        q.Data = make([]interface{}, 0)
        q.Length = 0
        return q
}

type Operate interface {
        InitSliceQueue()
        IsEmpty() bool
        Len() int
        DisplayQueue()
        GetFrontElem() interface{}
        GetRearElem() interface{}
        EnterQueue(v interface{})
        RemoveQueue() interface{}
}

func (q *SliceQueue) InitSliceQueue() {
        q.Length = 0
}

func (q *SliceQueue) IsEmpty() bool {
        return q.Length == 0
}

func (q *SliceQueue) Len() int {
        return q.Length
}

func (q *SliceQueue) GetFrontElem() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SliceQueue is empty!\n"))
        } else {
                return q.Data[0]
        }
}

func (q *SliceQueue) GetRearElem() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SliceQueue is empty!\n"))
        } else {
                return q.Data[q.Length-1]
        }
}

func (q *SliceQueue) DisplayQueue() {
        if q.IsEmpty() {
                fmt.Println("The SliceQueue is empty!")
        } else {
                fmt.Printf("队列中的元素为: ")
                i := 0
                for i < q.Length {
                        fmt.Printf("%d ", q.Data[i])
                        i++
                }
                fmt.Println()
        }
}

func (q *SliceQueue) EnterQueue(v interface{}) {
        q.Data = append(q.Data, v)
        q.Length++
        fmt.Printf("Elem %d is entered into the SliceQueue!\n", v)
}

func (q *SliceQueue) RemoveQueue() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SliceQueue is empty!\n"))
        } else {
                v := q.Data[0]
                q.Data = q.Data[1:]
                q.Length--
                fmt.Printf("Elem %d is removed from the SliceQueue!\n", v)
                return v
        }
}

（3）在该项目的目录下创建一个名为 slicequeue_test.go 的程序测试以上的功能逻辑是否正确，该程序的具体代码如下所示。

package SliceQueue

import (
        "fmt"
        "testing"
)

func TestNewSliceQueue(t *testing.T) {
        var q Operate
        q = NewSliceQueue()
        q.InitSliceQueue()
        q.DisplayQueue()
        q.EnterQueue(4)
        q.EnterQueue(2)
        q.EnterQueue(6)
        q.DisplayQueue()
        fmt.Printf("The SliceQueue's length is %d\n", q.Len())
        q.EnterQueue(1)
        q.RemoveQueue()
        q.EnterQueue(7)
        q.DisplayQueue()
        fmt.Printf("The SliceQueue front elem is %d\n", q.GetFrontElem())
        fmt.Printf("The SliceQueue rear elem is %d\n", q.GetRearElem())

}

（4）在项目的目录下执行 go test 命令进行测试验证，程序运行的结果如下所示。

The SliceQueue is empty!
Elem 4 is entered into the SliceQueue!
Elem 2 is entered into the SliceQueue!
Elem 6 is entered into the SliceQueue!
队中的元素为: 4 2 6 
The SliceQueue's length is 3
Elem 1 is entered into the SliceQueue!
Elem 4 is removed from the SliceQueue!
Elem 7 is entered into the SliceQueue!
队中的元素为: 2 6 1 7 
The SliceQueue front elem is 2
The SliceQueue rear elem is 7
  • 带头结点

（1）切片队列的基本操作如下代码所示。

type Operate interface {
		// 初始化队列
        InitSliceQueue()
        // 判断队列是否为空
        IsEmpty() bool
        // 获取队列的长度
        Len() int
        // 输出队列
        DisplayQueue()
        // 获取对首元素
        GetFrontElem() interface{}
        // 获取对尾元素
        GetRearElem() interface{}
        // 元素进队
        EnterQueue(v interface{})
        // 元素出队
        RemoveQueue() (v interface{})
}

（2）在任意目录下创建一个项目，在该项目下创建一个名为 slicequeue.go 的程序编写实现以上的功能，该程序的具体代码如下所示。

package SliceQueue

import (
        "errors"
        "fmt"
)

type SliceQueue struct {
        Data  []interface{}
        Front int
        Rear  int
}

func NewSliceQueue() *SliceQueue {
        return &SliceQueue{Data: make([]interface{}, 0)}
}

type Operate interface {
        InitSliceQueue()
        IsEmpty() bool
        Len() int
        DisplayQueue()
        GetFrontElem() interface{}
        GetRearElem() interface{}
        EnterQueue(v interface{})
        RemoveQueue() (v interface{})
}

func (q *SliceQueue) InitSliceQueue() {
        q.Front = 0
        q.Rear = q.Front
}

func (q *SliceQueue) IsEmpty() bool {
        return q.Front == q.Rear
}

func (q *SliceQueue) Len() int {
        return q.Rear - q.Front
}

func (q *SliceQueue) GetFrontElem() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SliceQueue is empty!\n"))
        } else {
                return q.Data[q.Front]
        }
}

func (q *SliceQueue) GetRearElem() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The SliceQueue is empty!\n"))
        } else {
                return q.Data[q.Rear-1]
        }
}

func (q *SliceQueue) DisplayQueue() {
        if q.IsEmpty() {
                fmt.Println("The SliceQueue is empty!")
        } else {
                fmt.Printf("队中的元素为: ")
                i := 0
                for i < q.Len() {
                        fmt.Printf("%d ", q.Data[i])
                        i++
                }
                fmt.Println()
        }
}

func (q *SliceQueue) EnterQueue(v interface{}) {
        q.Data = append(q.Data, v)
        q.Rear++
        fmt.Printf("Elem %d is entered into the SliceQueue!\n", v)
}

func (q *SliceQueue) RemoveQueue() (v interface{}) {
        if q.IsEmpty() {
                panic(errors.New("The SliceQueue is empty!\n"))
        } else {
                v, q.Data = q.Data[0], q.Data[1:]
                q.Rear--
                fmt.Printf("Elem %d is removed from the SliceQueue!\n", v)
                return v
        }
}

（3）在该项目的目录下创建一个名为 slicequeue_test.go 的程序测试以上的功能逻辑是否正确，该程序的具体代码如下所示。

package SliceQueue

import (
        "fmt"
        "testing"
)

func TestNewSliceQueue(t *testing.T) {
        var q Operate
        q = NewSliceQueue()
        q.InitSliceQueue()
        q.DisplayQueue()
        q.EnterQueue(4)
        q.EnterQueue(2)
        q.EnterQueue(6)
        q.DisplayQueue()
        fmt.Printf("The SliceQueue's length is %d\n", q.Len())
        q.EnterQueue(1)
        q.RemoveQueue()
        q.EnterQueue(7)
        q.DisplayQueue()
        fmt.Printf("The SliceQueue front elem is %d\n", q.GetFrontElem())
        fmt.Printf("The SliceQueue rear elem is %d\n", q.GetRearElem())
}

（4）在项目的目录下执行 go test 命令进行测试验证，程序运行的结果如下所示。

The SliceQueue is empty!
Elem 4 is entered into the SliceQueue!
Elem 2 is entered into the SliceQueue!
Elem 6 is entered into the SliceQueue!
队中的元素为: 4 2 6 
The SliceQueue's length is 3
Elem 1 is entered into the SliceQueue!
Elem 4 is removed from the SliceQueue!
Elem 7 is entered into the SliceQueue!
队中的元素为: 2 6 1 7 
The SliceQueue front elem is 2
The SliceQueue rear elem is 7

循环队列

（1）循环队列的基本操作如下代码所示。

type Operate interface {
		// 初始化循环队列
        InitSeqQueue()
        // 判断循环队列是否为空
        IsEmpty() bool
        // 判断循环队列是否满
        IsFull() bool
        // 获取循环队列的长度
        Len() int
        // 输出循环队列
        DisplayQueue()
        // 获取对首元素
        GetFrontElem() interface{}
        // 获取对尾元素
        GetRearElem() interface{}
        // 元素进队
        EnterQueue(v interface{})
        // 元素出队
        RemoveQueue() interface{}
}

（2）在任意目录下创建一个项目，在该项目下创建一个名为 ringqueue.go 的程序编写实现以上的功能，该程序的具体代码如下所示。

package RingQueue

import (
        "errors"
        "fmt"
)

const MaxSize = 50

type RingQueue struct {
        Data  [MaxSize]interface{}
        Front int
        Rear  int
}

func NewRingQueue() *RingQueue {
        return new(RingQueue)
}

type Operate interface {
        InitRingQueue()
        IsEmpty() bool
        IsFull() bool
        Len() int
        DisplayQueue()
        GetFrontElem() interface{}
        GetRearElem() interface{}
        EnterQueue(v interface{})
        RemoveQueue() interface{}
}

func (q *RingQueue) InitRingQueue() {
        q.Front = 0
        q.Rear = q.Front
}

func (q *RingQueue) IsEmpty() bool {
        return q.Front == q.Rear
}

func (q *RingQueue) IsFull() bool {
        return q.Front == (q.Rear+1)%MaxSize
}

func (q *RingQueue) GetFrontElem() interface{} {
        return q.Data[q.Front+1]
}

func (q *RingQueue) GetRearElem() interface{} {
        return q.Data[q.Rear]
}

func (q *RingQueue) Len() int {
        return q.Rear - q.Front
}

func (q *RingQueue) DisplayQueue() {
        if q.IsEmpty() {
                fmt.Println("The RingQueue is empty!")
        } else {
                fmt.Printf("循环队列的元素为: ")
                p := q.Front
                for p != q.Rear {
                        p = (p + 1) % MaxSize
                        fmt.Printf("%d ", q.Data[p])
                }
                fmt.Println()
        }
}

func (q *RingQueue) EnterQueue(v interface{}) {
        if q.IsFull() {
                panic(errors.New("The RingQueue is full!\n"))
        } else {
                q.Rear = (q.Rear + 1) % MaxSize
                q.Data[q.Rear] = v
                fmt.Printf("Elem %d is entered into the RingQueue!\n", v)
        }
}

func (q *RingQueue) RemoveQueue() interface{} {
        if q.IsEmpty() {
                panic(errors.New("The RingQueue is empty!\n"))
        } else {
                v := q.Data[q.Front+1]
                q.Front = (q.Front + 1) % MaxSize
                fmt.Printf("Elem %d is removed from the RingQueue!\n", v)
                return v
        }
}

（3）在该项目的目录下创建一个名为 ringqueue_test.go 的程序测试以上的功能逻辑是否正确，该程序的具体代码如下所示。

package RingQueue

import (
        "fmt"
        "testing"
)

func TestRingQueue(t *testing.T) {
        var q Operate
        q = NewRingQueue()
        q.InitRingQueue()
        q.DisplayQueue()
        q.EnterQueue(1)
        q.EnterQueue(3)
        q.EnterQueue(5)
        q.DisplayQueue()
        fmt.Printf("The RingQueue front elem is %d\n", q.GetFrontElem())
        fmt.Printf("The RingQueue rear elem is %d\n", q.GetRearElem())
        q.RemoveQueue()
        q.RemoveQueue()
        fmt.Printf("The RingQueue's length is %d\n", q.Len())
        q.DisplayQueue()
}

（4）在项目的目录下执行 go test 命令进行测试验证，程序运行的结果如下所示。

The RingQueue is empty!
Elem 1 is entered into the RingQueue!
Elem 3 is entered into the RingQueue!
Elem 5 is entered into the RingQueue!
循环队列的元素为: 1 3 5 
The RingQueue front elem is 1
The RingQueue rear elem is 5
Elem 1 is removed from the RingQueue!
Elem 3 is removed from the RingQueue!
The RingQueue's length is 1
循环队列的元素为: 5

链表队列

（1）链表队列的基本操作如下代码所示。

type Operate interface {
		// 初始化链表队列
        InitLinkedQueue()
        // 判断链表队列是否为空
        IsEmpty() bool
        // 获取链表队列的长度
        Len() int
        // 输出链表队列
        DisplayQueue()
        // 获取对首元素
        GetFrontElem() interface{}
        // 获取对尾元素
        GetRearElem() interface{}
        // 元素进队
        EnterQueue(v interface{})
        // 元素出队
        RemoveQueue() interface{}
}

（2）在任意目录下创建一个项目，在该项目下创建一个名为 linkedqueue.go 的程序编写实现以上的功能，该程序的具体代码如下所示。

package LinkedQueue

import (
        "errors"
        "fmt"
)

type LinkedQueueNode struct {
        Value interface{}
        Next  *LinkedQueueNode
}

type LinkedQueue struct {
        Front *LinkedQueueNode
        Rear  *LinkedQueueNode
}

func NewLinkedQueueNode() *LinkedQueueNode {
        return new(LinkedQueueNode)
}

func NewLinkedQueue() *LinkedQueue {
        return new(LinkedQueue)
}

type Operate interface {
        InitLinkedQueue()
        IsEmpty() bool
        Len() int
        DisplayQueue()
        GetFrontElem() interface{}
        GetRearElem() interface{}
        EnterQueue(v interface{})
        RemoveQueue() interface{}
}

func (q *LinkedQueue) InitLinkedQueue() {
        q.Front = nil
        q.Rear = q.Front
}

func (q *LinkedQueue) IsEmpty() bool {
        return q.Rear == nil
}

func (q *LinkedQueue) Len() (i int) {
        i = 0
        head := q.Front
        for head != q.Rear {
                i++
                head = head.Next
        }
        return i + 1
}

func (q *LinkedQueue) DisplayQueue() {
        head := q.Front
        if head == nil {
                fmt.Printf("The LinkedQueue is empty!\n")
        } else {
                fmt.Printf("链表队列中的元素为: ")
                for i := 0; head != q.Rear; i++ {
                        fmt.Printf("%d ", head.Value)
                        head = head.Next
                }
                fmt.Printf("%d\n", q.Rear.Value)
        }
}

func (q *LinkedQueue) GetFrontElem() interface{} {
        if q.Front == nil {
                panic(errors.New("The LinkedQueue is empty!\n"))
        } else {
                return q.Front.Value
        }
}

func (q *LinkedQueue) GetRearElem() interface{} {
        if q.Front == nil || q.Rear == nil {
                panic(errors.New("The LinkedQueue is empty!\n"))
        } else {
                return q.Rear.Value
        }
}

func (q *LinkedQueue) EnterQueue(v interface{}) {
        s := NewLinkedQueueNode()
        s.Value = v
        if q.Front == nil {
                q.Front = s
                q.Rear = s
        } else {
                q.Rear.Next = s
                q.Rear = s
        }
        fmt.Printf("Elem %d is entered into the LinkedQueue!\n", v)

}

func (q *LinkedQueue) RemoveQueue() interface{} {
        if q.Front == nil {
                panic(errors.New("The LinkedQueue is empty!\n"))
        } else {
                v := q.Front.Value
                q.Front = q.Front.Next
                if q.Front == nil {
                        q.Rear = nil
                }
                fmt.Printf("Elem %d is removed from the LinkedQueue!\n", v)
                return v
        }
}

（3）在该项目的目录下创建一个名为 linkedqueue_test.go 的程序测试以上的功能逻辑是否正确，该程序的具体代码如下所示。

package LinkedQueue

import (
        "fmt"
        "testing"
)

func TestNewLinkedQueue(t *testing.T) {
        var q Operate
        q = NewLinkedQueue()
        q.InitLinkedQueue()
        q.DisplayQueue()
        q.EnterQueue(1)
        q.EnterQueue(3)
        q.EnterQueue(5)
        q.DisplayQueue()
        f := q.GetFrontElem()
        fmt.Printf("The LinkedQueue front elem is %d\n", f)
        r := q.GetRearElem()
        fmt.Printf("The LinkedQueue rear elem is %d\n", r)
        q.EnterQueue(4)
        q.EnterQueue(7)
        q.DisplayQueue()
        fmt.Printf("The LinkedQueue rear elem is %d\n", q.GetRearElem())
        q.RemoveQueue()
        fmt.Printf("The LinkedQueue' length is %d\n", q.Len())
        q.DisplayQueue()
}

（4）在项目的目录下执行 go test 命令进行测试验证，程序运行的结果如下所示。

The LinkedQueue is empty!
Elem 1 is entered into the LinkedQueue!
Elem 3 is entered into the LinkedQueue!
Elem 5 is entered into the LinkedQueue!
链表队列中的元素为: 1 3 5
The LinkedQueue front elem is 1
The LinkedQueue rear elem is 5
Elem 4 is entered into the LinkedQueue!
Elem 7 is entered into the LinkedQueue!
链表队列中的元素为: 1 3 5 4 7
The LinkedQueue rear elem is 7
Elem 1 is removed from the LinkedQueue!
The LinkedQueue' length is 4
链表队列中的元素为: 3 5 4 7

  • 参考书籍：《数据结构教程 第6版》（李春葆 主编）

  • 参考书籍：《数据结构 C语言版》（严蔚敏、李冬梅、吴伟民著）

물の韜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go-GoQ在Golang中的轻量级消息队列
08-14
GoQ 在Golang中的轻量级消息队列
数据结构与算法基础-Go语言版-3.队列
qq_41736299的博客
11-22 347
本文将展示如何使用go语言实现队列的结构以及队列的基本方法：如入队，出队等
Go数据结构与算法—队列
qq_31639829的博客
10-16 494
介绍 队列（queue），是一种特殊的线性表。队列只允许在一端插入数据，另一端取出数据，并且队列中的数据遵循先进先出（First In First Our, FIFO）的规则。其中取出数据的一端称为队头，插入数据的一端称为队尾。 队列可以分为：顺序队列、循环队列、链式队列。 顺序队列 type Queue struct { MaxSize int Front int Rear int Element []int } // 初始化队列 func (q *Queue) initQueue(m
Go 容器之队列的几种实现方式
宇宙之一粟的技术漂泊之旅
10-30 88
1 队列的概念队列是有序集合，遵循 FIFO (First in first out，即先进先出)排队方法的容器。添加操作发生在队列的尾部，移除操作则发生在头部。新元素从尾部进入队列，然后一直向前移动到头部，直到下一个被移除的元素。在日常生活中，我们经常需要排队，这就是队列数据结构的生活例子。排队的概念可以通过在快递驿站取...
基础篇——Go语言队列实现
magic的博客
07-22 9682
理论介绍 队列(queue)， 是一种先进先出的线性表。通常用数据或者链表来实现队列。 队列只允许在后端插入，前端删除操作。 性质： 先进先出 代码实现 了解了队列的概念，实现一个队列也相当简单，下面看代码 package queue type Item interface { } // Item the type of the queue type ItemQueue...
用go实现队列
m15082717021的博客
01-09 2097
队列的定义 队列，和栈一样，也是一种对数据的"存"和"取"有严格要求的线性存储结构，与栈结构不同的是，队列的两端都"开口"，要求数据只能从一端进，从另一端出。队列有两种存储方式，分别是顺序队和链队，今天实现的是链队。 结构的定义 队列需要两个指针定位对头和队尾的位置，所以定义方式如下所示。 // 代表每一个节点 type node struct { data interface{} next *node } type queue struct { // 头节点 head *node // 队尾
GO语言-数据结构-队列
qq522044637的博客
08-05 2297
GO语言-数据结构-队列（顺序存储结构和链式存储结构）
Go语言数据结构-队列
jeremy_ke的博客
10-25 669
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列本身是有序列表，数组或链表实现，若使用数组的结构来存储队列的数据，则队列数组的声明如上图, 其中 maxSize 是该队列的最大容量。队列增加数据时候 rear增加；队列消费数据时候 front改变。
go实现队列
空山新雨后，天气晚来秋
03-02 1167
上代码 package main import ( "fmt" "os" ) type Queue struct { List []int } // 创建一个新队列 func newQueue(len int) *Queue { // 这里加了个判断，创建时可以传入队列长度，满了就不能添加。你也可以不用传参，直接list := make([]int, 0)，然后不用判断满没满即可......
数据结构【Golang实现】(六)——队列
脑袋装水的博客
03-16 2334
《Go语言》实现顺序队列、链式队列、循环队列
Go数据结构----队列操作
zhangzhongyanting的博客
05-12 210
队列先进先出，和栈操作顺序相反，我们这里只实现入队，和出队操作，其他操作和栈一样。​ 队列先进先出，和栈操作顺序相反，无非和上述实现方式不一样罢了。
Go-基于golang和redis实现的简单易用的队列
08-14
基于golang和redis实现的简单易用的队列
Golang中数据结构Queue的实现方法详解
12-26
本文主要给大家介绍了关于Golang中数据结构Queue实现的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 需求 队列的特性较为单一，基本操作即初始化、获取大小、添加元素、移除元素等...
用go实现常见的数据结构.md
11-02
golang常见数据结构实现 链表，可变数组，栈和队列，字典Map和集合Set
go-data-structure：Golang实现数据结构
02-18
Golang实现数据结构待办事项清单 双链表 跳过清单 基数树 特里 红黑树 RLU缓存 哈希图 位设置 循环队列 优先队列 排序：合并， 排序：快速 排序：插入 排序：堆 排序：侏儒 排序：鸡尾酒 排序：计数 搜索：二进制 堆...
Go数据结构-集合、列表、堆栈、地图、树、队列等等
最新发布
02-22
Go中各种数据结构和算法的实现。
Go 实现常用数据结构与算法.zip
12-27
常见的数据结构有数组、链表、栈、队列、树、图等。 算法则是解决特定问题的步骤，是对数据运算和操作的详细描述。算法的设计和选择会直接影响到程序的效率，因此，在设计和选择算法时，需要考虑到时间复杂度、空间...
go 数据结构之 队列
小小城的博客
06-23 427
下面先介绍下什么是队列： （1）队列是一个有序列表，可以用数组或是链表来实现。 （2）遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入的要后取出。 这里用Go 实现一个一次性的队列 package main import ( "errors" "fmt" ) type Query struct { maxSize int //最大容量 array [4]int //数组 head int //队首指针 tail int //队尾指针 } //初始化一个Que
GO语言数据结构之队列
zlyGOGOGO的博客
08-16 736
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 顺序队列 在顺序队列中，为了降低运算的复杂度，元素入队时，只修改队尾指针；元素出对时，只修改队头指针。由于顺序队列的存储空间是提前设定的，因此队尾指针会有一个上限值，当队尾指针达到其上限时，就不能只通过修改队尾指针来实现新元素的入队操作了。 代码实现 //定义队列结构 type queue struct {
go语言实现数据结构
10-20
Go语言是一种开源的编程语言，它支持面向对象编程、并发编程和函数式编程等多种编程范式。在Go语言中，数据结构的实现非常灵活，可以使用内置的数据结构，也可以手动实现自己的数据结构。常见的数据结构包括数组、链表、栈、队列、树、图等。在实现数据结构时，可以使用Go语言提供的接口，也可以手动实现。手动实现数据结构需要考虑数据结构的性能、可读性和可维护性等方面的问题。同时，Go语言还提供了一些第三方库，如container包、heap包等，可以方便地实现常见的数据结构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

물の韜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值