go语言队列的顺序表示和实现

1、队列的定义

• 队列(Queue)是一种先进先出的线性表，在表一段插入(表尾)，在另一端(表头)删除。
  • 队头(Front)，即表尾端
  • 队尾(Rear)，即表头端
  • FIFO(First In First Out)，即队列的操作具有先进先出的特性。
  • 与栈相同，队列也是限定插入和删除只能在表的"端点"进行的线性表，故栈和队列是线性表的子集(是插入和删除位置受限的线性表)。
• 顺序队列在表尾插入，在表头删除，其他操作和线性表类似，本文只给出以下操作的go语言实现。
  • 初始化
  • 入队
  • 出队

2、队列的初始化

//顺序队列的数据结构
type Queue struct {
    //这里的指针并不是指针变量，而是用来表示数组当中元素下标的位置
    front int //头指针
    rear int //尾指针
    length int //顺序表中元素的个数
    queueSize int //初始化动态分配存储空间
    queueList []interface{}
}

//初始化
func initQueue(size int, arr []interface{}) *Queue {
    if size <= 0 {return nil}
    qList := &Queue{
        front: 0,
        rear: 0,
        length: 0,
        queueSize: size,
        queueList: make([]interface{}, 0, size),
    }
    for i := range arr {
        qList.queueList = append(qList.queueList, arr[i])
        qList.rear ++
        qList.length ++
    }
    
    return qList
}

3、入队

//入队
func (queue *Queue) push(val interface{}) {
    if queue.rear == queue.queueSize && queue.front == 0 {
        fmt.Println("发生溢出，且为真溢出")
        return
    }
    if queue.rear == queue.queueSize && queue.front != 0 {
        fmt.Println("发生溢出，且为假溢出")
        return
    }

    queue.queueList = append(queue.queueList, val)
    queue.rear ++
    queue.length ++
}

4、出队

//出队
func (queue *Queue) pop() interface{} {
    if queue.front == queue.rear {
        fmt.Println("队空")
        return nil
    }

    val := queue.queueList[queue.front]
    queue.front ++
    queue.length --
    queue.queueList = queue.queueList[queue.front:]
    return val
}

5、完整代码及结果演示

package main

import "fmt"

//顺序队列的数据结构
type Queue struct {
    //这里的指针并不是指针变量，而是用来表示数组当中元素下标的位置
    front int //头指针
    rear int //尾指针
    length int //顺序表中元素的个数
    queueSize int //初始化动态分配存储空间
    queueList []interface{}
}

//初始化
func initQueue(size int, arr []interface{}) *Queue {
    if size <= 0 {return nil}
    qList := &Queue{
        front: 0,
        rear: 0,
        length: 0,
        queueSize: size,
        queueList: make([]interface{}, 0, size),
    }
    for i := range arr {
        qList.queueList = append(qList.queueList, arr[i])
        qList.rear ++
        qList.length ++
    }
    
    return qList
}

//入队
func (queue *Queue) push(val interface{}) {
    if queue.rear == queue.queueSize && queue.front == 0 {
        fmt.Println("发生溢出，且为真溢出")
        return
    }
    if queue.rear == queue.queueSize && queue.front != 0 {
        fmt.Println("发生溢出，且为假溢出")
        return
    }

    queue.queueList = append(queue.queueList, val)
    queue.rear ++
    queue.length ++
}

//出队
func (queue *Queue) pop() interface{} {
    if queue.front == queue.rear {
        fmt.Println("队空")
        return nil
    }

    val := queue.queueList[queue.front]
    queue.front ++
    queue.length --
    queue.queueList = queue.queueList[queue.front:]
    return val
}

func main() {
    data := []interface{}{
        "bala",
        "aa",
        12,
        45,
    }

    L := initQueue(8, data)
    fmt.Println(L)

    L.push(99)
    fmt.Println(L)

    aa := L.pop()
    fmt.Println(L, aa)
}

6、总结

与循环队列，链队列一起总结