golang实现队列

最新推荐文章于 2024-06-17 00:00:00 发布
最新推荐文章于 2024-06-17 00:00:00 发布
阅读量813 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： golang 数据结构
原文链接：http://xiaorui.cc/archives/2923
版权

基于环形缓冲区的双端队列实现

在这里插入图片描述

  • 代码：
package main

const minCapacity = 16

type Deque struct {
	buf []interface{}
	head int
	tail int
	count int
	minCap int
}

func NewDeque() *Deque  {
	return &Deque{
		buf:   make([]interface{}, minCapacity),
		head:  0,
		tail:  0,
		count: 0,
		minCap:minCapacity,
	}
}

func (d *Deque) Len() int  {
	return d.count
}

func (d *Deque) Empty() bool  {
	return d.count == 0
}

// 尾部插入元素：从尾部插入元素，则tail需要改变
func (d *Deque) PushBack(elem interface{})  {
	d.groupIfFull()
	
	d.buf[d.tail] = elem
	d.tail = d.next(d.tail)  // 计算新的尾部位置
	d.count++
}

// 头部插入元素: 从头部插入元素，则head需要改变
func (d *Deque) PushFront(elem interface{}) {
	d.groupIfFull()

	d.head = d.pre(d.head)
	d.buf[d.head] = elem
	d.count++
}



// 扩大/缩小容量： 为元素的2倍
func (d *Deque) resize()  {
	newBuf := make([]interface{}, d.count << 1)
	
	if(d.tail > d.head){
		copy(newBuf, d.buf[d.head:d.tail])
	}else{
		n := copy(newBuf, d.buf[d.head:])
		copy(newBuf[n:], d.buf[:d.tail])
	}
	
	d.head = 0
	d.tail = d.count   // 下一个尾部插入元素的索引位置
	d.buf = newBuf
}

// 大于最小容量 && 当前元素个数  <= 缓冲区容量大小/4
func (d *Deque) shrinkIfExcess() {
	if len(d.buf) > d.minCap && (d.count<<2) <= len(d.buf){
		d.resize()
	}
}

//prev返回环绕缓冲区的上一个缓冲区位置。
func (d *Deque) pre(i int) int {
	return (i - 1) & (len(d.buf) - 1)
}

// next返回环绕缓冲区的下一个缓冲区位置
func (d *Deque) next(i int) int {
	return (i + 1) & (len(d.buf) - 1)
}


// PopFront从队列前面删除并返回元素。如果队列为空则panic
func (d *Deque) PopFront() interface{} {
	if d.count <= 0 {
		panic("deque: PopFront() called on empty queue")
	}


	ret := d.buf[d.head]  // 备份要删除的元素
	d.buf[d.head] = nil  // 在要删除的那个位置写nil
	d.head = d.next(d.head) // 重新计算新head的索引
	d.count--              // 元素个数减少1

	d.shrinkIfExcess()
	return ret
}

//PopBack 从队列最后面删除并返回元素。如果队列为空则panic
func (d *Deque) PopBack() interface{} {
	if d.count <= 0 {
		panic("deque: PopBack() called on empty queue")
	}

	d.tail = d.pre(d.tail)


	ret := d.buf[d.tail]
	d.buf[d.tail] = nil
	d.count--

	d.shrinkIfExcess()
	return  ret
}

// Front 返回队首元素。如果队列为空则panic
func (d *Deque) Front() interface{} {
	if d.count <= 0 {
		panic("deque: Front() called when empty")
	}

	return d.buf[d.head]
}

// Back 返回队尾元素。如果队列为空则panic
func (d *Deque) Back() interface{} {
	if d.count <= 0 {
		panic("deque: Back() called when empty")
	}

	return d.buf[d.pre(d.tail)]
}
func (d *Deque) groupIfFull()  {
	if(len(d.buf) == 0){
		if(d.minCap == 0){
			d.minCap = minCapacity
		}

		d.buf = make([]interface{}, d.minCap)
		return
	}

	if(len(d.buf) == d.count){
		d.resize()
	}
}

//At返回队列中索引i处的元素，而不从队列中移除元素。
//此方法只接受非负索引值。
//At（0）表示第一个元素，与Front（）相同。
//At（Len（）-1）表示最后一个元素，与Back（）相同。
//如果索引无效，则panic。
// At的目的是让Deque充当一个更通用的循环缓冲区，其中的项只添加到Deque的末尾，
//也可以从Deque中的任何位置读取。考虑一个固定大小的循环日志缓冲区的情况：
//一个新的条目被推到一端，当满的时候从另一端弹出最旧的条目。
//缓冲区中的所有日志条目必须是可读的，而不改变缓冲区的内容。
func (q *Deque) At(i int) interface{} {
	if i < 0 || i >= q.count {
		panic("deque: At() called with index out of range")
	}
	// bitwise modulus
	return q.buf[(q.head+i)&(len(q.buf)-1)]
}

