golang使用數(shù)組模擬環(huán)形隊列(demo)

// 定義環(huán)形隊列結構體
type LoopQueue struct {
 ? MaxSize int
 ? array [5]int
 ? front int
 ? rear int
 ? over bool ?// 標識隊列是否溢出
}

// 定義環(huán)形隊列的添加數(shù)據(jù)方法
func (loop *LoopQueue) Add(val int) {
 ? // 環(huán)形隊列如果隊列滿了會覆蓋前面先進來的位置元素
 ? if loop.rear == loop.MaxSize -1 ?{
 ? ? ?// 重置隊尾的指針指向,從頭重新開始隊列的邏輯
 ? ? ?// 這里如果用取模的話,還沒實現(xiàn)
 ? ? ?loop.rear = -1
 ? ? ?// 這個是為了退出條件,當loop.rear == loop.front
 ? ? ?loop.front = loop.rear + 1
 ? ? ?// 隊列是否溢出覆蓋
 ? ? ?loop.over = true
 ? }
 ? loop.rear++
 ? // 如果溢出了則會覆蓋隊列前面先進來的數(shù)據(jù),
 ? // 但是這些數(shù)據(jù)是后面進來的,要遵循FIFO原則,
 ? // 則隊列首部指針往后面移動
 ? if loop.over {
 ? ? ?loop.front++
 ? }
 ? loop.array[loop.rear] = val
}


// 定義環(huán)形隊列的數(shù)據(jù)查看方法
func (loop *LoopQueue) Show()(err error) ?{
 ? for i := loop.front + 1; i < loop.rear; i++ {
 ? ? ?fmt.Println("show:", loop.array[i])
 ? }
 ? return err
}

// 定義取出環(huán)形隊列的數(shù)據(jù)方法
func (loop *LoopQueue) Get()(val int, err error) {
 ? // 這里判斷隊列為空要分兩種情況
 ? // 1.正常隊列情況, 數(shù)據(jù)沒有溢出覆蓋,即隊列首部在前,隊列尾部在后,此時loop.front < loop.rear
 ? // 2.隊列溢出了.數(shù)據(jù)把以前隊列前面的數(shù)據(jù)覆蓋了,此時loop.front > loop.rear
 ? if loop.front == loop.rear {
 ? ? ?return -1, errors.New("queue is empty111")
 ? }
 ? // 這個表示隊列前面有些數(shù)據(jù)已經溢出被覆蓋了
 ? if loop.rear < loop.front {
 ? ? ?if loop.front == loop.MaxSize -1 {
 ? ? ? ? val = loop.array[loop.front]
 ? ? ? ? // 當front讀取隊列后邊尾部時,此時由于隊列是溢出的,隊列前面還有
 ? ? ? ? // 此時則重置front為初始值,從頭在開始邏輯
 ? ? ? ? loop.front = -1
 ? ? ? ? return val, err
 ? ? ?}
 ? ? ?val = loop.array[loop.front]
 ? ? ?loop.front++
 ? ? ?return val, err
 ? }
 ? if loop.front < loop.rear {
 ? ? ?if loop.rear == loop.front {
 ? ? ? ? return -1, errors.New("queue is empty~")
 ? ? ?}
 ? ? ?loop.front++
 ? ? ?val = loop.array[loop.front]
 ? ? ?return val, err
 ? }
 ? return
}