Comment implémenter une liste chaînée en go

Une liste chaînée est une structure de données commune composée d'une série de nœuds, chaque nœud contenant des données et un pointeur vers le nœud suivant. Les listes chaînées peuvent être utilisées pour stocker et exploiter de grandes quantités de données, et elles offrent des performances efficaces pour l'insertion et la suppression d'éléments. En langage Go, nous pouvons utiliser des pointeurs et des structures pour implémenter des listes chaînées.

Tout d'abord, nous devons définir une structure de nœuds, qui contient des données et un pointeur vers le nœud suivant. En langage Go, vous pouvez utiliser des structures pour définir des nœuds.

type Node struct {
data int
next *Node
}

Ensuite, nous pouvons définir une structure de liste chaînée, qui contient un pointeur vers le nœud principal de la liste chaînée.

type LinkedList struct {
head *Node
}

Dans la structure de liste chaînée, nous pouvons définir certaines méthodes pour faire fonctionner la liste chaînée. Tout d’abord, nous devons implémenter une méthode pour insérer un nœud à la fin de la liste chaînée.

func (list *LinkedList) Insert(data int) {
newNode := &Node{data: data, next: nil}
if list.head == nil {
list.head = newNode
} else {
current := list.head
for current.next != nil {
current = current.next
}
current.next = newNode
}
}

Dans cette méthode, nous créons d'abord un nouveau nœud et lui attribuons des données. Ensuite, nous vérifions si la liste chaînée est vide et, si c'est le cas, définissons le nouveau nœud comme nœud principal de la liste chaînée. Sinon, nous parcourons la liste chaînée jusqu'à ce que nous trouvions le dernier nœud, puis insérons le nouveau nœud après le dernier nœud.

Ensuite, nous pouvons implémenter une méthode pour supprimer un nœud dans la liste chaînée.

func (list *LinkedList) Delete(data int) {
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
}
}

Dans cette méthode, nous vérifions d'abord si la liste chaînée est vide, et si elle est vide, revenons directement. Nous vérifions ensuite si le nœud principal de la liste chaînée contient les données à supprimer, et si tel est le cas, définissons le nœud à côté du nœud principal comme nouveau nœud principal. Sinon, nous parcourons la liste chaînée jusqu'à ce que nous trouvions le nœud contenant les données à supprimer, puis définissons le nœud suivant de ce nœud sur le nœud suivant du nœud actuel.

Enfin, nous pouvons implémenter une méthode pour imprimer tous les nœuds de la liste chaînée.

func (list *LinkedList) Print() {
current := list.head
for current != nil {
fmt.Println(current.data)
current = current.next
}
}

Dans cette méthode, nous parcourons la liste chaînée en commençant par le nœud principal de la liste chaînée, imprimons les données de chaque nœud et pointons le nœud actuel vers le nœud suivant.

En utilisant la méthode ci-dessus, nous pouvons créer une liste chaînée et y insérer, supprimer et imprimer des nœuds.

func main() {
list := LinkedList{}
list.Insert(1)
list.Insert(2)
list.Insert(3)
list.Print() // 输出：1 2 3
list.Delete(2)
list.Print() // 输出：1 3
}

Grâce au code ci-dessus, nous pouvons voir que les opérations de création, d'insertion, de suppression et d'impression de la liste chaînée peuvent être facilement mises en œuvre. Il s'agit de la méthode de base pour implémenter des listes chaînées en langage Go.

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!