1.Queue定义
1.1 普通队列
像栈一样,队列(queue)也是一种线性表,它的特性是先进先出,插入在一端,删除在另一端。就像排队一样,刚来的人入队(push)要排在队尾(rear),每次出队(pop)的都是队首(front)的人。如图1,描述了一个队列模型。
队列(Queue)与栈一样,是一种线性存储结构,它具有如下特点:
- 队列中的数据元素遵循“先进先出”(First In First Out)的原则,简称FIFO结构。
- 在队尾添加元素,在队头删除元素。
例如:去银行取钱的排队;
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多倍.