Go版数据结构 -【5.2 优先队列】

最新推荐文章于 2025-06-17 15:17:28 发布
最新推荐文章于 2025-06-17 15:17:28 发布
阅读量728 收藏 16
点赞数 18
CC 4.0 BY-SA版权
分类专栏： Go版数据结构 文章标签： golang 数据结构 开发语言 Go版数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28796345/article/details/142826216

5.2 优先队列

优先队列 是一种特殊的队列，它与普通队列的区别在于：每个元素都有一个优先级，出队时，总是优先出队优先级最高的元素，而不是按照入队的顺序。

优先队列广泛应用于各种场景，如任务调度、路径规划等。它通常使用堆来实现，因为堆能保证高效的优先级出队和插入操作。

本节我们将介绍优先队列的基本概念、应用场景以及如何使用Go语言基于堆实现优先队列。

本节代码存放目录为 lesson11

概念及原理

优先队列 是一种抽象的数据结构，具有以下操作特性：

  • 插入元素：将一个新元素插入到优先队列中。

  • 删除优先级最高的元素：从优先队列中删除优先级最高的元素。

优先队列中的元素根据优先级进行排列，优先级可以是数值、字母、或任何可以比较的值。

优先队列通常使用堆来实现，堆的特性使得插入和删除操作都可以在 O(log n) 的时间复杂度内完成。

优先队列通常使用 堆 来实现，因为堆可以高效地维护一个动态集合，并快速地获取和移除优先级最高的元素。

最大堆 用于实现优先级递减的优先队列，即优先级最大的元素先出队。

最小堆 则用于实现优先级递增的优先队列，即优先级最小的元素先出队。

最大堆优先队列示意图

假设我们有一个优先队列，包含以下元素及其优先级：

(任务 A, 优先级 5)
(任务 B, 优先级 3)
(任务 C, 优先级 8)
(任务 D, 优先级 2)
(任务 E, 优先级 7)

使用最大堆维护这个优先队列的结构如下：

        C(8)
       /   \
    E(7)   A(5)
   /   \
 B(3) D(2)

在这个最大堆中，优先级最高的任务 C（8）位于堆顶，每次出队操作将移除堆顶元素，并调整堆的结构。

插入操作

插入新元素时，遵循堆的插入规则如下：

  • 将新元素插入到堆的末尾。

  • 通过 上滤 操作将新元素调整到正确的位置，以保持堆的性质。

操作示意如下所示：

初始堆状态：

		        C(8)
		       /   \
		    E(7)   A(5)
		   /   \
		 B(3) D(2)

1. 插入任务 F（优先级 10）：

   - 初始插入 F 到堆的末尾：
  
	        C(8)
	       /   \
	    E(7)   A(5)
	   /   \    /
	 B(3) D(2) F(10)

   - 上滤：F 的优先级高于 A，交换它们：

	        C(8)
	       /   \
	    E(7)   F(10)
	   /   \    /
	 B(3) D(2) A(5)
   
   - 上滤：F 的优先级高于 C，交换它们：

	        F(10)
	       /   \
	    E(7)   C(8)
	   /   \    /
	 B(3) D(2) A(5)

这与上一节我们讲到的堆操作其实是差不多的，都是插入到末尾，之后根据大小/优先级进行上滤/下滤等操作，最终形成符合规则的堆结构。

删除操作

删除优先级最高的元素时，遵循堆的删除规则：

  • 将堆的最后一个元素替换堆顶元素，并移除最后一个元素。

  • 通过 下滤 操作将替换后的堆顶元素调整到正确的位置，以保持堆的性质。

操作示意如下所示：

初始堆状态：

	        F(10)
	       /   \
	    E(7)   C(8)
	   /   \    /
	 B(3) D(2) A(5)

1. 删除任务 F（优先级 10）：

   - 将堆的最后一个元素 A 替换到堆顶：
   
	        A(5)
	       /   \
	    E(7)   C(8)
	   /   \
	 B(3) D(2)

   - 下滤：C 的优先级高于 A，交换它们：
  
	        C(8)
	       /   \
	    E(7)   A(5)
	   /   \
	 B(3) D(2)

删除的操作其实与上一节堆的删除也是一样的，只不过在上一节中，我们是通过节点进行比较，而在优先队列中则是使用优先级进行对比。

Go语言的实现

接下来我们使用Go语言基于最大堆实现优先队列的插入和删除操作，操作基本与上一节中的堆是一样的，只不过我们在元素上面加入了一个任务字段方便理解。

实现代码如下：

// item 定义节点结构
type item struct {
	// 任务
	task string
	// 优先级
	priority int
}

// PriorityQueue 定义优先队列结构
type PriorityQueue struct {
	items []*item
}

// Insert 插入元素
func (pq *PriorityQueue) Insert(task string, priority int) {
	pq.items = append(pq.items, &item{
		task:     task,
		priority: priority,
	})
	pq.siftUp(len(pq.items) - 1)
}

