So löschen Sie Elemente aus der Liste in der Go-Sprache

In der Go-Sprache können Sie die Funktion „remove()“ verwenden, um Listenelemente zu löschen. Die Syntax lautet „list object.Remove(element)“. Das Elementelement darf nicht leer sein. Wenn es nicht leer ist, wird der Wert des gelöschten Elements zurückgegeben. Wenn es leer ist, wird eine Ausnahme gemeldet.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

go bietet ein Listenpaket, ähnlich der Liste von Python, das beliebige Datentypen speichern kann und die entsprechende API wie folgt bereitstellt:

type Element
    func (e *Element) Next() *Element
    func (e *Element) Prev() *Element
type List
    func New() *List
    func (l *List) Back() *Element
    func (l *List) Front() *Element
    func (l *List) Init() *List
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element
    func (l *List) Len() int
    func (l *List) MoveAfter(e, mark *Element)
    func (l *List) MoveBefore(e, mark *Element)
    func (l *List) MoveToBack(e *Element)
    func (l *List) MoveToFront(e *Element)
    func (l *List) PushBack(v interface{}) *Element
    func (l *List) PushBackList(other *List)
    func (l *List) PushFront(v interface{}) *Element
    func (l *List) PushFrontList(other *List)
    func (l *List) Remove(e *Element) interface{}

Unter anderem wird die Funktion „remove()“ zum Löschen von Elementen aus der Liste verwendet Die gelöschten Elemente können nicht leer sein. Wenn es leer ist, wird eine Ausnahme gemeldet.

Remove(e *Element) interface{}

Parameter	Beschreibung
e	Zum Entfernen von Listenelementen.

Rückgabewert

• Gibt den Wert des gelöschten Elements zurück.

Beispiel für Listenlöschelemente

Beispiel 1:

package main
import (
	"container/list"
	"fmt"
)
func main() {
	//使用 Remove 在列表中删除元素
	listHaiCoder := list.New()
	listHaiCoder.PushFront("Hello")
	listHaiCoder.PushFront("HaiCoder")
	element := listHaiCoder.PushFront("Hello")
	removeEle := listHaiCoder.Remove(element)
	fmt.Println("RemoveElement =", removeEle)
	for i := listHaiCoder.Front(); i != nil; i = i.Next() {
		fmt.Println("Element =", i.Value)
	}
}

Analyse:

• Wir haben eine Liste listHaiCoder über list.New erstellt und dann die PushFront-Funktion zum Einfügen verwendet drei Artikel in das Listenelement und verwenden Sie dann die Funktion „Entfernen“, um das zuletzt eingefügte Element zu löschen.

• Abschließend drucken wir das gelöschte Element und die gelöschte Liste. Die Funktion „Entfernen“ gibt den Wert des gelöschten Elements zurück. Gleichzeitig stellen wir fest, dass das zuletzt eingefügte Element erfolgreich aus der Liste gelöscht wurde.

Beispiel 2: Leere Elemente löschen

package main
import (
	"container/list"
	"fmt"
)
func main() {
	//使用 Remove 在列表中删除空元素，报错
	listHaiCoder := list.New()
	listHaiCoder.PushFront("Hello")
	listHaiCoder.PushFront("HaiCoder")
	listHaiCoder.Remove(nil)
}

Nachdem das Programm ausgeführt wurde, lautet die Konsolenausgabe wie folgt:

Erweitertes Wissen: Liste löscht alle Elemente

Mit der vom Listenpaket bereitgestellten API Die Liste ist wirklich einfach zu verwenden. Es ist praktisch, aber wenn Sie während der Verwendung nicht aufpassen, werden Sie auf einige schwer zu findende Fallstricke stoßen, die dazu führen, dass die Programmergebnisse nicht den Erwartungen entsprechen. Die Gefahr hierbei ist das Problem, das beim Durchlaufen der Liste durch eine for-Schleife und beim Löschen aller Elemente auftritt. Das folgende Beispielprogramm erstellt beispielsweise eine Liste, speichert 0-3 der Reihe nach und durchläuft dann die Liste, um alle Elemente über eine for-Schleife zu löschen:

