La cabeza es un puntero a la memoria que es igual a la actual

void display(node_t **head) {  
    struct node *current = (*head);
    if((*head) == NULL) {  
        printf("List is empty \n");  
        return;  
    }  
    
while(current != NULL) {  
   printf("current->n=%d\n", current->next);  //0 1 2
   printf("head->n=%d\n", head->next);        // 0 0 0 if we assign current to its next 
   current = current->next;                // should it affect to the head because we are
                                           //because we are assigning memory address to another 
}  
}

Código de muestra usando vars estáticas:

int *head,*current,c=1;
head=&c;
current=&c;
(*current)++;

La cabeza y la corriente cambiarán en este caso

-1
Mad Tom 28 sep. 2020 a las 16:33

2 respuestas

La mejor respuesta
while(current != NULL) {  
   printf("current->n=%d\n", current->n);  //0 1 2
   printf("head->n=%d\n", head->n);        // 0 0 0 if we assign current to its next 
   current = current->next;                // should it affect to the head because we are
                                           //because we are assigning memory address to another 
}

Ignorando la nomenclatura inconsistente (¿es n o next?), head y current son objetos separados; nada de lo que hagas en current afectará a {{X5 }}.

Podría ayudar si hacemos un dibujo. Supongamos que tiene una lista con tres nodos (no sé cómo se ve la estructura de su nodo, así que esto es bastante genérico):

+---+---+      +---+---+       +---+---+
|   |   |----->|   |   |------>|   |   |---|||
+---+---+      +---+---+       +---+---+

Tiene un puntero al primer elemento (lo llamaremos h):

      +---+      +---+---+      +---+---+       +---+---+
   h: |   |----->|   |   |----->|   |   |------>|   |   |---|||
      +---+      +---+---+      +---+---+       +---+---+

Su argumento head en la función display apunta a h:

      +---+
head: |   |
      +---+
        |
        V
      +---+      +---+---+      +---+---+       +---+---+
   h: |   |----->|   |   |----->|   |   |------>|   |   |---|||
      +---+      +---+---+      +---+---+       +---+---+

Inicializa current con el valor de *head, que es el valor de h, por lo que current apunta al primer nodo de la lista:

      +---+
head: |   |
      +---+
        |
        V
      +---+      +---+---+      +---+---+       +---+---+
   h: |   |----->|   |   |----->|   |   |------>|   |   |---|||
      +---+      +---+---+      +---+---+       +---+---+
                   ^
                   |
                 +---+
        current: |   |
                 +---+

Cada vez que ejecutas

current = current->next

Que configurará current para que apunte al siguiente elemento de la lista:

      +---+
head: |   |
      +---+
        |
        V
      +---+      +---+---+      +---+---+       +---+---+
   h: |   |----->|   |   |----->|   |   |------>|   |   |---|||
      +---+      +---+---+      +---+---+       +---+---+
                                  ^
                                  |
                                +---+
                       current: |   |
                                +---+

      +---+
head: |   |
      +---+
        |
        V
      +---+      +---+---+      +---+---+       +---+---+
   h: |   |----->|   |   |----->|   |   |------>|   |   |---|||
      +---+      +---+---+      +---+---+       +---+---+
                                                  ^
                                                  |
                                                +---+
                                       current: |   |
                                                +---+

Nada de lo que hagas para current afectará a head; son objetos separados.

int *head,*current,c=1;
head=&c;
current=&c;
while(True):
    current++;

En este caso, la cabeza y la corriente cambiarán.

Sí, porque está asignando explícitamente un nuevo valor tanto a head como a current; sin embargo, current++ no tendrá ningún efecto en head.

Y esto no es válido en C, por cierto, parece que comenzó en C y terminó en Python.

0
John Bode 28 sep. 2020 a las 14:40

Porque en este punto aquí: struct node *current = (*head); desreferencia al jefe. Si head es una matriz de punteros de nodo, ahora la corriente apunta al primer elemento de esa matriz.

También recomendaría verificar NULL antes de eliminar la referencia, ya que de lo contrario tiene un SEGFAULT esperando que suceda.

0
TTG 28 sep. 2020 a las 14:11