// 上滤操作，维持最大堆性质
func (pq *PriorityQueue) siftUp(index int) {
	parent := (index - 1) / 2
	if parent >= 0 && pq.items[parent].priority < pq.items[index].priority {
		pq.items[parent], pq.items[index] = pq.items[index], pq.items[parent]
		pq.siftUp(parent)
	}
}

// Remove 删除堆顶元素（优先级最高）
func (pq *PriorityQueue) Remove() *item {
	if len(pq.items) == 0 {
		return nil
	}

	// 将堆顶元素和最后一个元素交换，并删除堆顶元素
	top := pq.items[0]
	pq.items[0] = pq.items[len(pq.items)-1]
	pq.items = pq.items[:len(pq.items)-1]

	// 下滤操作，恢复堆序
	pq.siftDown(0)

	return top
}

// 下滤操作，维持最大堆性质
func (pq *PriorityQueue) siftDown(index int) {
	left := 2*index + 1
	right := 2*index + 2
	largest := index

	if left < len(pq.items) && pq.items[left].priority > pq.items[largest].priority {
		largest = left
	}
	if right < len(pq.items) && pq.items[right].priority > pq.items[largest].priority {
		largest = right
	}

	if largest != index {
		pq.items[index], pq.items[largest] = pq.items[largest], pq.items[index]
		pq.siftDown(largest)
	}
}

func (pq *PriorityQueue) print() {
	for _, v := range pq.items {
		fmt.Printf("任务 %s, 优先级 %d\n", v.task, v.priority)
	}
}

func main() {
	pq := &PriorityQueue{}
	pq.Insert("A", 5)
	pq.Insert("B", 3)
	pq.Insert("C", 8)
	pq.Insert("D", 2)
	pq.Insert("E", 7)

	fmt.Println("优先队列: ")
	pq.print()

	fmt.Println("删除优先级最高的元素: ", pq.Remove())
	fmt.Println("优先队列: ")
	pq.print()

	fmt.Println("删除优先级最高的元素: ", pq.Remove())
	fmt.Println("优先队列: ")
	pq.print()
}

执行结果如下所示：

优先队列: 
任务 C, 优先级 8
任务 E, 优先级 7
任务 A, 优先级 5
任务 D, 优先级 2
任务 B, 优先级 3

删除优先级最高的元素:  &{C 8}
优先队列: 
任务 E, 优先级 7
任务 B, 优先级 3
任务 A, 优先级 5
任务 D, 优先级 2

删除优先级最高的元素:  &{E 7}
优先队列: 
任务 A, 优先级 5
任务 B, 优先级 3
任务 D, 优先级 2

在上面的实现中，我们通过 Insert 函数插入元素，并通过 Remove 函数删除优先级最高的元素。每次插入和删除都通过上滤和下滤操作来维持堆的性质。

小结

优先队列是一种常用的数据结构，它基于堆实现，使得插入和删除操作非常高效。优先队列广泛应用于任务调度、路径规划等场景。

通过本节课的学习，我们了解了优先队列的基本概念、操作原理以及在Go语言中的实现。

通过我们的例子也可以看出，假设我们有一批任务需要执行，而这些任务都有不同的权重，那么这时候我们使用优先队列来做就会显得特别简单。

我的GitHub：https://github.com/swxctx

书籍地址：https://gs.golang.website/

书籍代码：https://github.com/YouCanGolang/GoStructedCode

