Gestion de liste simplement chaînée Complément au Chap 11 Delannoy

Transcription

1 Gestion de liste simplement chaînée Complément au Chap 11 Delannoy Objectifs: Maîtriser une structure de donnée dynamique Plan: Rappel sur les pointeurs Interface d un module de gestion de listes Analyse de la fonction "ajouter un élément" Analyse de function "retirer un élément"

2 Rappel: comment fonctionnent les pointeurs? void fn1(float * p) { float val; if(p) { val = *p; *p = val + 2. ; } }... float x = 10.; fn1(&x) x a maintenant la valeur

3 Rappel: comment fonctionnent les pointeurs? void fn2(float ** p) { float * adr; if(p) { adr = *p; if(adr) *p = adr + 2 ; } }... float t[]= {3.,6.,9.}; float *tp = t ; fn2(&tp) (*tp) a maintenant la valeur

4 Gestion d une liste simplement chaînée Contexte d un module de gestion MULTI-liste On travaille sur une liste particulière précisée avec sa tête de liste Ajouter un élément à une liste donnée Enlever un élément à une liste donnée Etc Variantes A et B détaillées plus loin Contexte d un module gérant une seule liste Le pointeur de tête de liste reste caché dans le module opaque (But: Simplicité de l interface)

5 Analyse de la fonction "ajouter un élément" Remarque: La liste n'est pas triée, il suffit d'ajouter le nouvel en tête de liste. Pseudo-code: int num... * suivant identificateur de chaque de la liste (clef) Lien vers l ' suivant dans la liste Allouer dynamiquement un nouvel En cas d'échec Quitter le programme Le nouvel indique l'ancienne tête de liste comme suivant La tête de liste indique que le nouvel est en tête de liste

6 Ajouter : les 2 Variantes MULTI-liste La fonction "ajouter" a besoin de connaitre l'information de tête de liste pour pouvoir ajouter un : La fonction doit modifier la variable "tête de liste" car sa valeur change quand on ajoute un nouvel au début de la liste. LES DEUX VARIANTES: A) Utiliser un pointeur sur la variable tête de liste pour pouvoir la modifer depuis l'intérieur de la fonction B) Renvoyer la nouvelle valeur de tête de liste pour mettre à jour la variable dans une affectation

7 Ajouter : les 2 Variantes MULTI-liste (2) A) Utiliser un pointeur sur la variable tête de liste : static * tete_de_liste = NULL; int id = 1; element_ajouter_a( &tete_de_liste, id); B) Renvoyer et affecter la nouvelle valeur de tête de liste : static * tete_de_liste = NULL; int id = 1; tete_de_liste = element_ajouter_b( tete_de_liste, id);

8 VARIANTE element_ajouter_a() 1 void element_ajouter_a ( ** p_tete, int num) 2 { 3 * nouveau = NULL; 4 5 if (!( nouveau = (*) malloc (sizeof()))) 6 { 7 printf ("Pb d'allocation dans %s\n", func ); 8 exit (EXIT_FAILURE); 9 } /* initialisation de la structure */ 12 nouveau->num = num; /* chaînage du nouvel en tete de liste */ nouveau->suivant = *p_tete; 18 *p_tete = nouveau; Th09a.8 }

9 Le but de cette fonction est d'allouer dynamiquement un et de l'ajouter en tete d'une liste d's void element_ajouter_a ( ** p_tete, int num ) le parametre formel p_tete reçoit l'adresse de la variable tete_de_liste. Son type est: ** équivalent à (associativité DG): ( *) * adresse d'un... pointeur sur un

10 p_tete tete_de_liste NULL element_ajouter_a ( p_tete.) variables globales ou créés dynamiquement paramètres et variables créés sur la pile

