Apprenez à implémenter une liste chaînée unique dans le langage Go à partir de zéro

Apprenez la méthode d'implémentation d'une liste chaînée unique dans le langage Go à partir de zéro

Lors de l'apprentissage des structures de données et des algorithmes, la liste chaînée unique est l'une des structures de données de base et importantes. Cet article expliquera comment utiliser le langage Go pour implémenter une liste à chaînage unique et aidera les lecteurs à mieux comprendre cette structure de données à travers des exemples de code spécifiques.

Qu'est-ce qu'une liste à chaînage unique

Une liste à chaînage unique est une structure de données linéaire composée d'une série de nœuds. Chaque nœud contient des données et un pointeur vers le nœud suivant. Le pointeur du dernier nœud pointe vers null.

Opérations de base des listes à lien unique

Les listes à lien unique prennent généralement en charge plusieurs opérations de base, notamment l'insertion, la suppression et la recherche. Nous allons maintenant mettre en œuvre ces opérations étape par étape.

Créer une structure de nœuds

Tout d'abord, nous devons définir la structure de nœuds d'une liste à chaînage unique :

type Node struct {
    data interface{}
    next *Node
}

Dans la structure ci-dessus, le champ data est utilisé pour stocker les données du nœud , next Le champ est un pointeur vers le nœud suivant. data字段用于存储节点的数据，next字段是指向下一个节点的指针。

初始化链表

接下来，我们需要定义一个LinkedList

Initialiser la liste chaînée

Ensuite, nous devons définir une structure LinkedList pour représenter une liste chaînée unique et fournir quelques méthodes de fonctionnement de base :

type LinkedList struct {
    head *Node
}

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

Insérer un nœud

Insérer en tête d'un liste chaînée unique Méthodes de nœuds :

func (list *LinkedList) Insert(data interface{}) {
    newNode := &Node{data: data}
    if list.head == nil {
        list.head = newNode
    } else {
        newNode.next = list.head
        list.head = newNode
    }
}

Supprimer des nœuds

Méthodes pour implémenter la suppression de nœuds avec des données spécifiées :

func (list *LinkedList) Delete(data interface{}) {
    if list.head == nil {
        return
    }

    if list.head.data == data {
        list.head = list.head.next
        return
    }

    prev := list.head
    current := list.head.next

    for current != nil {
        if current.data == data {
            prev.next = current.next
            return
        }

        prev = current
        current = current.next
    }
}

Trouver des nœuds

Méthodes pour implémenter des nœuds qui trouvent des données spécifiées :

func (list *LinkedList) Search(data interface{}) bool {
    current := list.head
    for current != nil {
        if current.data == data {
            return true
        }
        current = current.next
    }
    return false
}

Exemple complet

Voici un exemple complet exemple de code, montre comment créer une liste à lien unique, insérer des nœuds, supprimer des nœuds et rechercher des nœuds :

package main

import "fmt"

type Node struct {
    data interface{}
    next *Node
}

type LinkedList struct {
    head *Node
}

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

func (list *LinkedList) Insert(data interface{}) {
    newNode := &Node{data: data}
    if list.head == nil {
        list.head = newNode
    } else {
        newNode.next = list.head
        list.head = newNode
    }
}

func (list *LinkedList) Delete(data interface{}) {
    if list.head == nil {
        return
    }

    if list.head.data == data {
        list.head = list.head.next
        return
    }

    prev := list.head
    current := list.head.next

    for current != nil {
        if current.data == data {
            prev.next = current.next
            return
        }

        prev = current
        current = current.next
    }
}

func (list *LinkedList) Search(data interface{}) bool {
    current := list.head
    for current != nil {
        if current.data == data {
            return true
        }
        current = current.next
    }
    return false
}

func main() {
    list := NewLinkedList()
    
    list.Insert(1)
    list.Insert(2)
    list.Insert(3)
    
    fmt.Println(list.Search(2)) // Output: true
    
    list.Delete(2)
    
    fmt.Println(list.Search(2)) // Output: false
}

Résumé 🎜🎜 Grâce à l'exemple de code ci-dessus, nous comprenons comment utiliser le langage Go pour implémenter les opérations de base d'un élément à lien unique. liste. Après avoir maîtrisé la méthode de mise en œuvre des listes à chaînage unique, les lecteurs peuvent apprendre davantage des structures de données plus complexes et des algorithmes associés pour approfondir leur compréhension et leur application de l'informatique. J'espère que cet article sera utile aux lecteurs, merci d'avoir lu ! 🎜

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!