实现一个队列（Queue）

1. 入队操作
2. 出队操作
3. 获取队列的大小
4. 队列是否为空

数组队列代码示例：

package main

import (
    "fmt"
    "sync"
)

// 实现一个队列（Queue）
// 1. 入队操作
// 2. 出队操作

// 实现方式
// 数组队列

func main() {
    arrque := new(ArrayQueue)
    // 入队
    arrque.ArrayAdd("one")
    arrque.ArrayAdd("two")
    arrque.ArrayAdd("three")
    fmt.Println(arrque.Array)
    // 出队
    str := arrque.ArrayRemove()
    fmt.Println(str)
    str = arrque.ArrayRemove()
    fmt.Println(str)
    str = arrque.ArrayRemove()
    fmt.Println(str)
    str = arrque.ArrayRemove()
    fmt.Println(str)
    fmt.Println(arrque.Array)
}

// 定义数组队列的数据结构
type ArrayQueue struct {
    Array []string
    Size  int
    Lock  sync.Mutex
}

// 1. 入队操作
func(q *ArrayQueue) ArrayAdd(v string) {
    q.Lock.Lock()
    defer q.Lock.Unlock()

    q.Array = append(q.Array, v)
    q.Size++
}
// 2. 出队操作
func(q *ArrayQueue) ArrayRemove() string {
    q.Lock.Lock()
    defer q.Lock.Unlock()

    if q.Size == 0 {
        return ""
    }

    v := q.Array[0]
    q.Array = q.Array[1:]
    q.Size--
    return v
}

链表队列代码示例：

package main

import (
    "fmt"
    "sync"
)

// 实现一个队列（Queue）
// 1. 入队操作
// 2. 出队操作
// 3. 获取队列的大小
// 4. 队列是否为空

// 实现方式
// 链表队列

func main() {
    linQueue := new(LinkQueue)

    // 入队
    linQueue.LinkAdd("one")
    linQueue.LinkAdd("two")
    linQueue.LinkAdd("three")
    nowNode := linQueue.Top
    for nowNode != nil {
        fmt.Print(nowNode.Data, " ")
        nowNode = nowNode.Next
    }
    fmt.Println()
    fmt.Println("size:", linQueue.Size)
    fmt.Println("empty:", linQueue.LinkQueueIsEmpty())

    // 出队
    fmt.Println(linQueue.LinkRemove())
    fmt.Println(linQueue.LinkRemove())
    fmt.Println(linQueue.LinkRemove())
    fmt.Println(linQueue.LinkRemove())
    fmt.Println("size:", linQueue.Size)
    fmt.Println("empty:", linQueue.LinkQueueIsEmpty())
}

// 定义链表队列数据结构
type LinkNode struct {
    Data string
    Next *LinkNode
}
type LinkQueue struct {
    Top  *LinkNode
    Size int
    Lock sync.Mutex
}

// 1. 入队操作
func(q *LinkQueue) LinkAdd(v string) {
    q.Lock.Lock()
    defer q.Lock.Unlock()

    if q.Top == nil {
        q.Top = new(LinkNode)
        q.Top.Data = v
    } else {
        temp := new(LinkNode)
        temp.Data = v
        TNode := q.Top
        for TNode.Next != nil {
            TNode = TNode.Next
        }
        TNode.Next = temp
    }
    q.Size++
}
// 2. 出队操作
func(q *LinkQueue) LinkRemove() string {
    q.Lock.Lock()
    defer q.Lock.Unlock()
    if q.Size == 0 {
        return ""
    }

    v := q.Top.Data
    q.Top = q.Top.Next
    q.Size--
    return v
}
// 3. 获取队列的大小
func(q *LinkQueue) GetLinkQueueSize() int {
    return q.Size
}
// 4. 队列是否为空
func(q *LinkQueue) LinkQueueIsEmpty() bool {
    return q.Size == 0
}