go语言实现最小堆并测试

最新推荐文章于 2024-06-24 16:02:31 发布
最新推荐文章于 2024-06-24 16:02:31 发布
阅读量877 收藏 1
点赞数
分类专栏： 学习笔记 服务计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jundesky/article/details/101217072
版权

作为go语言初学者，非常有必要多写写代码来熟悉go的语法和风格，本文是关于go语言实现最小堆，就不对最小堆进行赘述了，具体的构建原理可以参考我的这篇博客
下面直接上代码~

package main

import "fmt"

type Node struct {
	Value int
}

// 用于构建结构体切片为最小堆，需要调用down函数
func Init(nodes []Node) {
    for i := len(nodes)/2-1; i >=0; i-- {
        down(nodes,i,len(nodes)) 
    }
}

// 需要down（下沉）的元素在切片中的索引为i，n为heap的长度，将该元素下沉到该元素对应的子树合适的位置，从而满足该子树为最小堆的要求
func down(nodes []Node, i, n int) {
    parent := i
    child := 2*parent+1
    temp := nodes[parent].Value
    for{
        if child < n {
            if child + 1 < n && nodes[child].Value > nodes[child+1].Value {
                child++
            }
            if temp <= nodes[child].Value{
                break
            }
            nodes[parent].Value = nodes[child].Value
            parent = child
            child = child*2+1
        }else{
            break
        }
    }
    nodes[parent].Value = temp    
}

// 用于保证插入新元素(j为元素的索引,切片末尾插入，堆底插入)的结构体切片之后仍然是一个最小堆
func up(nodes []Node, j int) {
    child := j
    parent := (j-1) / 2
    for{
        if child == 0 {
            break
        }
        if nodes[parent].Value < nodes[child].Value {
            break
        }
        temp := nodes[child].Value
        nodes[child].Value = nodes[parent].Value
        nodes[parent].Value = temp
        child = parent
        parent = (parent-1)/2
    }
}

// 弹出最小元素，并保证弹出后的结构体切片仍然是一个最小堆，第一个返回值是弹出的节点的信息，第二个参数是Pop操作后得到的新的结构体切片
func Pop(nodes []Node) (Node, []Node) {
    min := nodes[0]
    nodes[0].Value = nodes[len(nodes)-1].Value
    nodes = nodes[:len(nodes)-1]
    down(nodes,0,len(nodes)-1)
    return min, nodes
}

// 保证插入新元素时，结构体切片仍然是一个最小堆，需要调用up函数
func Push(node Node, nodes []Node) []Node {
    nodes = append(nodes,node)
    up(nodes,len(nodes)-1)
    return nodes
}

// 移除切片中指定索引的元素，保证移除后结构体切片仍然是一个最小堆
func Remove(nodes []Node, node Node) []Node {
    for i := 0; i < len(nodes); i++ {
        if node.Value == nodes[i].Value {
            nodes[i].Value = nodes[len(nodes)-1].Value
            nodes = nodes[0:len(nodes)-1]
            down(nodes,0,len(nodes)-1)
            break
        }
    }
    return nodes
}

//我添加的函数，用于打印切片
func Display(nodes []Node) {
    for _, ele := range nodes {
        fmt.Printf("%d ", ele.Value)
    }
    fmt.Printf("\n")
}

func main() {
    nodes := []Node{
        Node{3},
        Node{6},
        Node{9},
        Node{1},
        Node{2},
        Node{5},
        Node{8},
        Node{4},
        Node{7},
    }
    fmt.Printf("Before test\n")
    Display(nodes)

    fmt.Printf("Testing Init() and down()\n")
    Init(nodes)
    Display(nodes)
    
    fmt.Printf("Testing up() with adding 0\n")
    node_add := Node{0}
    nodes = append(nodes,node_add)
    up(nodes,9)
    Display(nodes)

    fmt.Printf("Testing Pop() with popping 0\n")
    min, nodes := Pop(nodes)
    fmt.Printf("Minimum :%d\n",min)
    Display(nodes)

    fmt.Printf("Testing Remove() with removing 5\n")
    node_remove := Node{5}
    nodes = Remove(nodes,node_remove)
    Display(nodes)

    fmt.Printf("Testing Push()\n")
    array := []Node{
        Node{9},
        Node{7},
        Node{6},
    }
    node5 := Node{5}
    node4 := Node{4}
    node3 := Node{3}
    node2 := Node{2}
    node1 := Node{1}
    array = Push(node5,array)
    array = Push(node4,array)
    array = Push(node3,array)
    array = Push(node2,array)
    array = Push(node1,array)
    Display(array)
}

使用go test 命令和 testing 包进行测试