// Set设置索引i处的元素。Set与At（）具有相同的用途，但执行相反的操作。
//索引i与At（）定义的索引相同。如果索引无效，则panic
func (q *Deque) Set(i int, elem interface{}) {
	if i < 0 || i >= q.count {
		panic("deque: Set() called with index out of range")
	}
	// bitwise modulus
	q.buf[(q.head+i)&(len(q.buf)-1)] = elem
}


// 清除将从队列中删除所有元素，但保留当前容量。
//当在重用期间以高频重复使用队列以避免GC时，这很有用。
//只要只添加项目，队列的大小就不会变小。只有当项目被移除时，队列的大小才会变小。
func (q *Deque) Clear() {
	// bitwise modulus
	modBits := len(q.buf) - 1
	for h := q.head; h != q.tail; h = (h + 1) & modBits {
		q.buf[h] = nil
	}
	q.head = 0
	q.tail = 0
	q.count = 0
}

// 设置 最小容量 = 2^(minCapacityExp)
func (q *Deque) SetMinCapacity(minCapacityExp uint) {
	if 1<<minCapacityExp > minCapacity {
		q.minCap = 1 << minCapacityExp
	} else {
		q.minCap = minCapacity
	}
}



func main() {

}
  • 容量设置成2^n的幂好处？
    任何一个数和2^n-1做&运算可以用在循环队列的数组中快速指针的位置。
    • 一个负数x和2^n-1做&运算相当于 2^n-1-|x|
    • 一个正数x和2^n-1做&运算相当于取余
func main() {
	cap := 4
	// tail
	fmt.Println((0 + 1) & (cap - 1)) // 1   tail = 0时，后一个索引为1
	fmt.Println((1 + 1) & (cap - 1)) // 2   tail = 1时，后一个索引为2
	fmt.Println((2 + 1) & (cap - 1)) // 3   tail = 2 时，后一个索引为3
	fmt.Println((3 + 1) & (cap - 1)) // 0   tail = 4 时，后一个索引为0

	// head 的那个索引
	fmt.Println((0 - 1) & (cap - 1)) // 3    head = 0时， 前一个索引是3
	fmt.Println((1 - 1) & (cap - 1)) // 0    head = 1时， 前一个索引为0
	fmt.Println((2 - 1) & (cap - 1)) // 1    head = 2时， 前一个索引为1
	fmt.Println((3 - 1) & (cap - 1)) // 2    head = 3时， 前一个索引为2
}

https://github.com/gammazero/deque
参考

优先队列

版本一： 基于切片实现

优先队列的本质是一个大根堆或者小根堆。 如何构建一个堆
优先队列 = 普通的单向队列 + 堆
在这里插入图片描述

基于切片的堆实现
package main

import (
	"sync"
)

type HeapItem interface {
	Less (than HeapItem) bool
}


type Heap struct {
	sync.Mutex
	data []HeapItem
	min  bool  // 当前堆是不是最小堆
}

func NewHeapMin() *Heap {
	return &Heap{
		data: make([]HeapItem, 0),
		min:  true,
	}
}

func NewHeapMax() *Heap {
	return &Heap{
		data: make([]HeapItem, 0),
		min:  false,
	}
}

// 无论是沉底还是上升，都需要比较
func (h *Heap) Less(a, b HeapItem) bool  {
	if h.min {
		return a.Less(b)
	}else{
		return b.Less(a)
	}
}


// 让最上面的元素沉底
func (h *Heap)ShiftDown()  {
	parent := 0
	leftchild := parent << 1 + 1
	rightchild := parent << 1 + 2

	for{
		min := parent
		if leftchild < h.Len() && h.Less(h.data[leftchild], h.data[min]) {
			min = leftchild
		}
		if rightchild < h.Len() && h.Less(h.data[rightchild], h.data[min]) {
			min = rightchild
		}

		if min == parent{
			return
		}

		h.data[min], h.data[parent] = h.data[parent], h.data[min]
		parent = min
		leftchild = parent << 1 + 1
		rightchild = parent << 1 + 2
	}
}

