Implementierung einer Prioritätswarteschlange in Go mit `container/heap`

Eine Prioritätswarteschlange ist eine abstrakte Datenstruktur, bei der jedem Element eine Priorität zugeordnet ist. Elemente werden basierend auf ihrer Priorität bedient, wobei Elemente mit höherer Priorität vor Elementen mit niedrigerer Priorität aus der Warteschlange entfernt werden. In Go bietet das Paket container/heap eine Möglichkeit, eine Prioritätswarteschlange mithilfe einer Heap-Schnittstelle zu implementieren.

Die Heap-Schnittstelle verstehen

Das Paket container/heap arbeitet mit Typen, die das heap.Interface implementieren. Diese Schnittstelle erfordert die folgenden Methoden:

type Interface interface {
    sort.Interface
    Push(x any) // add x as element Len()
    Pop() any   // remove and return element Len() - 1.
}

Durch die Implementierung dieser Schnittstelle können Sie benutzerdefiniertes Verhalten für Ihre Prioritätswarteschlange definieren.

Implementieren einer Prioritätswarteschlange

Um eine Prioritätswarteschlange zu erstellen, definieren Sie eine Struktur für die Elemente, die Sie speichern möchten, einschließlich eines Prioritätsfelds. Implementieren Sie dann das heap.Interface für ein Slice von Zeigern auf diese Elemente.

package main

import (
    "container/heap"
    "fmt"
)

// Item repräsentiert ein Element in der Prioritätswarteschlange.
type Item struct {
    value    string // Der Wert des Elements.
    priority int    // Die Priorität des Elements.
    index    int    // Der Index des Elements im Heap.
}

// PriorityQueue implementiert heap.Interface und enthält Items.
type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

// Wir möchten, dass Pop uns die höchste Priorität gibt, daher verwenden wir hier Größer-als.
func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].priority > pq[j].priority
}

func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
    pq[i].index = i
    pq[j].index = j
}

func (pq *PriorityQueue) Push(x any) {
    n := len(*pq)
    item := x.(*Item)
    item.index = n
    *pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() any {
    old := *pq
    n := len(old)
    item := old[n-1]
    item.index = -1 // zur Sicherheit
    *pq = old[0 : n-1]
    return item
}

// update ändert die Priorität und den Wert eines Elements in der Warteschlange.
func (pq *PriorityQueue) update(item *Item, value string, priority int) {
    item.value = value
    item.priority = priority
    heap.Fix(pq, item.index)
}

func main() {
    // Erstellen Sie eine Prioritätswarteschlange und fügen Sie einige Elemente hinzu.
    pq := make(PriorityQueue, 0)
    heap.Init(&pq)

    items := map[string]int{
        "banana": 3,
        "apple":  2,
        "pear":   4,
    }

    for value, priority := range items {
        heap.Push(&pq, &Item{
            value:    value,
            priority: priority,
        })
    }

    // Aktualisieren Sie die Priorität eines Elements.
    item := &Item{
        value:    "orange",
        priority: 1,
    }
    heap.Push(&pq, item)
    pq.update(item, item.value, 5)

    // Entfernen Sie Elemente aus der Prioritätswarteschlange.
    for pq.Len() > 0 {
        item := heap.Pop(&pq).(*Item)
        fmt.Printf("%s: %d\n", item.value, item.priority)
    }
}

Dieses Beispiel zeigt, wie Sie eine Prioritätswarteschlange in Go mithilfe des Pakets container/heap implementieren. Durch Anpassen der Methode Less können Sie definieren, ob sich Ihre Prioritätswarteschlange als Min-Heap oder Max-Heap verhält. In diesem Fall haben wir einen Max-Heap verwendet, um sicherzustellen, dass Elemente mit höherer Priorität zuerst aus der Warteschlange entfernt werden.

We are Leapcell, your top choice for hosting Go projects.

Leapcell is the Next-Gen Serverless Platform for Web Hosting, Async Tasks, and Redis:

Multi-Language Support

• Develop with Node.js, Python, Go, or Rust.

Deploy unlimited projects for free

• pay only for usage — no requests, no charges.

Unbeatable Cost Efficiency

• Pay-as-you-go with no idle charges.
• Example: $25 supports 6.94M requests at a 60ms average response time.

Streamlined Developer Experience

• Intuitive UI for effortless setup.
• Fully automated CI/CD pipelines and GitOps integration.
• Real-time metrics and logging for actionable insights.

Effortless Scalability and High Performance

• Auto-scaling to handle high concurrency with ease.
• Zero operational overhead — just focus on building.

Explore more in the Documentation!

Follow us on X: @LeapcellHQ