Directives d'explication visuelle nécessaires à la reprise du code de la structure de données de la liste liée?

la liste ressemblait à: xxx

Nous avons inversé chaque pièce de la liste xxx

donc, maintenant commence maintenant est à la fin, et commence maintenant. Nous pouvons examiner la liste des différents points et voir: xxx

Consultez Ce site Pour une représentation visuelle.
Il ressemble à une bonne explication de codeProject ici aussi (voir Technique 3). < / p>

J'ai fait un diagramme dans DOT que je pense expliquera graphiquement ce qui se passe:

< / P>

Lien vers une image de taille complète

Et voici la source de point (bâclée) au cas où quelqu'un se soucie: xxx

OK, voici ma tentative de rendre la réponse de Valya encore plus claire (bien que je pensais que c'était très bien déjà):

Disons que nous avons cette liste: p> xxx pré> nous Commencez au premier nœud, A code>, qui contient un pointeur ( suivant code>) sur B code>: p> xxx pré >

la ligne suivant = actuel-> suivant; code> définit suivant code> à B code> (assez simple). La ligne suivante actuelle-> suivante = résultat; code> Est-ce que: p> xxx pré>

alors nous avons résultat = actuel; code> qui Définit résultat code> à A code> (à nouveau, assez simple). Et enfin, nous avons le tout important actuel = suivant; code>, lequel définit actuel code> sur B code>. P>

donc sur le Série d'itération suivante de la boucle tandis que Suivant code> défini sur B code>, résultat code> défini sur A code> et actuel code> défini sur B code>, nous commençons: p> xxx pré>

alors nous le faisons à nouveau: p> xxx

Une fois que nous avons eu le dernier élément de la liste liée ( E code> dans cet exemple), cela se produit: p> xxx pré>

maintenant em>, étant donné actuel code> est NULL, la boucle tandis que la boucle se termine et nous sommes laissés avec: p>

*headRef = result;

voir ici pour un bon explication. Voici l'extrait:

public class List {
    private class Node {
        int data;
        Node next;
    }
   private Node head;

   public void reverse() {
      if (head == null) return;
      Node prev = null,curr = head,next = null;
      while (curr != null) {
         next = curr.next;
         curr.next = prev;
         prev = curr;
         curr = next;
      }
      head = prev;
   }
}

The list:
==========
1->2->3->4->5
------------------------------------------------------------------
Running of the code:
============================
At start:
**********
head = 1;
prev = null,curr = 1, next = null
1st iteration of while loop:
******************************
next = 2;
2->3->4->5
curr.next = null;
1->null
prev = 1;
1->null
curr = 2;
2->3->4->5
2nd iteration of while loop:
******************************
next = 3
3->4->5
curr.next = 1
2->1->null
prev = 2
2->1->null
curr = 3
3->4->5
3rd iteration of while loop:
******************************
next = 4
4->5
curr.next = 2
3->2->1->null
prev = 3
3->2->1->null
curr = 4
4->5
4th iteration of while loop:
******************************
next = 5
5->null
curr.next = 3
4->3->2->1->null
prev = 4
4->3->2->1->null
curr = 5
5->null
5th iteration of while loop:
******************************
next = null
null
curr.next = 4
5->4->3->2->1->null
prev = 5
5->4->3->2->1->null
curr = null
There is no 6th iteration and the while loop terminates since 
curr is null and the check is for curr != null.
last statement: 
==================
head = prev
This statement leaves the list reversed with referencing head with the reversed node prev 
to become the new head node.