19、堆、优先队列与图数据结构详解
jupyter5notebook的博客
06-28 9
本文详细介绍了堆、优先队列和图数据结构的基本概念、实现方式及其应用场景。内容涵盖优先队列的操作与实现、图的定义与表示方法、广度优先搜索与深度优先搜索算法、图在社交网络和交通网络中的应用，以及相关复杂度分析和存储优化策略。通过实际案例分析，展示了这些数据结构和算法在解决实际问题中的强大功能。
pq:Golang的优先队列
05-23
简单优先级队列 == 创建队列 开始N工人 通过工作程序（同步或异步）执行任务创建任务组（如果需要） 优先处理重要任务 安装： go get -u github.com/cheggaaa/pq 例子： package main import ( "fmt" "github.com/cheggaaa/pq" "time" ) type HardWork struct { name string priority int duration int } // implement pq.Task func ( w * HardWork ) Priority () int { return w . priority } func ( w * HardWork ) Run () ( err error ) { fmt . Printf ( "Start: %s (%
go的优先队列
weixin_39057744的博客
08-17 656
asf
go 并发队列、优先级队列、延迟队列
最新发布
skylar2的博客
06-17 465
好处：b.queue = b.queue[1:]会引起内存频繁分配，ringBuffer复用固定资源。等待时使用for，而不是if // 广播唤醒多个，但只有一个抢到了锁，其他需要重新等待枪锁。好处: ringBuffer使用固定内存，可能实际不需要，链表支持动态连接。ringBuffer比链表的优势：支持复杂操作，如随机访问。由于sync.cond没有超时控制，所以自行设计cond。ringBuffer替代[]*T。链表替代ringBuffer。使用cond进行超时阻塞控制。
golang优先队列
ayci54153的博客
03-29 323
参考博客：https://studygolang.com/articles/13173 基本类型排序 package main import ( "fmt" "sort" ) func main() { intList := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0} floatList := [...
Go--构建优先级队列
weixin_33841503的博客
11-03 361
1.官方示例 1.1 int队列 // This example demonstrates an integer heap built using the heap interface. package main import ( "container/heap" "fmt" ) // An IntHeap is a min-heap of ints. type IntHeap []int...
计算机考研数据结构---栈和队列
weixin_43970560的博客
07-17 1474
** 第三章 栈和队列 ** 一、栈的基本概念 1.1 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 空栈：不含任何元素的空表。 栈顶：线性表允许进行插入或删除的那一端。 栈底：固定的，线性表不允许进行插入和删除操作的一端。 假如某个栈S={a1,a2,a3,a4,a5}，a1为栈底元素，a5为栈顶元素。进栈次序a1->a2->a3->a4->a5，出栈次序：a5->a4->a3-
数据结构课程设计-多级队列调度算法的模拟.doc
05-26
### 数据结构课程设计-多级队列调度算法的模拟 #### 开发背景 多级队列调度算法（也称为反馈循环队列或多队列策略）是一种广泛应用于现代操作系统的CPU处理机调度算法，如UNIX等操作系统便采用了此类调度机制。其...
考研-数据结构-殷人昆.zip
09-09
2019 版数据结构高分笔记 X 3.1 栈和队列的基本概念 55 3.1.1 栈的基本概念 55 3.1.2 队列的基本概念 56 3.2 栈和队列的存储结构、算法与应用 56 3.2.1 本章所涉及的结构体定义 56 3.2.2 顺序栈 57 3.2.3 链栈 59 ...
数据结构--python 第五章 队列
Jasminexjf的博客
04-14 580
5.1 认识队列 队列的基本操作 用数组实现队列 用链表实现队列 5.2 队列的应用 环形队列 -- 双向队列 -- 优先队列 队列是一种“先进先出（First In First Out,FIFO）”的数据结构，和堆栈一样都是一种有序线性表的抽象数据类型（ADT）。就好比乘坐高铁时买票的队伍，先到的人当然可以先买票，买完后就从前端离去准备进入站台。 5.1 认识队列 队列...
go-queue:Golang的优先级和延迟队列
03-04
排队 Golang的优先级和延迟队列
golang优先级队列的实现
u013131603的博客
12-24 2630
在数据结构中，队列遵循着FIFO（先进先出）的规则。在此基础上，人们引申出了“优先级队列”的概念。在本文中，我将和大家一起探讨，golang优先级队列的一种实现方案。
golang实现的简单优先队列
weixin_30455067的博客
04-26 450
下面是golang实现的简单优先队列，参考信息可以查看https://golang.org/pkg/container/heap/或者https://golang.google.cn/pkg/container/heap/，后面这个网址也是官方提供的网址，关于这个网页的说明，可以参考https://blog.golang.org/hello-china。 package queue i...
数据结构与算法 — 二叉堆及优先队列的代码实现（Golang）
Mr_XiMu的博客
03-15 1928
二叉堆及优先队列的代码实现
堆（优先队列go语言）
Weird2020的博客
09-05 398
Go中，虽然没有直接提供优先队列的实现，不过通过标准库container/heap可以很方便的实现一个简单的优先队列。简单的说就是要实现5个接口就能使用了。
2. Golang优先队列（基于堆排序实现）
lihaoen666的博客
11-10 1530
优先队列 既然是优先队列，那么我们首先就需要给数据进行排序，这里最适合的排序方法就是堆排序。 排完序以后，就可以从队列里面取出想要的值。 // 最大堆、最小堆 // 接口实现比大小 type Item interface { Less(than Item) bool } type Int int func (x Int) Less(than Item) bool { return x < than.(Int) } // 最小堆 type Heap struct { // 数据 da.
golang container/heap最小堆-最大堆
a...Z
03-29 1064
package main import ( "container/heap" "fmt" ) // An Item is something we manage in a priority queue. type Item struct { value string // The value of the item; arbitrary. priority int // The priority of the item in the queue. // The index is n
数据结构与算法 — 二叉堆及优先队列的代码实现（Golang）_golang 优先队列
2401_84253380的博客
04-16 735
/结果：[0, 1, 2, 6, 3, 7, 8, 9, 10, 5]//结果：[1, 5, 2, 6, 7, 3, 8, 9, 10]if (array[parentIndex] < array[childIndex]) { //当父节点比子节点小的时候，退出循环。fmt.Println(array) //结果：[0, 1, 2, 6, 3, 7, 8, 9, 10, 5]fmt.Println(array) //结果：[1, 5, 2, 6, 7, 3, 8, 9, 10]看漫画算法 P101。
C++版数据结构习题解答及算法实现
文件中的“数据结构（C++版）”表明这是一本专注于在C++环境下实现和运用数据结构的教辅资料。 2. C++编程基础：文件中所提到的例题和习题的解答表明该资料中包含了大量的编程实践。涉及到的知识点可能包括变量、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Swxctx

您的鼓励将是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值