11 le pointeur nouveau reçoit l'adresse de l' alloué dynamiquement * nouveau = NULL; if (!( nouveau = (*) malloc (sizeof()))) affectation de l'adresse renvoyée par malloc condition équivalente à : ( nouveau == NULL ) { } printf ("Pb d'allocation dans %s\n", func ); exit (EXIT_FAILURE); message d'erreur + fin du programme si malloc renvoie NULL

12 Si l'allocation s'est bien passée, les champs du nouvel ont des valeurs quelconques ; il faut les initialiser correctement: /* initialisation de la structure */ nouveau->num... = num; nouveau champ num

13 L' pointé par nouveau est installé comme nouvelle tete de liste: 1) l'ancienne tête de liste est "accrochée" à la suite du nouvel élément nouveau->suivant = * p_tete ;

14 nouveau->suivant = * p_tete ; *p_tete NULL suivant nouveau->suivant p_tete nouveau

15 2) La nouvelle tête de liste est maintenant le nouvel élément. Il faut donc modifier la variable de tete de liste qui se trouve en dehors de la fonction, ce qui est fait avec le pointeur p_tete : *p_tete = nouveau;

16 *p_tete = nouveau ; *p_tete NULL suivant p_tete nouveau

17 Situation mémoire après l'exécution de element_ajouter_a( ) tete_de_liste NULL suivant

18 VARIANTE element_ajouter_b() 1 * element_ajouter_b ( * tete, int num) 2 { 3 * nouveau = NULL; 4 5 if (!( nouveau = (*) malloc (sizeof()))) 6 { 7 printf ("Pb d'allocation dans %s\n", func ); 8 exit (EXIT_FAILURE); 9 } /* initialisation de la structure */ 12 nouveau->num = num; /* chaînage du nouvel en tete de liste */ nouveau->suivant = tete ; 18 return nouveau; Th09a.18 }

19 nouveau->suivant = tete ; tete_de_liste NULL suivant nouveau->suivant tete nouveau

20 Analyse de la fonction "retirer un élément" Remarques: un parcours de liste est nécessaire pour trouver l' à retirer (cas d'un seul retrait de la liste). On doit aussi mémoriser l'adresse de l'élément qui précède celui à enlever pour mettre à jour le chaînage Pseudo-code: Si X est en tête de liste Mettre à jour la variable tête de liste Libérer l'espace mémoire de l' X Sinon Rechercher X dans le reste de la liste Si X est trouvé Relier l' précédent directement à l' suivant. Libérer l'espace mémoire de l' X Fin_Si Fin_Si

21 retirer : les 2 Variantes MULTI-liste A) Utiliser un pointeur sur la variable tête de liste : static * tete_de_liste= NULL; int id_x = ; element_retirer_a( &tete_de_liste, id_x); B) Renvoyer la nouvelle valeur de tête de liste : static * tete_de_liste= NULL; int id_x = ; tete_de_liste = element_ajouter_b( tete_de_liste, id_x);

