Entwerfen und implementieren Sie die Datenstruktur einer verknüpften Liste in Golang

Entwurf und Implementierung der Datenstruktur einer verknüpften Liste in Golang

Einführung:
Eine verknüpfte Liste ist eine allgemeine Datenstruktur, die zum Speichern einer Reihe von Knoten verwendet wird. Jeder Knoten enthält Daten und einen Zeiger auf den nächsten Knoten. In Golang können wir verknüpfte Listen mithilfe von Strukturen und Zeigern implementieren.

1. Design und Strukturdefinition einer verknüpften Liste
   In Golang können wir Strukturen und Zeiger verwenden, um die Knoten der verknüpften Liste und die Struktur der verknüpften Liste selbst zu definieren. Die Knotenstruktur enthält ein Datenfeld und einen Zeiger auf den nächsten Knoten.

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

type LinkedList struct {
    head *Node // 链表头节点的指针
}

2. Initialisierung der verknüpften Liste
   Beim Erstellen einer verknüpften Liste müssen wir eine leere verknüpfte Liste initialisieren. Beim Initialisieren der verknüpften Liste ist der Kopfknotenzeiger der verknüpften Liste leer.

func NewLinkedList() *LinkedList {
    return &LinkedList{}
}

3. Einfügung in eine verknüpfte Liste
   Das Einfügen in eine verknüpfte Liste fügt einen Knoten am Ende der verknüpften Liste hinzu. Zuerst müssen wir einen neuen Knoten erstellen und ihm Daten zuweisen. Dann suchen wir den letzten Knoten der verknüpften Liste und zeigen mit seinem next-Zeiger auf den neuen Knoten. next指针指向新节点。

func (list *LinkedList) Insert(data interface{}) {
    newNode := &Node{data: data} // 创建新节点
    if list.head == nil {        // 链表为空
        list.head = newNode     // 直接将新节点设为头节点
    } else {
        current := list.head
        for current.next != nil {
            current = current.next // 找到链表的最后一个节点
        }
        current.next = newNode // 将新节点链接到最后一个节点的next指针
    }
}

4. 链表的删除
   链表的删除操作将找到并删除链表中特定节点。首先，我们需要找到要删除的节点的前一个节点，并将其next指针设置为被删除节点的next

func (list *LinkedList) Delete(data interface{}) {
    if list.head == nil {
        return // 链表为空，无需删除
    }
    if list.head.data == data { // 头节点需要删除
        list.head = list.head.next
        return
    }
    current := list.head
    for current.next != nil {
        if current.next.data == data { // 找到要删除节点的前一个节点
            current.next = current.next.next
            return
        }
        current = current.next
    }
}

Löschen der verknüpften Liste
Der Löschvorgang der verknüpften Liste sucht und löscht den spezifischen Knoten in der verknüpften Liste. Zuerst müssen wir den vorherigen Knoten des zu löschenden Knotens finden und seinen next-Zeiger auf den next-Zeiger des gelöschten Knotens setzen.
5. 
   

   func (list *LinkedList) Traverse() {
       if list.head == nil {
           return // 链表为空
       }
       current := list.head
       for current != nil {
           fmt.Println(current.data)
           current = current.next
       }
   }

Durchlauf der verknüpften Liste
Der Durchlaufvorgang der verknüpften Liste druckt alle Knoten in der verknüpften Liste.

func main() {
    list := NewLinkedList() // 创建一个新链表
    list.Insert(1)          // 插入节点1
    list.Insert(2)          // 插入节点2
    list.Insert(3)          // 插入节点3

    list.Traverse() // 遍历链表，输出: 1 2 3

    list.Delete(2)  // 删除节点2
    list.Traverse() // 遍历链表，输出: 1 3
}

Anwendungsbeispiel einer verknüpften Liste


rrreee🎜Fazit: 🎜In Golang können wir durch die Verwendung von Strukturen und Zeigern leicht verknüpfte Listendatenstrukturen implementieren. Die Einfüge-, Lösch- und Durchlaufvorgänge verknüpfter Listen sind ebenfalls sehr einfach und klar und können problemlos auf praktische Probleme angewendet werden. 🎜

Das obige ist der detaillierte Inhalt vonEntwerfen und implementieren Sie die Datenstruktur einer verknüpften Liste in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!