Concevoir et implémenter la structure de données de la liste chaînée dans Golang

Conception et mise en œuvre d'une structure de données de liste chaînée dans Golang

Introduction :
Une liste chaînée est une structure de données courante utilisée pour stocker une série de nœuds. Chaque nœud contient des données et un pointeur vers le nœud suivant. Dans Golang, nous pouvons implémenter des listes chaînées en utilisant des structures et des pointeurs.

1. Conception et définition de la structure de la liste chaînée
   Dans Golang, nous pouvons utiliser des structures et des pointeurs pour définir les nœuds de la liste chaînée et la structure de la liste chaînée elle-même. La structure du nœud contient un champ de données et un pointeur vers le nœud suivant.

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

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

2. Initialisation de la liste chaînée
   Lors de la création d'une liste chaînée, nous devons initialiser une liste chaînée vide. Lors de l'initialisation de la liste chaînée, le pointeur du nœud principal de la liste chaînée est vide.

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

3. Insertion dans une liste chaînée
   L'insertion dans une liste chaînée ajoute un nœud à la fin de la liste chaînée. Tout d’abord, nous devons créer un nouveau nœud et lui attribuer des données. Ensuite, nous trouvons le dernier nœud de la liste chaînée et pointons son pointeur next vers le nouveau nœud. 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
    }
}

Suppression de la liste chaînée
L'opération de suppression de la liste chaînée trouvera et supprimera le nœud spécifique dans la liste chaînée. Tout d'abord, nous devons trouver le nœud précédent du nœud à supprimer et définir son pointeur next sur le pointeur next du nœud supprimé.
5. 
   

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

Parcours de la liste chaînée
L'opération de parcours de la liste chaînée imprimera tous les nœuds de la liste chaînée.

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
}

Exemple d'utilisation de liste chaînée


rrreee🎜Conclusion : 🎜Dans Golang, en utilisant des structures et des pointeurs, nous pouvons facilement implémenter des structures de données de liste chaînée. Les opérations d'insertion, de suppression et de parcours des listes chaînées sont également très simples et claires, et peuvent être facilement appliquées à des problèmes 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!