So implementieren Sie eine verknüpfte Liste in Golang

Verknüpfte Liste ist eine allgemeine Datenstruktur, die aus einer Reihe von Knoten besteht. Jeder Knoten enthält Daten und einen Zeiger auf den nächsten Knoten. In diesem Artikel verwenden wir die Go-Sprache, um eine einfache verknüpfte Liste zu implementieren.

1. Knotentyp definieren

Zuerst müssen wir einen Knotentyp definieren. Der Knoten sollte ein Datenelement und einen Zeiger auf den nächsten Knoten enthalten. Der Code lautet wie folgt:

type Node struct {
    Data interface{} //节点存储的数据
    Next *Node       //指向下一个节点的指针
}

Wir verwenden interface{}, um Knotendaten zu speichern, wodurch die verknüpfte Liste jede Art von Daten speichern kann.

2. Definieren Sie den Typ der verknüpften Liste.

Als nächstes müssen wir einen Typ der verknüpften Liste definieren. Es sollte einen Zeiger auf den ersten Knoten enthalten. Gleichzeitig haben wir zwei Methoden hinzugefügt: AddNode und Traverse.

type LinkedList struct {
    Head *Node //指向第一个节点的指针
}

//添加一个节点
func (l *LinkedList) AddNode(data interface{}) {
    newNode := &Node{Data: data}

    if l.Head == nil {
        l.Head = newNode
    } else {
        current := l.Head
        for current.Next != nil {
            current = current.Next
        }
        current.Next = newNode
    }
}

//遍历链表并执行函数
func (l *LinkedList) Traverse(fn func(interface{})) {
    current := l.Head
    for current != nil {
        fn(current.Data)
        current = current.Next
    }
}

Die AddNode-Methode fügt einen Knoten am Ende der verknüpften Liste hinzu. Wenn die verknüpfte Liste leer ist, wird der hinzugefügte Knoten zum ersten Knoten. Andernfalls durchlaufen wir die verknüpfte Liste, suchen den letzten Knoten und fügen den neuen Knoten als nächsten Knoten hinzu.

Die Traverse-Methode verwendet eine Rückruffunktion, um jeden Knoten in der verknüpften Liste zu bearbeiten. Es durchläuft jeden Knoten in der verknüpften Liste und führt dann die übergebene Funktion auf jedem Knoten aus. Wir können diese Methode verwenden, um die verknüpfte Liste zu durchlaufen und jeden Knoten zu drucken:

func main() {
    list := LinkedList{}
    list.AddNode("A")
    list.AddNode("B")
    list.AddNode("C")

    list.Traverse(func(data interface{}) {
        fmt.Println(data)
    })
}

Der obige Code wird gedruckt:

A
B
C

3. Löschen Sie den Knoten

#🎜 🎜#Jetzt fügen wir eine Methode hinzu, um einen Knoten aus der verknüpften Liste zu löschen.

//删除链表中的节点
func (l *LinkedList) RemoveNode(target interface{}) {
    if l.Head == nil {
        return
    }

    if l.Head.Data == target {
        l.Head = l.Head.Next
        return
    }

    current := l.Head
    for current.Next != nil {
        if current.Next.Data == target {
            current.Next = current.Next.Next
            return
        }
        current = current.Next
    }
}

Die RemoveNode-Methode verwendet einen Parameter, der den zu löschenden Knoten identifiziert, und durchläuft die verknüpfte Liste, um den Knoten zu finden. Wenn der Knoten gefunden wird, ändern Sie den nächsten Zeiger des aktuellen Knotens, um ihn aus der verknüpften Liste zu entfernen. Wenn die verknüpfte Liste leer ist oder der Knoten nicht gefunden wird, wird keine Aktion ausgeführt.

Vollständiger Code:

package main

import "fmt"

type Node struct {
    Data interface{} //节点存储的数据
    Next *Node       //指向下一个节点的指针
}

type LinkedList struct {
    Head *Node //指向第一个节点的指针
}

//添加一个节点
func (l *LinkedList) AddNode(data interface{}) {
    newNode := &Node{Data: data}

    if l.Head == nil {
        l.Head = newNode
    } else {
        current := l.Head
        for current.Next != nil {
            current = current.Next
        }
        current.Next = newNode
    }
}

//遍历链表并执行函数
func (l *LinkedList) Traverse(fn func(interface{})) {
    current := l.Head
    for current != nil {
        fn(current.Data)
        current = current.Next
    }
}

//删除链表中的节点
func (l *LinkedList) RemoveNode(target interface{}) {
    if l.Head == nil {
        return
    }

    if l.Head.Data == target {
        l.Head = l.Head.Next
        return
    }

    current := l.Head
    for current.Next != nil {
        if current.Next.Data == target {
            current.Next = current.Next.Next
            return
        }
        current = current.Next
    }
}

func main() {
    list := LinkedList{}
    list.AddNode("A")
    list.AddNode("B")
    list.AddNode("C")

    //遍历链表
    list.Traverse(func(data interface{}) {
        fmt.Println(data)
    })

    //删除节点并再次遍历链表
    list.RemoveNode("B")
    list.Traverse(func(data interface{}) {
        fmt.Println(data)
    })
}

Der obige Code wird gedruckt:

A
B
C
A
C

4. Zusammenfassung

In diesem Artikel Wir haben eine einfache verknüpfte Liste mit der Go-Sprache implementiert. Verknüpfte Listen sind eine wichtige Datenstruktur, die in vielen Algorithmen- und Softwareentwicklungsszenarien weit verbreitet ist. Erwägen Sie beim Schreiben von tatsächlichem Code das Hinzufügen zusätzlicher Funktionen und bewerten Sie die Leistung.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie eine verknüpfte Liste in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!