blocks|key|1178985|text|后一种情况是我们必须要做的。就Go没有泛型而言，它是目前唯一可用的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1178986|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The later case is what one has to do. As far as Go doesn't have generics, it's the only available option at the moment.

blocks|key|1172771|text|过去，标准库的container/vector模块中有一些矢量类型，它们基于可调整大小的切片实现了这些方法，并完美地充当了与heap模块一起使用的容器。不幸的是，他们抛弃了vector，我从来没有理解过它，因为它在切片变量上实现了一个很好的方法级抽象。所以现在，每当我看到有人在Go中使用堆模块时，他们基本上必须重新实现vector的一部分--基于切片变量编写Push、Pop、Length等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1172772|entityMap^0|7|G|1Q|4|2E|6|4G|6|50|4|55|3|59|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|G|$]]

There used to be vector types in the <code>container/vector</code> module of the standard library that implemented these methods, based on a resizable slice, and perfectly worked as the container to be used with the <code>heap</code> module. Unfortunately, they got rid of <code>vector</code>, which I never understood as it implemented a nice method-level abstraction over a slice variable. So now, every time I see someone using the heap module in Go, they have to basically re-implement part of <code>vector</code> -- writing <code>Push</code>, <code>Pop</code>, <code>Length</code>, etc. based on a slice variable.

blocks|key|4939246|text|我还没有尝试过，但是如果你的案例碰巧符合某些限制，也许你可以使用反射和结构标签。您将要求您的可堆类型是一个结构，在用于排序的字段上具有类似于pq:"Key"的标记，并且该字段类型是<可比较的。它远不如less方法强大，但它可能满足您的需求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4939247|对不起，我没有给你的示例代码。我认为这不会很难，但这需要我花一些时间。离开去做练习了。|4939248|如果我有需要处理任意结构的情况，并且我可以忍受简单的键限制，我可能会尝试这种技术。但是，对于有限的类型集，我不会这么做。我会照本宣科，为每种类型分别实现heap.Interface。这真的不是那么多的工作，也不是那么多的代码。|4939249|entityMap^0|1Y|8|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

Haven't tried it, but maybe you could use reflection and struct tags, if your cases happened to fit certain restrictons. You would require that your heapable type be a struct with a tag like `pq:"Key"` on the field you use for ordering, and that that field type be &lt; comparable. It's far less powerful than a Less method but it might meet your needs.

Sorry I have no example code for you. I don't think it wouldn be terribly hard, but it would take me some time. Left for an exercise.

I might try this technique if I had a situation where I needed to handle arbitrary structs and I could live with the simplistic key restriction. For a finite set of types though, I wouldn't do this. I would just do it by the book, implementing heap.Interface separately for each type. It's really not that much work nor that many lines of code.

blocks|key|3470265|text|我不确定我是否理解这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3470266|我在这里使用interface{}作为存储类型实现了一个队列(以及堆栈和环)：|3470267|https://github.com/iNamik/go_container|offset|length|3470268|使用interface{}允许您存储任何您想要的类型-尽管它不能帮助您将类型作为泛型强制执行，但它可以完成这项工作。|3470269|我可以看到创建优先级队列不会有太多麻烦。|3470270|我是不是遗漏了什么？|3470271|我很乐意添加一个优先级队列容器，如果您认为它有用的话。|3470272|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|12|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|E]]]]

I'm not sure I understand the question.

I've implemented a queue (and stack and ring) using interface{} as the stored type here:

<a href="https://github.com/iNamik/go_container" rel="nofollow">https://github.com/iNamik/go_container</a>

Using interface{} allows you to store any type you want - although it doesn't help you enforce types ala generics, it gets the job done.

I could see creating a priority queue without much hassle.

Am I missing something?

I'd be happy to add a priority queue container if you think you'd find it useful.

How would one go about writing the code for a reusable priority queue in Google Go or is one expected to define the <code>Less</code> <code>Push</code> and <code>Pop</code> function everytime a priority queue implementation is needed?

Reusable Priority queue implementation in google go

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如何在Google go中编写可重用优先级队列的代码，或者每次需要优先级队列实现时都需要定义Less、Push和Pop函数？

问google go中可重用优先级队列的实现
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问google go中可重用优先级队列的实现EN