// 将数组的最后一个元素放到正确的位置去
func (h *Heap)ShiftUp()  {
	index := h.Len()  - 1
	parent := (index - 1) >> 1

	for parent >= 0 && h.Less(h.data[index], h.data[parent]) {  // 当前节点和父节点比较
		h.data[parent], h.data[index] = h.data[index], h.data[parent]
		index = parent
		parent = (index - 1) >> 1
	}
}



func (h *Heap)Empty() bool  {
	return len(h.data) == 0
}

func (h *Heap) Len() int {
	return len(h.data)
}

func (h *Heap) Insert(v HeapItem) {
	h.Lock()
	defer h.Unlock()

	h.data = append(h.data, v)
	h.ShiftUp()
}

func (h *Heap) Delete() HeapItem{
	h.Lock()
	h.Unlock()

	if h.Len() == 0 {
		return nil
	}

	var el, last HeapItem

	el = h.data[0]
	last = h.data[h.Len() - 1]

	if h.Len() == 1 {
		h.data = nil
	}else{
		h.data = append([]HeapItem{last}, h.data[1:h.Len()-1]...)
		h.ShiftDown()
	}

	return el
}

测试：

package main

import (
	"fmt"
	"testing"
)

type Int int

func (x Int) Less(than HeapItem) bool {
	return x < than.(Int)
}

func TestMinHeap(t *testing.T) {
	h := NewHeapMin()

	h.Insert(Int(8))
	h.Insert(Int(7))
	h.Insert(Int(6))
	h.Insert(Int(3))
	h.Insert(Int(1))
	h.Insert(Int(0))
	h.Insert(Int(2))
	h.Insert(Int(4))
	h.Insert(Int(9))
	h.Insert(Int(5))

	sorted := make([]Int, 0)
	for h.Len() > 0 {
		sorted = append(sorted, h.Delete().(Int))
	}

	for i := 0; i < len(sorted)-2; i++ {
		if sorted[i] > sorted[i+1] {
			fmt.Println(sorted)
			t.Error()
		}
	}
}

func TestMaxHeap(t *testing.T) {
	h := NewHeapMax()

	h.Insert(Int(8))
	h.Insert(Int(7))
	h.Insert(Int(6))
	h.Insert(Int(3))
	h.Insert(Int(1))
	h.Insert(Int(0))
	h.Insert(Int(2))
	h.Insert(Int(4))
	h.Insert(Int(9))
	h.Insert(Int(5))

	sorted := make([]Int, 0)
	for h.Len() > 0 {
		sorted = append(sorted, h.Delete().(Int))
	}

	for i := 0; i < len(sorted)-2; i++ {
		if sorted[i] < sorted[i+1] {
			fmt.Println(sorted)
			t.Error()
		}
	}
}
优先队列实现
package main

import (
	"fmt"
)

type PQItem struct {
	Value interface{}
	Priority  int
}

func (p PQItem) Less(than HeapItem) bool {
	return p.Priority < than.(PQItem).Priority
}

func NewPQItem(v interface{}, priority int) *PQItem  {
	return &PQItem{
		Value:    v,
		Priority: priority,
	}
}

type PQ struct {
	data  Heap
}

func NewMaxPQ() *PQ {
	return &PQ{
		data:*NewHeapMax(),
	}
}

func NewMinPQ() *PQ  {
	return &PQ{
		data:*NewHeapMin(),
	}
}

func (pq *PQ)Empty() bool  {
	return pq.data.Empty()
}

func (pq *PQ)Len() int  {
	return pq.data.Len()
}

// data是[]heapItem的，因此只要PQ实现了heapItem的接口就可以
func (pq *PQ)Insert(v PQItem)  {
	pq.data.Insert(v)
}

func (pq *PQ)Delete()( PQItem){
	return pq.data.Delete().(PQItem)
}

func (pq *PQ)ChangePriority(val interface{}, priority int) (err error) {
	// 先判断当前队列中有没有val。
	var storeage []PQItem


	found := pq.Delete()
	for found.Value != val {
		if pq.Len() == 0 {
			err =  fmt.Errorf("Item not found")
			break
		}
		storeage = append(storeage, found)
		found = pq.Delete()
	}

	// 跳出循环： err == nil --->   found.Value == value
	 //           err != nil  ---> found.Value != value

	// 找到了
	if err == nil {
		found.Priority = priority
	}

	pq.data.Insert(found)

	for len(storeage) > 0  {
		var el PQItem
		el, storeage = storeage[0], storeage[1:]
		pq.data.Insert(el)
	}

	return nil
}

