Golang implementiert Warteschlangen

In der modernen Gesellschaft müssen sich die Menschen zunehmend anstellen, um verschiedene Probleme zu lösen, z. B. beim Kauf von Tickets, bei der medizinischen Behandlung, beim Transport usw. Eine Möglichkeit, Warteschlangen zu erreichen, ist der Einsatz von Computertechnologie.

Im Computerbereich gibt es eine Programmiersprache namens Go, auch bekannt als Golang. Es handelt sich um eine moderne Programmiersprache, die von Google entwickelt wurde und häufig zur Entwicklung leistungsstarker und verteilter Systeme eingesetzt wird. In diesem Artikel wird erläutert, wie Sie Warteschlangen mithilfe von Golang implementieren.

Das erste, was klargestellt werden muss, ist, dass Warteschlangen ein typisches Anwendungsszenario für Datenstrukturen sind. Daher können wir Warteschlangen in Golang verwenden, um Warteschlangen zu implementieren. Eine Warteschlange ist eine First-In-First-Out-Datenstruktur, die dem Warteschlangenmodell sehr ähnlich ist.

In Golang können wir die Liste im integrierten Containerpaket verwenden, um die Warteschlange zu implementieren. Die spezifische Implementierungsmethode lautet wie folgt:

1. Definieren Sie zunächst eine Warteschlangenstruktur:

type Queue struct {
    list *list.List
}

2. Als nächstes müssen wir die initialisieren Warteschlange und erstellen Sie eine neue Liste und geben Sie eine Instanz des Warteschlangentyps zurück:

func New() *Queue {
    return &Queue{
        list: list.New(),
    }
}

3. Wir müssen Elemente zur Warteschlange hinzufügen und können die Push-Methode der Warteschlange verwenden: # 🎜🎜## 🎜🎜#

   func (q *Queue) Push(v interface{}) {
       q.list.PushBack(v)
   }

Um die Elemente in der Warteschlange zu entfernen, müssen Sie die Pop-Methode der Warteschlange verwenden:

4. func (q *Queue) Pop() interface{} {
       e := q.list.Front()
       if e != nil {
           q.list.Remove(e)
           return e.Value
       }
       return nil
   }

Das Obige So verwenden Sie die Liste in Golang, um die Warteschlange zu implementieren.

Als nächstes werden wir Warteschlangen verwenden, um ein Warteschlangensystem zu implementieren. Im Warteschlangensystem müssen wir die folgenden Punkte implementieren:

Jedes Element in der Warteschlange repräsentiert eine an der Warteschlange teilnehmende Person, und die Informationen jeder Person müssen aufgezeichnet werden, z wie Nummer und Wartezeit warten.

1. Einzelpersonen müssen nach bestimmten Regeln in die Warteschlange eintreten, z. B. nach dem Prinzip „Wer zuerst kommt, mahlt zuerst“ oder nach Priorität.
2. Wenn die Anzahl der Personen in der Warteschlange ein bestimmtes Niveau erreicht, muss das System Personen gemäß bestimmten Regeln aus der Warteschlange entfernen, z. B. das Entfernen der ersten Person, die in die Warteschlange gelangt.
3. Wenn eine Person herausgenommen wird, muss sie aus der Warteschlange entfernt werden und ihre Wartezeit, Servicezeit und andere Informationen sollten aufgezeichnet werden.
Basierend auf den oben genannten Anforderungen können wir eine Personenstruktur definieren, um die Informationen jedes Einzelnen aufzuzeichnen:

type Person struct {
    id int       // 编号
    waitTime int // 等待时间
    serveTime int // 服务时间
}

Als nächstes können wir eine Warteschlangenstruktur definieren, Wird zum Implementieren der Warteschlangenfunktion verwendet:

type Queue struct {
    list *list.List // 存储每个个体
}

func NewQueue() *Queue {
    return &Queue{
        list: list.New(),
    }
}

func (q *Queue) Push(p *Person) {
    q.list.PushBack(p)
}

func (q *Queue) Pop() *Person {
    e := q.list.Front()
    if e != nil {
        q.list.Remove(e)
        return e.Value.(*Person)
    }
    return nil
}

func (q *Queue) Len() int {
    return q.list.Len()
}

Der obige Code zeigt, wie Warteschlangen zum Implementieren der Warteschlangenfunktion verwendet werden. Wir können diese Warteschlangenstruktur im Programm verwenden, um die Warteschlange im Warteschlangensystem darzustellen.

Wir können ein einfaches Beispiel implementieren, um zu demonstrieren, wie die Warteschlangenstruktur zum Implementieren eines Warteschlangensystems verwendet wird:

package main

import (
    "fmt"
    "time"
)

type Person struct {
    id int       // 编号
    waitTime int // 等待时间
    serveTime int // 服务时间
}

func NewPerson(id int) *Person {
    return &Person{
        id: id,
    }
}

func main() {
    q := NewQueue()

    // 模拟10个人排队
    for i := 1; i <= 10; i++ {
        p := NewPerson(i)
        q.Push(p)
    }

    // 每秒钟服务一个人，直到队列为空
    for q.Len() > 0 {
        time.Sleep(time.Second)
        p := q.Pop()
        if p != nil {
            p.waitTime += 1
            p.serveTime += 1
            fmt.Printf("编号%d的人被服务，等待%d秒，已服务%d秒
", p.id, p.waitTime, p.serveTime)
        }
    }
}

Der obige Code zeigt ein einfaches Warteschlangensystem, das den Prozess simuliert 10 Personen in der Warteschlange anzustellen und jede Sekunde eine Person zu bedienen, bis die Warteschlange leer ist.

In diesem Artikel wird erläutert, wie Sie mit Golang Warteschlangen implementieren. Bei der Implementierung eines Warteschlangensystems können wir Warteschlangen verwenden, um Personen zu speichern, Personen nach bestimmten Regeln zur Warteschlange hinzuzufügen, Personen aus der Warteschlange zu entfernen und individuelle Informationen aufzuzeichnen. Durch die Verwendung des Listenpakets in Golang können wir die Warteschlangenfunktionalität einfach implementieren.

Das obige ist der detaillierte Inhalt vonGolang implementiert Warteschlangen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!