inversion de la liste chaînée Golang

Golang est l'un des langages de programmation les plus populaires actuellement. Sa simplicité et son efficacité sont profondément appréciées des développeurs. Dans Golang, les listes chaînées sont largement utilisées dans diverses structures de données. Cependant, le fonctionnement des listes chaînées est relativement complexe et une attention particulière doit être accordée à l'exactitude des opérations des pointeurs. Dans cet article, nous verrons comment inverser une liste chaînée à l'aide de Golang.

Qu'est-ce qu'une liste chaînée ?

En informatique, une liste chaînée est une structure de données qui est une collection de nœuds. Chaque nœud contient des données et un pointeur vers le nœud suivant. Sa caractéristique est qu'il peut insérer et supprimer des nœuds de manière efficace, mais accéder de manière aléatoire à un nœud nécessite de parcourir toute la liste chaînée.

La structure des données de la liste chaînée est la suivante :

type Node struct {
    data int
    next *Node
}

où data sont les données stockées dans le nœud, et next pointe vers le prochain pointeur vers le nœud. Lorsque next est égal à nil, cela signifie qu'il s'agit du dernier nœud de la liste chaînée. data是节点存储的数据，next是指向下一个节点的指针。当next等于nil时，表示这是链表的最后一个节点。

链表的遍历和插入操作

遍历链表的基本操作是从链表的头节点开始遍历，直到链表的尾节点。遍历过程中可以对每个节点进行一定的操作，例如输出节点的值。下面是遍历链表的例子：

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

对于插入操作，我们需要先找到要插入的位置，然后修改指针的指向。例如，在链表的第三个节点后插入一个新节点，代码如下：

func insert(head *Node, pos int, value int) *Node {
    p := head
    for i := 1; i < pos && p != nil; i++ {
        p = p.next
    }
    if p == nil {
        return head
    }
    newNode := &Node{data: value}
    newNode.next = p.next
    p.next = newNode
    return head
}

链表的反转

反转链表是指将链表中的节点顺序翻转，即原来的第一个节点变为最后一个节点，原来的最后一个节点变为第一个节点。反转链表的过程需要涉及到链表中节点之间指针的反转。下面是反转链表的实现代码：

func reverseList(head *Node) *Node {
    if head == nil || head.next == nil {
        return head
    }
    var prev *Node
    curr := head
    for curr != nil {
        next := curr.next
        curr.next = prev
        prev = curr
        curr = next
    }
    return prev
}

首先，我们判断链表是否为空或者只有一个节点，这种情况下不需要反转，直接返回原来的链表头节点。然后我们定义两个指针，prev指向当前节点的前一个节点，curr指向当前节点。我们从头节点开始遍历链表，每次循环将当前节点的next指针指向其前一个节点，然后将prev和curr

Opérations de parcours et d'insertion de listes chaînées

L'opération de base de parcours d'une liste chaînée est de commencer le parcours du nœud principal de la liste chaînée au nœud de queue du lien liste. Pendant le processus de parcours, certaines opérations peuvent être effectuées sur chaque nœud, telles que la sortie de la valeur du nœud. Voici un exemple de parcours d'une liste chaînée :

func main() {
    head := &Node{data: 1}
    head.next = &Node{data: 2}
    head.next.next = &Node{data: 3}
    head.next.next.next = &Node{data: 4}
    fmt.Println("Original list:")
    printList(head)
    head = reverseList(head)
    fmt.Println("
Reversed list:")
    printList(head)
}

Pour l'opération d'insertion, nous devons d'abord trouver la position à insérer, puis modifier le pointage du pointeur. Par exemple, insérez un nouveau nœud après le troisième nœud dans la liste chaînée, le code est le suivant :

Original list:
1 2 3 4
Reversed list:
4 3 2 1

Inversion de la liste chaînée

Inverser la liste chaînée signifie changer l'ordre des nœuds dans la liste chaînée Flip, c'est-à-dire que le premier nœud d'origine devient le dernier nœud et le dernier nœud d'origine devient le premier nœud. Le processus d'inversion d'une liste chaînée implique d'inverser les pointeurs entre les nœuds de la liste chaînée. Voici le code d'implémentation pour inverser la liste chaînée : #🎜🎜#rrreee#🎜🎜#Tout d'abord, nous déterminons si la liste chaînée est vide ou n'a qu'un seul nœud. Dans ce cas, il n'est pas nécessaire d'inverser, et le. Le nœud principal de la liste chaînée d'origine est renvoyé directement. Ensuite, nous définissons deux pointeurs, prev pointe vers le nœud précédent du nœud actuel et curr pointe vers le nœud actuel. Nous parcourons la liste chaînée en commençant par le nœud principal, et chaque boucle pointe le pointeur next du nœud actuel vers son nœud précédent, puis pointe le prev et le curr pointe vers Ensuite, déplacez un nœud jusqu'à ce que toute la liste chaînée soit parcourue. Enfin, le nœud de tête de liste inversé est renvoyé. #🎜🎜##🎜🎜#Le code du test est le suivant : #🎜🎜#rrreee#🎜🎜#Le résultat de sortie est : #🎜🎜#rrreee#🎜🎜#Résumé #🎜🎜##🎜🎜#Cet article présente la liste chaînée dans les opérations Golang Basic et comment inverser une liste chaînée. Bien que le fonctionnement des listes chaînées soit légèrement compliqué, il présente les avantages d'une insertion et d'une suppression efficaces et est largement utilisé dans divers scénarios. Lors de l'utilisation de listes chaînées, une attention particulière doit être accordée à l'exactitude des pointeurs pour éviter des problèmes tels que des fuites de mémoire. #🎜🎜#

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!