测试：

package main

import (
	"fmt"
	"testing"
)

func TestMaxPriorityQueue(t *testing.T) {
	h := NewMaxPQ()

	h.Insert(*NewPQItem(8, 10))
	h.Insert(*NewPQItem(7, 11))
	h.Insert(*NewPQItem(6, 12))
	h.Insert(*NewPQItem(3, 13))
	h.Insert(*NewPQItem(1, 14))
	h.Insert(*NewPQItem(0, 15))
	h.Insert(*NewPQItem(2, 16))
	h.Insert(*NewPQItem(4, 17))
	h.Insert(*NewPQItem(9, 18))
	h.Insert(*NewPQItem(5, 19))

	sorted := make([]PQItem, 0)
	for h.Len() > 0 {
		sorted = append(sorted, h.Delete())
	}

	for i := 0; i < len(sorted)-2; i++ {
		if sorted[i].Priority < sorted[i+1].Priority {
			fmt.Println(sorted)
			t.Error()
		}
	}
}


func TestMinPriorityQueue(t *testing.T) {
	h := NewMinPQ()

	h.Insert(*NewPQItem(8, 10))
	h.Insert(*NewPQItem(7, 11))
	h.Insert(*NewPQItem(6, 12))
	h.Insert(*NewPQItem(3, 13))
	h.Insert(*NewPQItem(1, 14))
	h.Insert(*NewPQItem(0, 15))
	h.Insert(*NewPQItem(2, 16))
	h.Insert(*NewPQItem(4, 17))
	h.Insert(*NewPQItem(9, 18))
	h.Insert(*NewPQItem(5, 19))

	sorted := make([]PQItem, 0)
	for h.Len() > 0 {
		sorted = append(sorted, h.Delete())
	}

	for i := 0; i < len(sorted)-2; i++ {
		if sorted[i].Priority > sorted[i+1].Priority {
			fmt.Println(sorted)
			t.Error()
		}
	}
}