22 1 void element_retirer_a ( ** p_tete, int num) 2 { 3 * tete = *p_tete; 4 if (tete) // liste non-vide 5 { if(tete->num == num) 6 { *p_tete = tete->suivant; 7 free (tete); 8 } 9 else 10 { * precedent = tete; 11 while ((precedent->suivant!= NULL) && 12 (precedent->suivant->num!= num )) // recherche 13 precedent = precedent->suivant; if (precedent->suivant!= NULL) // trouvé! 17 { 18 * a_retirer = precedent->suivant ; 19 precedent->suivant = precedent->suivant->suivant; 20 free (a_retirer); 21 } 22 } Th09a } 24 } VARIANTE element_retirer_a()

23 p_tete *p_tete NULL dans element_retirer( p_tete.) variables globales ou créés dynamiquement paramètres et variables créés sur la pile

24 nous déclarons une variable locale initialisée avec l'adresse du premier de la liste: * tete = * p_tete; if (tete) { test du pointeur pour garantir que la liste n'est pas vide if (tete!= NULL) { test équivalent à celui-ci :

25 *p_tete NULL p_tete tete

26 Si le premier est l élément recherché pour être retiré de la liste, alors la tête de liste change: Pour notre exemple, le test se fait sur la valeur du champ num if(tete->num == num) { *p_tete = tete->suivant; } free (tete); Il n est pas nécessaire d affecter NULL à tete après l appel de free() car on quitte la fonction

27 *p_tete = tete->suivant *p_tete NULL Cas où l à retirer est le premier dans la liste p_tete tete

28 Si l recherché n est pas le premier, la tête de liste ne change pas. Il faut parcourir la liste: { * precedent = tete; while ((precedent->suivant!= NULL) && (precedent->suivant->num!= num ) ) } precedent = precedent->suivant; La boucle vérifie si l suivant existe et, dans l affirmative, si son champ num est DIFFERENT de celui qui est recherché Si ces 2 conditions sont remplies on passe à l'élément suivant dans la liste DEUX causes de sortie de boucle : si la recherche est positive ou si on arrive en fin de liste sans avoir trouvé l' recherché

29 Cas où l à retirer est le deuxième (identificateur 3). *p_tete NULL precedent est initialisé avec la valeur de tete p_tete tete precedent

30 precedent->suivant->num == num *p_tete NULL C est la valeur num de cet qui est testée p_tete tete precedent

31 Après la boucle de détection il faut savoir si la recherche s est passée avec succès (<=> si precedent->suivant existe). Si c'est le cas il faut modifier le chaînage: if (precedent->suivant!= NULL) { * a_retirer = precedent->suivant ; precedent->suivant = precedent->suivant->suivant; } free (a_retirer); 1) L'adresse de l à retirer est mémorisée dans a_retirer 2) on met à jour le champ suivant de l' pointé par precedent 3) liberation de l'espace mémoire à l'adresse a_retirer

32 precedent->suivant = precedent->suivant->suivant; *p_tete NULL p_tete tete precedent a_retirer

33 Situation en mémoire après l appel de element_retirer_a() tete_de_liste NULL

34 1 * element_retirer_b ( * tete, int num) 2 { 3 if (tete) // liste non-vide 5 { if(tete->num == num) 6 { * next = tete->suivant; 7 free (tete); 8 return(next); 9 } 10 else 11 { * precedent = tete; 13 while ((precedent->suivant!= NULL) && 14 (precedent->suivant->num!= num )) // recherche 15 precedent = precedent->suivant; if (precedent->suivant!= NULL) // trouvé! 18 { 19 * a_retirer = precedent->suivant ; 20 precedent->suivant = precedent->suivant->suivant; 21 free (a_retirer); 22 } 23 return(tete); 24 } 25 } Th09a } VARIANTE element_retirer_b()

35 1 Prog. void II MT & EL element_retirer_c ( ** p_tete, int num) 2 { 3 * tete = *p_tete ; 4 5 if (tete) 6 { 7 while(tete &&(tete->num == num)) 8 { 9 *p_tete = tete->suivant; 10 free (tete); 11 tete = *p_tete ; 12 } * precedent = tete; 15 while (precedent && precedent->suivant) 16 { 17 if (precedent->suivant->num == num) 18 { 19 * a_retirer = precedent->suivant ; 20 precedent->suivant = precedent->suivant->suivant; 21 free (a_retirer); 22 } 23 else 24 precedent = precedent->suivant; 25 } 26 } Th09a } Cette 3ieme VARIANTE permet d'enlever plusieurs s ayant le même champ num en un seul appel

36 Résumé Un module responsable d une seule liste, cache aussi la tête de liste dans l implémentation. Sinon, le module gère autant de liste qu on désire créer, et on indique le pointeur de tête de liste en paramètre pour désigner celle sur laquelle on travaille La tête de liste doit être éventuellement remise à jour lors de l'ajout/retrait d'un élément. La modification du pointeur de tête de liste peut être effectuée dans une fonction à l'aide d'un pointeur de pointeur ou par affectation d'une valeur retournée.