Le langage Go est un langage de programmation rapide, efficace et fortement typé. Sa syntaxe élégante et sa riche bibliothèque standard le rendent largement utilisé dans le domaine Internet. En langage Go, une liste chaînée unique est une structure de données commune qui peut être utilisée pour stocker et organiser des données. Cet article approfondira les principes de mise en œuvre sous-jacents des listes à chaînage unique dans le langage Go et donnera des exemples de code spécifiques.

Concept de base de liste chaînée unique

La liste chaînée unique est une structure de données de base d'une liste linéaire, composée d'une série de nœuds, chaque nœud contient deux parties : des données et un pointeur vers le nœud suivant. L'avantage d'une liste à chaînage unique est que les opérations d'insertion et de suppression sont efficaces, mais les opérations de recherche sont relativement inefficaces.

En langage Go, nous pouvons utiliser des structures pour définir les nœuds d'une liste chaînée :

type Node struct {
    data int
    next *Node
}

Le code ci-dessus définit une structure de nœud contenant des données entières et un pointeur vers le nœud suivant. Ensuite, nous mettrons en œuvre plusieurs opérations de base d'une liste à chaînage unique : création, insertion, suppression et impression.

Créer une liste à chaînage unique

func createLinkedList() *Node {
    head := &Node{}
    return head
}

Le code ci-dessus définit une fonction qui crée une liste à chaînage unique, qui renvoie un nœud principal vide. Ensuite, nous implémenterons l’opération d’insertion dans une liste à chaînage unique.

Insert Node

func insertNode(head *Node, data int) {
    newNode := &Node{data, nil}
    if head.next == nil {
        head.next = newNode
    } else {
        temp := head
        for temp.next != nil {
            temp = temp.next
        }
        temp.next = newNode
    }
}

Le code ci-dessus définit une fonction d'insertion de nœud qui insère un nouveau nœud à la fin d'une liste à chaînage unique. Ensuite, nous implémenterons l’opération de suppression d’une liste à chaînage unique.

Delete Node

func deleteNode(head *Node, data int) {
    temp := head
    for temp.next != nil {
        if temp.next.data == data {
            temp.next = temp.next.next
            break
        }
        temp = temp.next
    }
}

Le code ci-dessus définit une fonction pour supprimer des nœuds, qui supprime le nœud correspondant dans la liste à chaînage unique en fonction des données spécifiées. Enfin, nous mettrons en œuvre l’opération d’impression d’une liste mono-chaînée.

Imprimer une liste à chaînage unique

func printLinkedList(head *Node) {
    temp := head.next
    for temp != nil {
        fmt.Print(temp.data, " ")
        temp = temp.next
    }
    fmt.Println()
}

Le code ci-dessus définit une fonction pour imprimer une liste à chaînage unique, qui parcourt la liste à chaînage unique à partir du nœud principal et génère les données de chaque nœud. Maintenant, nous pouvons utiliser le code ci-dessus pour créer, insérer, supprimer et imprimer une liste chaînée unique.

func main() {
    head := createLinkedList()
    insertNode(head, 1)
    insertNode(head, 2)
    insertNode(head, 3)
    printLinkedList(head)
    
    deleteNode(head, 2)
    printLinkedList(head)
}

L'exemple de code ci-dessus crée une liste à chaînage unique contenant les données 1, 2 et 3, puis supprime le nœud avec les données 2 et imprime le résultat final de la liste à chaînage unique. Grâce aux exemples de code ci-dessus, nous avons une compréhension approfondie des principes de mise en œuvre sous-jacents des listes à lien unique dans le langage Go et maîtrisons les opérations de base des listes à lien unique. Les lecteurs Xiduo peuvent utiliser de manière flexible cette structure de données classique des listes à lien unique dans. Applications pratiques.

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!