GoConvey是一款针对Golang的测试框架，可以管理和运行测试用例，同时提供了丰富的断言函数，并支持很多 Web 界面特性。使用go test指令就可以直接运行。
在测试之前，我们需要修改上面部分函数的返回值(这里就不放代码了)，返回构造好的最小堆，以便使用GoConvey进行测试。
首先将miniHeap.go打包，go build之后应该会在pkg中生成.a文件
然后在同一目录下，增加miniHeap_test.go测试文件：

package miniHeap

import (
    "testing"
    ."github.com/smartystreets/goconvey/convey"
)

func TestInit(t *testing.T){
    Convey("testing Init()",t,func(){
        So(Init([]Node{
        Node{3},
        Node{6},
        Node{9},
        Node{1},
        Node{2},
        Node{5},
        Node{8},
        Node{4},
        Node{7},
    }),ShouldResemble,[]Node{
        Node{1},
        Node{2},
        Node{5},
        Node{4},
        Node{3},
        Node{9},
        Node{8},
        Node{6},
        Node{7},
    })
    })
}

func TestUp(t *testing.T){
    Convey("testing up()",t,func(){
        So(up([]Node{
            Node{1},
            Node{2},
            Node{5},
            Node{4},
            Node{3},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
            Node{0},
        },9),ShouldResemble,
        []Node{
            Node{0},
            Node{1},
            Node{5},
            Node{4},
            Node{2},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
            Node{3},
        })
    })
}

func TestPop(t *testing.T){
    Convey("testing Pop()",t,func(){
        So(Pop([]Node{
            Node{0},
            Node{1},
            Node{5},
            Node{4},
            Node{2},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
            Node{3},
        }),ShouldResemble,
        []Node{
            Node{1},
            Node{2},
            Node{5},
            Node{4},
            Node{3},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
        })
    })
}

func TestPush(t *testing.T){
    Convey("testing Push()",t,func(){
        So(Push(Node{0},[]Node{
            Node{1},
            Node{2},
            Node{5},
            Node{4},
            Node{3},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
        }),ShouldResemble,
        []Node{
            Node{0},
            Node{1},
            Node{5},
            Node{4},
            Node{2},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
            Node{3},
        })
    })
}

func TestRemove(t *testing.T){
    Convey("testing Remove()",t,func(){
        So(Remove([]Node{
            Node{1},
            Node{2},
            Node{5},
            Node{4},
            Node{3},
            Node{9},
            Node{8},
            Node{6},
            Node{7},
        },Node{1}),ShouldResemble,
        []Node{
            Node{2},
            Node{3},
            Node{5},
            Node{4},
            Node{7},
            Node{9},
            Node{8},
            Node{6},
        })
    })
}

下面是运行结果

由于我也是初学者，有的地方还不甚明白(比如原Pop函数，返回一个切片和一个结构体，我不知道怎么写断言，只好去掉返回值中的结构体)，写法也比较笨重，希望大佬们可以指点指点~

