线性结构-队列 Queue

1.Queue定义

    1.1 普通队列

像栈一样，队列（queue）也是一种线性表，它的特性是先进先出，插入在一端，删除在另一端。就像排队一样，刚来的人入队（push）要排在队尾(rear)，每次出队(pop)的都是队首(front)的人。如图1，描述了一个队列模型。

队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：

1. 队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。
2. 在队尾添加元素，在队头删除元素。

               

例如:去银行取钱的排队;

         

 

1.2普通队列的实现

      包的编写

package arr

import "log"

type Queue struct {
	C []interface{}
}

/**
 * Enqueue向队列中添加数据
 * @value 泛型
 */
func (q *Queue) Enqueue(value interface{}) []interface{} {
	q.C = append(q.C, value)
	return q.C
}

/**
 * Dequeue先队首取出数据
 */
func (q *Queue) Dequeue() interface{} {
	if len(q.C) == 0 {
		log.Fatal("错误:队首不为空")
	}
	rel := q.C[0]
	q.C = q.C[1:]
	return rel
}

/**
 * Getqueue展示全部的队列
 */
func (q *Queue) Getqueue() interface{} {
	return q.C
}

      包的调用

package main

import (
	"./arr"
	"fmt"
)

func main() {
	var a arr.Queue
	a.Enqueue(111)
	a.Enqueue(112)
	a.Enqueue(113)
	a.Enqueue(114)
	a.Dequeue()
	a.Dequeue()
	fmt.Println(a.C)

}

 

2.循环队列

    2.1循环队列的定义  

      大小为C的循环队列中

      front为当前队头元素位置，tail为当前队尾元素位置(最后一个元素的位置)，如果front<tail说明是正常队列，那么队列中的元素显然是tail-front+1,但是如果front>tail,队列中的元素个数为:(tail-front+C).此时该队列是循环队列. 

                               

    2.2循环队列的代码实现

       包的定义

package arr

import "log"

type Loopqueue struct {
	D    []interface{}
	Size int //指定循环队列的长度
}

//定义首位尾位置是0
var (
	front = 0
	tail  = 0
)

/**
 * Loopenqueue循环队列的入队
 * @value 泛型
 */
func (l *Loopqueue) Loopenqueue(value interface{}) {
	//判断队列是否已满
	if (tail+1)%l.Size == front {
		log.Fatal("队列已近溢满")
	}
	//定义slice
	if len(l.D) == 0 {
		l.D = make([]interface{}, l.Size)
	}
	l.D[tail] = value
	tail = (tail + 1) % l.Size
}

/**
 * Loopdequeue循环队列的出队
 */
func (l *Loopqueue) Loopdequeue() interface{} {
	if l.D[front] == nil {
		log.Fatal("队列为空")
	}
	rel := l.D[front]
	l.D[front] = nil
	front = (front + 1) % l.Size
	return rel
}

      包的使用

package main

import (
	"./arr"
	"fmt"
)

func main() {
	var a arr.Loopqueue
	a.Size=5
	a.Loopenqueue("我就是fornt")
	a.Loopenqueue(1)
	a.Loopenqueue(2)
	a.Loopenqueue(3)
	a.Loopdequeue()
	a.Loopenqueue(4)
	a.Loopdequeue()
	a.Loopenqueue(5)
	a.Loopdequeue()
	a.Loopenqueue(6)
	fmt.Println(a.D)

}

  最后提一句:相对于队列来说,循环队列的性能更加的优秀,两种数据结构对性能的影响基本相差100多倍.