suppression de la liste chaînée Golang

Golang est un langage de programmation efficace, concis, sûr et hautement évolutif qui prend en charge la mise en œuvre de structures de données telles que des listes chaînées. Une liste chaînée est une structure de données couramment utilisée qui peut être utilisée pour implémenter des piles, des files d'attente et d'autres structures de données. Dans une liste chaînée, chaque nœud contient des données et un pointeur vers le nœud suivant. Les opérations d'insertion et de suppression des listes chaînées sont plus efficaces que celles des tableaux, mais les opérations de suppression des listes chaînées sont plus compliquées. Cet article expliquera comment implémenter l'opération de suppression de liste chaînée dans Golang.

1. Connaissance de base des listes chaînées

Dans Golang, les listes chaînées sont implémentées à l'aide de structures et de pointeurs. Chaque nœud contient des données et un pointeur vers le nœud suivant, le pointeur du dernier nœud étant nul.

Ce qui suit est un exemple simple de liste chaînée :

type Node struct {
    val  int
    next *Node
}

Le code ci-dessus définit une structure nommée Node, qui contient une valeur de type int et un pointeur vers la suivante nœud ensuite.

Vous pouvez utiliser la méthode suivante pour créer une liste chaînée :

func createLinkedList() *Node {
    head := Node{0, nil} // 创建头结点
    curr := &head

    // 添加节点到链表
    for i := 1; i < 10; i++ {
        node := Node{i, nil}
        curr.next = &node
        curr = &node
    }

    return &head
}

Le code ci-dessus partira du nœud principal et ajoutera chaque nœud à la liste chaînée via une boucle continue . Enfin, la liste chaînée entière est renvoyée.

2. Opération de suppression de liste chaînée

L'opération de suppression de liste chaînée nécessite d'abord de parcourir la liste chaînée pour trouver le nœud qui doit être supprimé. Ensuite, mettez à jour le pointeur du nœud avant ce nœud afin qu'il pointe vers le nœud à côté du nœud supprimé. Enfin, libérez l'espace mémoire occupé par le nœud supprimé.

Voici comment implémenter l'opération de suppression de liste chaînée :

func deleteNode(head *Node, val int) *Node {
    dummy := &Node{0, head} // 创建虚拟头结点
    prev := dummy
    curr := head

    // 遍历链表，寻找需要删除的节点
    for curr != nil {
        if curr.val == val {
            prev.next = curr.next // 更新前一个节点的指针
            break
        }
        prev = curr
        curr = curr.next
    }

    return dummy.next
}

Le code ci-dessus crée d'abord un nœud principal virtuel pour gérer la situation où la suppression commence avec le nœud principal . Ensuite, parcourez la liste chaînée et recherchez le nœud qui doit être supprimé. Enfin, le pointeur du nœud précédent est mis à jour pour qu'il pointe vers le nœud situé à côté du nœud supprimé. Renvoie les nœuds restants dans la liste chaînée.

3. Code complet

Ce qui suit est un programme complet, comprenant la création d'une liste chaînée et la suppression de nœuds :

package main

import "fmt"

type Node struct {
    val  int
    next *Node
}

func createLinkedList() *Node {
    head := Node{0, nil} // 创建头结点
    curr := &head

    // 添加节点到链表
    for i := 1; i < 10; i++ {
        node := Node{i, nil}
        curr.next = &node
        curr = &node
    }

    return &head
}

func deleteNode(head *Node, val int) *Node {
    dummy := &Node{0, head} // 创建虚拟头结点
    prev := dummy
    curr := head

    // 遍历链表，寻找需要删除的节点
    for curr != nil {
        if curr.val == val {
            prev.next = curr.next // 更新前一个节点的指针
            break
        }
        prev = curr
        curr = curr.next
    }

    return dummy.next
}

func main() {
    head := createLinkedList()
    fmt.Println("before delete:")
    curr := head
    for curr != nil {
        fmt.Println(curr.val)
        curr = curr.next
    }

    head = deleteNode(head, 5)
    fmt.Println("after delete:")
    curr = head
    for curr != nil {
        fmt.Println(curr.val)
        curr = curr.next
    }
}

#🎜🎜 # Le programme crée une liste chaînée de 10 nœuds et supprime le nœud avec val 5. Enfin, affichez les valeurs des nœuds restants.

Summary

Cet article présente comment utiliser Golang pour implémenter des opérations de suppression de listes chaînées. La liste chaînée est une structure de données importante largement utilisée dans les algorithmes. La méthode présentée dans cet article peut être appliquée à l'implémentation de listes chaînées dans d'autres langages de programmation, et vous pouvez choisir de l'utiliser en fonction de vos besoins réels.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!