func TestChangePriority(t *testing.T) {
	h := NewMaxPQ()

	h.Insert(*NewPQItem(8, 10))
	h.Insert(*NewPQItem(7, 11))
	h.Insert(*NewPQItem(6, 12))
	h.Insert(*NewPQItem(3, 13))
	h.Insert(*NewPQItem(1, 14))
	h.Insert(*NewPQItem(0, 15))
	h.Insert(*NewPQItem(2, 16))
	h.Insert(*NewPQItem(4, 17))
	h.Insert(*NewPQItem(9, 18))
	h.Insert(*NewPQItem(5, 19))

	h.ChangePriority(8, 66)
	popped := h.Delete()

	if popped.Value != 8 {
		t.Error()
	}
}
OceanStar的学习笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang数据结构与算法之队列
PandaQ的博客
04-26 348
队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 1.思路分析 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下其中maxSize是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示： 使用数组实现队列的思路： 1.创建一个数组array,是作为队列的一
golang环形队列实现代码示例
09-18
下面我们将详细讲解环形队列的概念、实现原理以及Golang中的具体代码实现。 首先，理解环形队列的概念非常重要。环形队列是基于固定大小数组构建的，队列的头部和尾部通过两个指针（front和rear）来标记。当元素...
Golang实现队列
布史之铭
08-27 281
队列 package queue type Element interface{} type Queue interface { Offer(e Element) //向队列中添加元素 Poll() Element //移除队列中最前面的元素 Clear() bool //清空队列 Size() int //获取队列的元素个数 IsEmpty() bool ...
golang实现循环队列
最新发布
ffmpeg&webrtc&study
06-17 1040
假溢出通常发生在循环队列的头部和尾部索引在数组中相遇时，即使数组中还有空间可以存放新元素。出现假溢出的原因，从根本上来说，是因为循环队列的容量被错误地判断为已满。在Go语言中实现循环队列，我们需要定义一个循环队列的数据结构，并实现其基本操作，包括初始化、入队（Push）、出队（Pop）、获取队列长度等。避免假溢出的关键在于正确地维护队列的状态信息，确保在任何时候都能准确地判断队列是否真正满了或者空了。在设计循环队列时，应该根据具体的应用场景和性能要求来选择最合适的策略。
数据结构【Golang实现】(六)——队列
脑袋装水的博客
03-16 2683
《Go语言》实现顺序队列、链式队列、循环队列
Golang-队列
samson
01-08 2917
一.使用链表实现队列 package Algorithm import ( "container/list" "errors" "fmt" "sync" ) type Queue struct { list *list.List mutex sync.Mutex } func GetQueue() *Queue { return &Queue{ list:list...
基于golang的简单分布式延时队列服务的实现
12-20
【基于Golang的简单分布式延时队列服务实现】 在软件开发中，有时我们需要处理非实时任务，例如在特定时间点发布公告或在用户完成某项操作后延迟执行某些操作，如发送提醒或奖励。传统的解决方案是为这些任务创建...
用golang实现一个定时器任务队列实例
01-03
很有幸得到公司信任，采用新的语言进行一些底层服务的开发，在实现功能的同时，也获得了一些感悟，因此在这记录一下，方便自己查看也可以共享给大家。 golang中定时器 golang中提供了2种定时器timer和ticker（如果...
lane:Golang的队列，堆栈和双端队列实现库
04-13
车道Lane包提供队列，优先级队列，堆栈和双端队列数据结构的实现。 它的设计考虑了简单性，性能和并发使用。优先队列Pqueue是堆优先级队列数据结构的实现。 它可以是最大订购量还是最小订购量，是否已同步以及对于...
golang 切片实现队列
gitxuzan
10-13 356
type SliceQueue struct { data []interface{} mu sync.Mutex } func NewSliceQueue(n int) (q *SliceQueue) { return &SliceQueue{data: make([]interface{}, 0, n)} } // Enqueue 把值放在队尾 func (q *SliceQueue) Enqueue(v interface{}) { q.mu.Lock.
Go-基于golang和redis实现的简单易用的队列
08-14
基于golang和redis实现的简单易用的队列
Go-GoQ在Golang中的轻量级消息队列
08-14
GoQ 在Golang中的轻量级消息队列
golang实现队列操作
skh2015java的博客
02-01 7665
队列和栈一样也是表。然而队列是插入在一段进行而删除在另一端进行。 队列是先进先出(FIFO)的。 下面用切片实现队列操作： package main import "fmt" type Element interface{} type Queue interface { Offer(e Element) //向队列中添加元素 Poll() Element /
【Golang】实现简单队列(Queue)数据结构
qq_40205510的博客
01-18 845
在计算机科学中，队列是一种特殊的线性数据结构，它遵循FIFO（先进先出）原则。队列中的元素只能从一端（称为队尾或后端）添加，并且只能从另一端（称为队头或前端）移除。这种特性使得队列在许多算法和数据结构中都有广泛的应用，例如操作系统中的任务调度、网络通信中的数据包排队等。在结构体中，我们实现了初始化、入队、出队和获取队列长度的方法。在Go语言中，我们可以使用切片（slice）来实现一个简单的队列。下面是一个示例代码，展示了如何定义一个队列结构体，并实现初始化、入队、出队和获取队列长度的方法。
golang算法之队列
qq_34820371的博客
06-20 184
golang算法之队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 单向对列代码实现 package main import ( "fmt" "errors" ) //结构体管理队列 type Queue struct { maxSize int //最大值 front int //队首 back int //队尾 arr
3.golang数据结构之队列
weixin_43893483的博客
09-02 2121
1. 队列的应用场景 2. 队列的介绍 1）队列是一个有序列表，可以用数组或是链表来实现。 2）遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 示意图：（使用数组模拟队列示意图） 3. 数组模拟队列 1）队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组声明如下，其中maxSize是该队列的最大容量 2）因为队列的输出、输入是分别从前后端来处理的，因此需要两个遍历front及rear分别记录队列前后端的下标，front会随着数据输出而改变，.
golang 队列（数组实例）
记录、分享、合作、共赢
05-17 9319
type ArrQue struct { Qs []string Size int Lock sync.Mutex } func (t *ArrQue) ArrAdd(data string) { t.Lock.Lock() defer t.Lock.Unlock() t.Qs = append(t.Qs, data) t.Size += 1 } func (t *ArrQue) ArrPop() string { t.Lock.Lock.
Golang实现简单爬虫框架（4）——队列实现并发任务调度
weixin_34068198的博客
05-27 291
前言 在上一篇文章《Golang实现简单爬虫框架（3）——简单并发版》中我们实现了一个最简单并发爬虫，调度器为每一个Request创建一个goroutine，每个goroutine往Worker队列中分发任务，发完就结束。所有的Worker都在抢一个channel中的任务。但是这样做还是有些许不足之处，比如控制力弱：所有的Worker在抢同一个channel中的任务，我们没有办法控制给哪一个wor...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值