go语言实现最小堆并测试

最新推荐文章于 2024-04-13 08:14:34 发布
最新推荐文章于 2024-04-13 08:14:34 发布
阅读量839 收藏 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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go语言使用GoConvey框架进行测试
Tifinity的博客
09-24 831
go语言使用GoConvey框架进行测试 本周作业为在go-online上完成一个最小堆算法，在完成之后我使用GoConvey进行测试。 要想写出好的的代码，必须学会测试框架，对于golang，可以使用自带的go test测试，也可以使用其他框架如 GoConvey，GoStub，GoMock，Monkey，本次我学习使用GoConvey。 安装GoConvey go get github.com...
Go语言专题：程序测试
06-10
总之，了解并熟练应用Go语言的测试工具和方法，不仅可以提升个人的编程技能，也是团队合作中负责任的表现。通过本课程的学习，你将能够自如地进行单元测试、性能测试和压力测试，为你的Go语言项目提供坚实的保障。
go --- 最大堆和最小堆
my_miuye的博客
01-23 2093
最大堆（大顶堆）：堆是一种完全二叉树（完全二叉树是满二叉树的一部分），根据树的结构可以通过数组来进行表示。
golang 源码阅读-heap堆的实现
王安的博客
04-27 289
heap包定义了实现一个堆所需的结构和堆的操作方法。heap包中提供了一个Interface接口，只要实现了这个接口，就能将该结构当做堆来使用。heap/*Len() int //返回堆的长度Less(i, j int) bool //比较索引i的元素和索引j元素的大小Swap(i, j int) //交换索引i和索引j的元素*/
golang标准库和第三方框架超详细使用指南_golang使用第三方库
最新发布
2401_84252281的博客
04-13 690
外链图片转存中…(img-6cUfyEK9-1712967256456)][外链图片转存中…(img-cXUNKBnj-1712967256456)][外链图片转存中…(img-TjaUpZJt-1712967256457)][外链图片转存中…(img-RaQtH0Ey-1712967256457)]
go语言 最小堆 最大堆 堆排序
weixin_43898670的博客
09-20 155
从第一个非叶结点开始 调整为大跟堆，这里就是图里面的1结点开始调整。先根据数组构建完全二叉树。
基于go语言写的链式堆
08-08
在这个场景中，"基于go语言写的链式堆" 指的是利用Go编程语言实现的一种优化的堆结构，这种结构以链表的形式存储元素，而不是像二叉堆那样在数组中存储。下面我们将深入探讨链式堆的基本概念、特性以及Go语言实现的...
mphf:用go编写的最小完美哈希表实现
07-12
总的来说，"mphf"是一个用Go语言实现的最小完美哈希表，它提供了一种高效、无冲突的键值映射方式，特别适用于需要快速查找和节省内存的应用场景。通过理解其内部实现机制和使用方法，开发者可以更好地利用这个工具来...
Go-goreq-最小的和简单的Go语言HTTP请求库
08-13
Go-goreq是一个轻量级且易于使用的Go语言库，专为简化HTTP请求而设计。在Go编程中，处理HTTP请求通常涉及使用内置的"net/http"包，但这个包提供的功能较为基础，对于某些场景可能过于繁琐。goreq库的目标就是通过...
Go-Go语言的json解析器基准
08-14
在Go语言中，进行性能基准测试通常会使用`testing`包，特别是`testing.B`类型，它允许开发者执行可重复的、时间量化的测试。此外，第三方库如`golang/gobenchnmark`和`github.com/gyuho/goraph/bench`也能提供更高级...
golang 最小堆排序实现
weixin_42847874的博客
05-31 1686
开发十年，就只剩下这套Java开发体系了 &gt;&gt;&gt;    ...
golang 高性能定时器之最小堆实现
weixin_42847874的博客
06-01 1451
开发十年，就只剩下这套Java开发体系了 &gt;&gt;&gt;    ...
（11）Go实现的最小堆求前K个最大值
哥斯拉啊啊啊哦的博客
09-04 481
在1,000,000个数字中,选出前100个最大的数字 // 在n个元素中选出前m个元素 // 如果用排序算法,最快时间 NlogN // 用最小二叉堆形式实现的优先队列,最快时间是 NlogM 算法思路： （1）最小堆中每次取出来的值都是堆中的最小值，利用这个性质维护一个m个节点最小堆； （2）遍历一篇数组，每次取出来的值和最小堆中的最小值做对比，如果大于最小堆中的最小值，则和该最小值做替换； ...
服务计算第4周：用go维护一个最小堆
zz9629的博客
10-05 203
课程网址：服务计算 - 云应用开发方法、技术与架构 项目传送门: week-4 文章目录1. 作业要求2.堆基础参考资料 1. 作业要求 TA布置的作业，go语言编程，实现一个最小堆。 2.堆基础 由于数据结构学的不太好，参考了 参考资料 go语言实现最小堆并测试 最大堆和最小堆 golang实现 Go语言中怎么实现一个小根堆 ...
堆排序（最小堆为例）
weixin_51392724的博客
11-11 1395
最小堆：每个节点的值都小于其左孩子和右孩子节点的值。 1.按完全二叉树的顺序插入要排序的元素。 2.若此元素a大于它的根节点b，则a和b交换位置。
【算法】堆，最大堆（大顶堆）及最小堆（小顶堆）的实现
热门推荐
一名普通码农的菜地
09-13 8万+
此坑待埋。 点击打开漫谈经典排序算法:一、从简单选择排序到堆排序的深度解析链接 白话经典算法系列之七 堆与堆排序 二叉排序树与二叉堆 下面来说一说具体算法。
【数据结构与算法】最小堆 minheap
u010900754的专栏
02-01 1万+
最小堆与最大堆实现思路一样，只不过顺序不同，这里只记录最小堆。 最小堆的定义是，一棵完全二叉树，每一个节点都大于等于其父节点。完全二叉树是叶子都在最后一层，且尽量靠左。 实现方面可以使用链表或者数组，这里使用数组。 如果使用数组，那么下标从0开始，父节点是i，则左子树是2*i+1，右子树是2*i+2。如果子节点是i，则父节点是（i-1)/2。 minheap的操作主要有两个，一个是add，
golang实现最小堆
06-09
要实现最小堆，可以使用golang内置的heap包。以下是一个最小堆的示例代码： ```go package main import ( "container/heap" "fmt" ) type MinHeap []int func (h MinHeap) Len() int { return len(h) } func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] } func (h MinHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } func (h *MinHeap) Push(x interface{}) { *h = append(*h, x.(int)) } func (h *MinHeap) Pop() interface{} { old := *h n := len(old) x := old[n-1] *h = old[0 : n-1] return x } func main() { h := &MinHeap{2, 1, 5, 3, 4} heap.Init(h) heap.Push(h, 0) fmt.Printf("minimum: %d\n", (*h)[0]) for h.Len() > 0 { fmt.Printf("%d ", heap.Pop(h)) } } ``` 这个程序创建了一个MinHeap类型，它实现了heap.Interface接口中的方法。其中Less方法定义了最小堆的比较规则，Push和Pop方法分别添加和删除元素，Len方法返回长度。程序中使用了heap包中的Init、Push和Pop方法来对最小堆进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值