queen.go

package data_struct

import "log"

//环形队列实现 队列，先进先出。追加至队尾，弹出队顶
type Queen struct {
    Length   int64 //队列长度
    Capacity int64 //队列容量
    Head     int64 //队头
    Tail     int64 //队尾
    Data     []interface{}
}

//初始化
func MakeQueen(length int64) Queen {
    var q = Queen{
        Length: length,
        Data:   make([]interface{}, length),
    }
    return q
}

//判断是否为空
func (t *Queen) IsEmpty() bool {
    return t.Capacity == 0
}

//判断是否满
func (t *Queen) IsFull() bool {
    return t.Capacity == t.Length
}

//加一个元素
func (t *Queen) Append(element interface{}) bool {
    if t.IsFull() {
        log.Println("队列已满 ，无法加入")
        return false
    }
    t.Data[t.Tail] = element
    t.Tail++
    t.Capacity++
    return true
}

//弹出一个元素，并返回
func (t *Queen) OutElement() interface{} {
    if t.IsEmpty() {
        log.Println("队列为空，无法弹出")
    }
    defer func() {
        t.Capacity--
        t.Head++
    }()
    return t.Data[t.Head]
}

//遍历
func (t *Queen) Each(fn func(node interface{})) {
    for i := t.Head; i < t.Head+t.Capacity; i++ {
        fn(t.Data[i%t.Length])
    }
}

//清空
func (t *Queen) Clcear() bool {
    t.Capacity = 0
    t.Head = 0
    t.Tail = 0
    t.Data = make([]interface{}, t.Length)
    return true
}

queen_test.go

package data_struct

import (
    "fmt"
    "testing"
)

func TestQueen(t *testing.T) {
    var testLength = int64(4)
    q := MakeQueen(testLength)
    if q.Length != testLength {
        t.Error("MakeQueen(4)的容量不是4")
    }
    q.Append(10)
    q.Append(12)
    q.Append(14)
    q.Append(16)
    //q.Append(18)

    q.OutElement()
    //fmt.Println(q.OutElement())
    if q.Capacity != 3 {
        t.Error("队队长度不正确")
    }

    q.Each(func(node interface{}) {
        fmt.Println(node)
    })

    q.Clcear()
    if q.Capacity != 0 {
        t.Error("queen的长度不为0")
    }
    q.Each(func(node interface{}) {
        fmt.Println(node)
    })

    q.Append("B")
    q.Append('A')

    q.Each(func(node interface{}) {
        fmt.Println(node)
    })
}