liste chaînée et Pointeurs en C

Question

Salut les gars j'apprends C et je vais avoir du mal à comprendre ce code:

struct node { 
int data; 
int key; 
struct node *next; 
}; 

struct node *head = NULL; 
struct node *current = NULL; 

//delete a link with given key 
struct node* delete(int key) { 

//start from the first link 
struct node* current = head; 
struct node* previous = NULL; 

//if list is empty 
if(head == NULL) { 
    return NULL; 
} 

//navigate through list 
while(current->key != key) { 

    //if it is last node 
    if(current->next == NULL) { 
    return NULL; 
    } else { 
    //store reference to current link 
    previous = current; 
    //move to next link 
    current = current->next; 
    } 
} 
//found a match, update the link 
if(current == head) { 
    //change first to point to next link 
    head = head->next; 
} else { 
    //bypass the current link 
    previous->next = current->next; 
}  

return current; 
} 

Le code fonctionne réellement, il supprime les éléments de la liste chaînée en C mais Je ne comprends pas comment, si nous ne sommes pas toucher la variable struct tête (Voici ma peine):

//bypass the current link 
    previous->next = current->next; 

Je comprends le code mais je ne comprends pas comment la tête variable va changer si nous ne fais pas la tête = quelque chose.

De plus, la façon dont il est posible d'avoir deux variables avec le même nom (courant)

Merci

Btw J'ai trouvé le code ici: https://www.tutorialspoint.com/data_structures_algorithms/linked_list_program_in_c.htm

Answer 1

La façon dont le code est publié ne fonctionne pas, car il manque effectivement la suppression du nœud initial dans le pointeur head. Cependant, vous avez omis du code qui résout apparemment le problème. Voici le code de l'delete d'origine:

//found a match, update the link 
if(current == head) { 
    //change first to point to next link 
    head = head->next; 
} else { 
    //bypass the current link 
    previous->next = current->next; 
} 

C'est là le code ajuste le pointeur de tête après la suppression. Le seul problème avec ce code est qu'il n'appelle jamais free n'importe où dans le corps du tutoriel, mais malheureusement, des erreurs comme celle-là sont communes à la fois sur les sites web gratuits et dans les livres.

Voici une implémentation qui fait la même chose avec un double pointeur:

struct node* delete(int key) { 
    struct node** ptrCurrent = &head; 
    while (*ptrCurrent) { 
     if ((*ptrCurrent)->key == key) { 
      struct node* tmp = *ptrCurrent; 
      *ptrCurrent = (*ptrCurrent)->next; 
      free(tmp); 
      break; 
     } 
     ptrCurrent = &((*ptrCurrent)->next); 
    } 
} 

Answer 2

Pour une struct a-> b les accès que est stocké dans b dans struct a. Cela signifie que la ligne current = current-> next est en effet en train de dire que le courant réglé est égal à ce qui est stocké dans la variable suivante dans le courant struct. En d'autres termes, passez à l'élément suivant de la liste.

Answer 3

Pour la ligne

previous->next = current->next; 

La variable previous a l'adresse de l'élément précédent dans la liste liée. Il peut avoir l'adresse de head comme n'importe quel autre article.

Vous venez de définir l'élément suivant est celui derrière. Similaire à:

Vous n'avez pas besoin de changer head si vous supprimez un élément de la liste (sauf le premier - le head et le second).