package main
import (
    "container/list"
    "fmt"
)
func main() {
    l := list.New()
    l.PushBack(0)
    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)
    fmt.Println("original list:")
    prtList(l)
    fmt.Println("deleted list:")
    for e := l.Front(); e != nil; e = e.Next() {
        l.Remove(e)
    }
    prtList(l)
}
func prtList(l *list.List) {
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Printf("%v ", e.Value)
    }
    fmt.Printf("n")
}

Die Ausgabe beim Ausführen des Programms lautet wie folgt:

original list:
0 1 2 3
deleted list:
1 2 3

From the Ausgabe, wir können wissen, dass die Elemente in der Liste nicht vollständig gelöscht wurden, sondern nur das erste Element 0 gelöscht wurde, was sich von der ursprünglichen Idee unterscheidet. Gemäß den Nutzungsgewohnheiten von Go sollte das Durchlaufen einer Liste und das Löschen aller Elemente erfolgen wie folgt geschrieben:

for e := l.Front(); e != nil; e = e.Next() {
    l.Remove(e)
}

Aber laut der Ausgabe des obigen Beispielcodes ist das Löschen aller Elemente der Liste ungültig. Was ist also das Problem? Aus dem for-Schleifenmechanismus können wir erkennen, dass, da das erste Element gelöscht wurde, das zweite Element jedoch nicht gelöscht wurde, die Bedingung der zweiten Schleife ungültig sein muss, was dazu führt, dass die Schleife beendet wird, d. h. nach der Ausführung die folgende Anweisung:

l.Remove(e)

e sollte Null sein, also wird die Schleife beendet. Fügen Sie eine print-Anweisung zur Überprüfung vor der l.Remove(e)-Anweisung in der for-Schleife hinzu. Fügen Sie beispielsweise die folgende Anweisung hinzu:

fmt.Println("delete a element from list")

Die Ausgabe beim Ausführen des Programms lautet wie folgt:

original list:
0 1 2 3
deleted list:
delete a element from list
1 2 3

Wie Sie sehen können wird tatsächlich nur einmal wiederholt und die Schleife ist beendet. Das heißt, nachdem die Anweisung l.Remove(e) ausgeführt wurde, ist e gleich e.Next(). Da e.Next() gleich Null ist, ist e Null und die Schleife wird beendet. Warum ist e.Next() Null? Wenn Sie sich den Quellcode der Go-Liste ansehen, sieht er wie folgt aus:

// remove removes e from its list, decrements l.len, and returns e.
func (l *List) remove(e *Element) *Element {
    e.prev.next = e.next
    e.next.prev = e.prev
    e.next = nil // avoid memory leaks
    e.prev = nil // avoid memory leaks
    e.list = nil
    l.len--
    return e
}
// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
func (l *List) Remove(e *Element) interface{} {
    if e.list == l {
        // if e.list == l, l must have been initialized when e was inserted
        // in l or l == nil (e is a zero Element) and l.remove will crash
        l.remove(e)
    }
    return e.Value
}

Sie können dem Quellcode entnehmen, dass bei der Ausführung von l.Remove(e) die Methode l.remove(e) intern aufgerufen wird, um Element e zu löschen . Um Speicherlecks zu vermeiden, werden e.next und e.prev auf Null gesetzt, was die Ursache des Problems ist.

Das korrigierte Programm lautet wie folgt:

package main
import (
    "container/list"
    "fmt"
)
func main() {
    l := list.New()
    l.PushBack(0)
    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)
    fmt.Println("original list:")
    prtList(l)
    fmt.Println("deleted list:")
    var next *list.Element
    for e := l.Front(); e != nil; e = next {
        next = e.Next()
        l.Remove(e)
    }
    prtList(l)
}
func prtList(l *list.List) {
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Printf("%v ", e.Value)
    }
    fmt.Printf("n")
}

Die Ausgabe des Programmlaufs lautet wie folgt:

original list:
0 1 2 3
deleted list:

Wie Sie sehen können, wurden alle Elemente in der Liste korrekt gelöscht.

【Verwandte Empfehlungen: Go-Video-Tutorial, Programmierunterricht】

Das obige ist der detaillierte Inhalt vonSo löschen Sie Elemente aus der Liste in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!