farthjun
关注
专栏目录
Golang实现最大堆/最小堆
qq_42139963的博客
10-17 2311
Golang实现最大堆/最小堆 参考： https://yangjiahao106.github.io/2019/01/15/golang-%E6%9C%80%E5%A4%A7%E5%A0%86%E5%92%8C%E6%9C%80%E5%B0%8F%E5%A0%86/ https://studygolang.com/articles/24288 方法一 此方法就是比较传统、常见的方法，下面来构建一个最小堆： type Heap struct { Size int Elems []int } fun
最小堆排序的实现(Go)
01-07
最小堆的特点是其父节点的值不大于任何一个字节点的值， 实现的是升序排序。 最小堆实现排序的原理，构建一个堆，不断的删除堆顶，这里的删除并不是完全删除， 而是将堆顶移动到末尾，然后父节点开始下沉操作，最后成为一个有序序列。 代码如下: package main import fmt func buidHeap(a []int, n int) { //heapify from the last parent node for i := n / 2; i >= 1; i-- { heapifyUpToDown(a, i, n) } } // 排序索引从
golang 最小堆排序实现
weixin_42847874的博客
05-31 1712
开发十年，就只剩下这套Java开发体系了 &gt;&gt;&gt;    ...
从0开始实现一个最小堆｜Golang
weixin_42161901的博客
10-23 301
笔记
go --- 最大堆和最小堆
my_miuye的博客
01-23 2357
最大堆（大顶堆）：堆是一种完全二叉树（完全二叉树是满二叉树的一部分），根据树的结构可以通过数组来进行表示。
Go语言专题：程序测试
06-10
总之，了解并熟练应用Go语言的测试工具和方法，不仅可以提升个人的编程技能，也是团队合作中负责任的表现。通过本课程的学习，你将能够自如地进行单元测试、性能测试和压力测试，为你的Go语言项目提供坚实的保障。
Go语言实现最小配置的TLS客户端/服务器隧道
总结来说，go-tls项目展示了一个Go语言编写的使用TLS隧道技术的最小化客户端/服务器实现。它利用了Go语言的网络编程能力和标准库中提供的TLS支持。通过这个项目，开发者可以学习到如何在Go项目中使用TLS来保护网络...
基于go语言写的链式堆
08-08
在这个场景中，"基于go语言写的链式堆" 指的是利用Go编程语言实现的一种优化的堆结构，这种结构以链表的形式存储元素，而不是像二叉堆那样在数组中存储。下面我们将深入探讨链式堆的基本概念、特性以及Go语言实现的...
Daniel Lemire算法实现的Go语言最大最小移动滤波器
标签"Go"表明这个移动最小最大滤波器的实现是用Go语言编写的，可能是利用了Go语言的并发特性来提高滤波的效率。 文件压缩包名称为"movingminmax-master"，这可能是一个开源项目或者代码库的名称。从名称可以看出，...
Go实现堆排序
coolsunxu的博客
10-28 571
Go实现堆排序
go语言实现堆排序
weixin_42278305的博客
03-17 568
因此，我们可以从堆顶取出元素, 与数组最后一位交换，然后重新维护堆的性质，再取堆顶元素和最后第二位交换…长度为n的数组，最后一个元素下标为n-1, 所以它的父级下标为 (n-1-1) / 2 = n/2 - 1。堆排序指利用堆的性质进行排序的算法。当我们要给下标为i的节点，调整为满足堆的性质可以这样定义一个方法。注意： 我们需要从最后一个父节点开始调整堆。大顶堆：所有父节点的值大于大于子节点的值。小顶堆：所有父节点的值小于大于子节点的值。这是一个未排序的数组，对应的二叉堆。通常我们用数组来实现堆，
用 Go 实现堆和堆操作，可能是最通俗易懂的讲解了
EDDYCJY的博客
05-07 1225
堆是一种树形数据结构，分为大顶堆和小顶堆，顾名思义，大顶堆就是堆顶（第一个元素）始终存放的是这组元素中的最大元素，小顶堆就是堆顶元素是最小元素。如果需要从一组对象中查找最大值或最小值，使用堆能够高效率的完成需求。排序算法中的堆排序正是利用了堆这一数据完成的排序，堆在实际应用中主要被用于实现优先队列（priority queue）下面我们以小顶堆为例学习一下堆的结构和常规操...
golang 最小堆获取前 n 的数据
最新发布
chechenshi的博客
06-24 243
大量数据，想获取其中 Num 降序前五的数据。
go利用最小堆实现优先队列
u012233832的专栏
03-21 2314
实现代码 package core import "container/heap" type Item struct { Value interface{} Index int Priority int } type PriorityQueue []*Item func NewPriorityQueue(cap int) PriorityQueue {...
使用go提供的接口实现大小堆｜Golang
weixin_42161901的博客
10-23 329
笔记
go学习 --- 堆的实现
qq_46093575的博客
02-20 356
一、堆的实现 package main import ( "container/heap" "fmt" "math/rand" "time" ) type Girl struct { name string age int tall int beauty int } type GirlHeap []Girl //比大小 func (h *GirlHeap) Less(i, j int) bool { //return (*h)[i].age > (*h)[j].age
堆--go语言自己实现以及go源码解析
rglkt的博客
07-20 453
堆通常是一种完全二叉树（二叉堆）,分为大顶堆和小顶堆。大顶堆的性质是，堆中某个结点的值总是不大于父结点的值（表现形式就是树越往上越大，大在顶上，所以是大顶堆）。小顶堆相反。 完全二叉树的性质是：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。需要注意的是，满二叉树肯定是完全二叉树，而完全二叉树不一定是满二叉树。完全二叉树可以用数组来表示，树的根节点是数组下标为0处，父节点的左子节点下标在2父结点下标+1处，右节点下标在2父结点下标+2处。 满二叉树的性质是：除最后一层无任何子节点外，每
go语言 最小堆 最大堆 堆排序
weixin_43898670的博客
09-20 200
从第一个非叶结点开始 调整为大跟堆，这里就是图里面的1结点开始调整。先根据数组构建完全二叉树。
php 最小堆,Golang标准库深入 - 堆（container/heap）
weixin_29153859的博客
03-29 194
概述heap包提供了对任意类型(实现了heap.Interface接口)的堆操作。(最小)堆是具有“每个节点都是以其为根的子树中最小值”属性的树。树的最小元素为其根元素，索引0的位置。heap是常用的实现优先队列的方法。要创建一个优先队列，实现一个具有使用(负的)优先级作为比较的依据的Less方法的Heap接口，如此一来可用Push添加项目而用Pop取出队列最高优先级的项目。这是文档中的解释。(c...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值