Les Listes Chainees

8/10/2019 Les Listes Chainees

1/18

Les listes chanes

Par lexou

www.openclassrooms.com

Licence Creative Commons 6 2.0Dernire mise jour le 24/08/2011
http://www.openclassrooms.com/http://www.openclassrooms.com/


2/18

Sommaire

2Sommaire ...........................................................................................................................................3Les listes chanes ............................................................................................................................3Gnralits sur les listes chaines ...................................................................................................................................

5Dclaration en C d'une liste chaine .................................................................................................................................6Manipuler les listes chaines (1/2) ....................................................................................................................................6Ajouter un lment ......................................................................................................................................................................................................

8Exercices (1/2) ..................................................................................................................................................................10Manipuler les listes chaines (2/2) ..................................................................................................................................11Supprimer un lment en tte ...................................................................................................................................................................................11Supprimer un lment en fin de liste .........................................................................................................................................................................12Rechercher un lment dans une liste ......................................................................................................................................................................12Compter le nombre d'occurrences d'une valeur ........................................................................................................................................................13Recherche du i-me lment ....................................................................................................................................................................................13Rcuprer la valeur d'un lment .............................................................................................................................................................................14Compter le nombre d'lments d'une liste chan ....................................................................................................................................................14Effacer tous les lments ayant une certaine valeur .................................................................................................................................................

15Exercices (2/2) ................................................................................................................................................................16Q.C.M. .............................................................................................................................................................................18Partager .....................................................................................................................................................................................................................

2/19

http://fr.openclassrooms.com/


3/18


4/18

Vous avez sur ce s chma la reprsentation que l'on pourrait faire d'un tableau et d'une liste chane. Chacune de cesreprsentations possde ses avantages et inconvnients. C'est lors de l'criture de votre programme que vous devez vous poserla question de savoir laquelle des deux mthodes es t la plus intressante.

Dans un tableau, la taille es t connue, l'adress e du premier lment auss i. Lorsque vous dclarez un tableau, la variablecontiendra l'adresse du premier lment de votre tableau.Comme le stockage est contigu, et la taille de chacun des lments connue, il est pos sible d'atteindre directement la case id'un tableau.Pour dclarer un tableau, il faut connatre sa taille.Pour supprimer ou ajouter un lment un tableau, il faut crer un nouveau tableau et supprimer l'ancien. Ce n'est engnral pas visible par l'utilisateur, mais c'est ce que reallocva souvent faire. L'adresse du premier lment d'untableau peut changer aprs un realloc, ce qui est tout fait logique puisque reallocn'aura pas forcement la

pos sibilit de trouver en mmoire la place nces saire et contigu pour allouer votre nouveau tableau. reallocva doncchercher une place suffisante, recopier votre tableau, et supprimer l'ancien.

Dans une liste chane, la taille est inconnue au dpart, la liste peut avoir autant d'lments que votre mmoire le permet.Il est en revanche impossible d'accder directement l'lment i de la liste chaine.Pour ce faire, il vous faudra traverser les i-1 lments prcdents de la liste.Pour dclarer une liste chane, il suffit de crer le pointeur qui va pointer sur le premier lment de votre liste chane,aucune taille n'est donc spcifier.Il est possible d'ajouter, de supprimer, d'intervertir des lments d'une liste chane sans avoir recrer la liste en entier,mais en manipulant simplement leurs pointeurs.

Chaque lment d 'une liste chane est compos de deux parties :

la valeur que vous voulez stocker,l'adresse de l'lment suivant, s'il existe.S'il n'y a plus d'lment suivant, alors l'adress e sera NULL, et dsignera le bout de la chane.

Voil deux schmas pour expliquer comment s e passent l'ajout et la suppres sion d 'un lment d 'une liste chane. Remarquez lesymbole en bout de chane qui signifie que l'adresse de l'lment s uivant ne pointe sur rien, c'est--dire sur NULL.

Les listes chanes 4/19



5/18

Comme vous vous en doutez certainement maintenant, la liste chane est un type s tructur. Nous en avons termin avec cesquelques gnralits, nous allons pouvoir passer la dfinition d'une structure de donnes nous permettant de crer cettefameuse liste !

Vous pouvez essayer d'imaginer quoi va ress embler la structure liste_chainee: si vous avez compris le principe,vous en tes capables. Je vous invite donc crire sur un papier vos ides que vous pourrez ensuite comparer aursultat que je vais fournir un peu plus bas !

Dclaration en C d'une liste chaine

Vous vous demandez srement de quel type sera l'lment de la liste chane. A ceci je ne peux rpondre que... vous de voir. Eneffet, vous pouvez crer des listes chanes de n'importe quel type d'lments : entiers, caractres, s tructures, tableaux, voirmme d'autres listes chanes... Il vous est mme poss ible de combiner plusieurs types dans une mme liste.Allez : vous avez assez patient, voici la dclaration d'une liste simplement chane d'entiers :

Code : C

#include typedefstructelement element;structelement{

intval; structelement *nxt;};typedefelement*llist;

On cre le type element qui est une s tructure contenant un entier (val) et un pointeur sur lment (nxt), qui contiendra l'adressede l'lment suivant. Ensuite, il nous faut crer le type llist (pour linked list= liste chane) qui est en fait un pointeur sur le typeelement. Lorsque nous allons dclarer la liste chane, nous devrons dclarer un pointeur sur element, l'initialiser NULL, pour

pouvoir ensuite allouer le premier lment. N'oubliez pas d'inclure stdlib.h afin de pouvoir utiliser la macro NULL. Comme vousallez le constater, nous avons juste cre le type llist afin de simplifier la dclaration.

Voil comment dclarer une liste chane (vide pour l'ins tant) :Code : C

#include




6/18

typedefstructelement element;structelement{ intval; structelement *nxt;};typedefelement*llist;

intmain(intargc, char**argv){ /* Dclarons 3 listes chanes de faons diffrentes maisquivalentes */ llist ma_liste1 =NULL; element *ma_liste2 =NULL; structelement *ma_liste3 =NULL;

return0;}

Il est important de toujours initialiser la liste chane NULL. Le cas chant, elle sera considre comme contenant aumoins un lment. C'est une erreur frquente. A garder en mmoire donc. De manire gnrale, il est plus sage detoujours initialiser vos pointeurs.

Manipuler les listes chaines (1/2)

Maintenant que nous savons comment dclarer une liste chane, il serait intressant d'apprendre ajouter des lments dans

cette liste, ainsi que de lire ce qu'elle contient. C'est ce que nous allons tudier dans cette premire partie sur la manipulation deslistes chanes. Je vous invite ess ayer par vous-mmes de programmer ces quelques fonctions basiques permettant demanipuler les listes . Dans tous les cas (ou presque), nous renverrons la nouvelle liste, c'est--dire un pointeur sur elementcontenant l'adresse du premier lment de la liste.

Ajouter un lment

Lorsque nous voulons ajouter un lment dans une liste chane, il faut savoir o l'insrer. Les deux ajouts gnriques des listeschanes sont les ajouts en tte, et les ajouts en fin de liste. Nous allons tudier ces deux moyens d'ajouter un lment uneliste.

Ajouter en tte

Lors d'un ajout en tte, nous allons crer un lment, lui assigner la valeur que l'on veut ajouter, puis pour terminer, raccorder cetlment la liste pass e en paramtre. Lors d 'un ajout en tte, on devra donc as signer nxt l'adresse du premier lment de laliste pass en paramtre. Visualisons tout ceci sur un schma :

Code : C




7/18

llist ajouterEnTete(llist liste, intvaleur){ /* On cre un nouvel lment */ element*nouvelElement =malloc(sizeof(element));

/* On assigne la valeur au nouvel lment */ nouvelElement->val =valeur;

/* On assigne l'adresse de l'lment suivant au nouvel lment

*/ nouvelElement->nxt =liste;

/* On retourne la nouvelle liste, i.e. le pointeur sur lepremier lment */ returnnouvelElement;}

C'est l'ajout le plus simple des deux. Il suffit de crer un nouvel lment puis de le relier au dbut de la liste originale. Si l'original

est , (vide) c'est NULL qui sera ass igne au champ nxt du nouvel element. La liste contiendra dans ce cas-l un seul lment.

Ajouter en fin de liste

Cette fois-ci, c'est un peu plus compliqu. Il nous faut tout d 'abord crer un nouvel lment, lui assigner sa valeur, et mettrel'adresse de l'lment suivant NULL. En effet,, comme cet lment va terminer la liste nous devons signaler qu'il n'y a plusd'lment s uivant. Ensuite, il faut faire pointer le dernier lment de liste originale sur le nouvel lment que nous venons decrer. Pour ce faire, il faut crer un pointeur temporaire sur element qui va se dplacer d'lment en lment, et regarder si cetlment est le dernier de la liste. Un lment sera forcment le dernier de la liste si NULL est assign son champ nxt.

Code : C

llist ajouterEnFin(llist liste, intvaleur){ /* On cre un nouvel lment */ element*nouvelElement =malloc(sizeof(element));

/* On assigne la valeur au nouvel lment */ nouvelElement->val =valeur;

/* On ajoute en fin, donc aucun lment ne va suivre */ nouvelElement->nxt =NULL;

if(liste ==NULL) {

/* Si la liste est vide il suffit de renvoyer l'lmentcr */ returnnouvelElement; } else {




8/18

/* Sinon, on parcourt la liste l'aide d'un pointeurtemporaire et onindique que le dernier lment de la liste est reli au nouvellment */ element*temp=liste; while(temp->nxt !=NULL) { temp =temp->nxt;

} temp->nxt =nouvelElement; returnliste; }}

Comme vous pouvez le cons tater, nous nous dplaons le long de la liste chane grce au pointeur temp. Si l'lment point partemp n'est pas le dernier (temp->nxt != NULL), on avance d'un cran (temp = temp->nxt) en assignant temp l'adresse de l'lmentsuivant. Une fois que l'on est au dernier lment, il ne reste p lus qu' le relier au nouvel lment.

Si vous pensez avoir bien saisi ces deux fonctions, je vous invite pas ser la partie suivante, dans laquelle je vais vousproposer quelques exercices . Le premier sera fondamental puisqu'il nous permettra d'afficher le contenu d 'une liste chane.

Exercices (1/2)

Exercice n1

Vous allez maintenant pouvoir vous tester. Votre miss ion, si vous l'acceptez, est de coder la fonction afficherListe. Vous devrezparcourir la liste jusqu'au bout et afficher toutes les valeurs qu'elle contient. Voici son prototype :

Code : C

voidafficherListe(llist liste);

Correction

Secret (cliquez pour afficher)

Code : C

voidafficherListe(llist liste){ element *tmp =liste; /* Tant que l'on n'est pas au bout de la liste */ while(tmp !=NULL) { /* On affiche */ printf("%d ", tmp->val); /* On avance d'une case */ tmp =tmp->nxt; }}

Alors ? Qu'est ce que a donne ? Si vous avez russi ce premier exercice, vous tes sur la bonne voie.Quelques explications pour ceux qui ont eu quelques difficults : la seule chose faire est de se dplacer le long de la listechane grce au pointeur tmp. Si ce pointeur tmp pointe sur NULL, c'est que l'on a atteint le bout de la chane, sinon c'estque nous sommes sur un lment dont il faut afficher la valeur.

Exercice n2


http://fr.openclassrooms.com/http://www.v3.siteduzero.com/tutoriel-3-36245-les-listes-chainees.html?pdf=1#


9/18

Un deuxime exercice utilisant trois fonctions que nous avons vues jusqu' prsent :

ajouterEnTeteajouterEnFinafficherListe

Vous devez crire le main permettant de remplir et afficher la liste chane ci-dess ous . Vous ne devrez utiliser qu'une seule boucle

for.

Code : Console

10 9 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10

Aucune autre directive pour cet exercice qui ncess ite peut-tre un peu de logique, mais ques tion technique vous devriez tre aupoint .

Correction


Code : C

intmain(intargc, char**argv){ llist ma_liste =NULL; inti;

for(i=1;i


10/18

des lments , trie sa liste, etc...) grce aux fonctions de la bibliothque. Dans certains cas, il lui faudra tester si la liste est vide, ilutilisera par exemple :

Code : C

if(estVide(ma_liste)) {

printf("La liste est vide"); } else { afficherListe(ma_liste); }

A vous donc pour cette fonction !

Correction


Code : C

intestVide(lliste liste){ if(liste ==NULL) { return1; } else {

return0; }}

Ou bien, en condens :Code : C

intestVide(llist liste){ return(liste ==NULL)?1:0;

}

Alors ? Rien de plus s imple, non ?Si la liste est NULL, il ne contient aucun lment, elle est donc vide. Sinon, c'est qu'elle contient au minimum un lment.

Nous voil au bout de cette premire srie d'exercices. Dans la section s uivante, nous allons voir plein de fonctions p luscomplexes permettant de manipuler nos listes chanes !

Manipuler les listes chaines (2/2)

Cette fois, a va monter d 'un cran niveau difficult. Nous allons voir tout un tas de fonctions , pour supprimer des lments ,rechercher un lment... Je vous conseille si vous n'avez pas tout compris de revenir un peu en arrire, de faire des ess ais avecvotre compilateur prfr, parce que tout ce que nous allons voir fonctionne toujours sur le mme principe. Je cons idrerais ceque j'ai prcdemment montr comme acquis. Cette partie va se drouler comme ceci : j'explique l'algorithme gnral de la fonction

puis je donne son code comment.




11/18

Prts ? On y va !

Supprimer un lment en tte

Il s'agit l de supprimer le premier lment de la liste. Pour ce faire, il nous faudra utiliser la fonction free que vous connaissez

certainement. Si la liste n'est pas vide, on s tocke l'adresse du premier lment de la liste aprs suppress ion (i.e. l'adresse du 2melment de la liste originale), on supprime le premier lment, et on renvoie la nouvelle liste. Attention quand mme ne paslibrer le premier lment avant d'avoir stock l'adresse du second, sans quoi il sera impossible de la rcuprer.

Code : C

llist supprimerElementEnTete(llist liste){ if(liste !=NULL) { /* Si la liste est non vide, on se prpare renvoyerl'adresse del'lment en 2me position */

element*aRenvoyer =liste->nxt; /* On libre le premier lment */ free(liste); /* On retourne le nouveau dbut de la liste */ returnaRenvoyer; } else { returnNULL; }}

Supprimer un lment en fin de liste

Cette fois-ci, il va falloir parcourir la liste jusqu' son dernier lment, indiquer que l'avant-dernier lment va devenir le dernier dela liste et librer le dernier lment pour enfin retourner le pointeur s ur le premier lment de la liste d'origine.

Code : C

llist supprimerElementEnFin(llist liste){

/* Si la liste est vide, on retourne NULL */ if(liste ==NULL) returnNULL;

/* Si la liste contient un seul lment */ if(liste->nxt ==NULL) { /* On le libre et on retourne NULL (la liste estmaintenant vide) */ free(liste); returnNULL; }

/* Si la liste contient au moins deux lments */

element*tmp =liste; element*ptmp =liste; /* Tant qu'on n'est pas au dernier lment */ while(tmp->nxt !=NULL) { /* ptmp stock l'adresse de tmp */ ptmp =tmp;




12/18

/* On dplace tmp (mais ptmp garde l'ancienne valeur de tmp*/ tmp =tmp->nxt; } /* A la sortie de la boucle, tmp pointe sur le dernier lment,et ptmp surl'avant-dernier. On indique que l'avant-dernier devient la fin dela liste

et on supprime le dernier lment */ ptmp->nxt =NULL; free(tmp); returnliste;}

Rechercher un lment dans une liste

Le but du jeu cette fois est de renvoyer l'adresse du premier lment trouv ayant une certaine valeur. Si aucun lment n 'esttrouv, on renverra NULL. L'intrt est de pouvoir, une fois le premier lment trouv, chercher la prochaine occurrence enrecherchant partir de elementTrouve->nxt. On parcourt donc la liste jusqu'au bout , et ds qu'on trouve un lment quicorrespond ce que l'on recherche, on renvoie son adresse.

Code : C

llist rechercherElement(llist liste, intvaleur){ element *tmp=liste; /* Tant que l'on n'est pas au bout de la liste */ while(tmp !=NULL) {

if(tmp->val ==valeur) { /* Si l'lment a la valeur recherche, on renvoie sonadresse */ returntmp; } tmp =tmp->nxt; } returnNULL;}

Compter le nombre d'occurrences d'une valeur

Pour ce faire, nous allons utiliser la fonction prcdente permettant de rechercher un lment. On cherche une premireoccurrence : si on la trouve, alors on continue la recherche partir de l'lment s uivant, et ce tant qu'il reste des occurrences dela valeur recherche. Il est aus si pos sible d'crire cette fonction sans u tiliser la prcdente bien entendu, en parcourantl'ensemble de la liste avec un compteur que l'on incrmente chaque fois que l'on pas se s ur un lment ayant la valeurrecherche. Cette fonction n 'est pas beaucoup plus complique, mais il est intressant d'un point de vue algorithmique derutiliser des fonctions pour simplifier nos codes .

Code : C

intnombreOccurences(llist liste, intvaleur){ inti =0;

/* Si la liste est vide, on renvoie 0 */ if(liste ==NULL)




13/18

return0;

/* Sinon, tant qu'il y a encore un lment ayant la val =valeur */ while((liste =rechercherElement(liste, valeur)) !=NULL) { /* On incrmente */ liste =liste->nxt;

i++; } /* Et on retourne le nombre d'occurrences */ returni;}

Recherche du i-me lment

Pour le coup, c'est une fonction relativement simple. Il suffit de se dplacer i fois l'aide du pointeur tmp le long de la listechane et de renvoyer l'lment l'indice i. Si la liste contient moins de i lment(s), alors nous renverrons NULL.

Code : C

llist element_i(llist liste, intindice){ inti; /* On se dplace de i cases, tant que c'est possible */ for(i=0; inxt; }

/* Si l'lment est NULL, c'est que la liste contient moins dei lments */ if(liste ==NULL) { returnNULL; } else { /* Sinon on renvoie l'adresse de l'lment i */ returnliste; }}

Rcuprer la valeur d'un lment

C'est une fonction du mme style que la fonction estVide. Elle sert "masquer" le fonctionnement interne l'utilisateur. Il suffitsimplement de renvoyer l'utilisateur la valeur d'un lment. Il faudra renvoyer un code d'erreur entier si l'lment n'existe pas (laliste es t vide), c'est donc vous de dfinir une macro selon l'utilisation que vous voulez faire des listes chanes. Dans ce code,

je considre qu'on ne travaille qu'avec des nombres entiers pos itifs, on renverra donc -1 pour une erreur. Vous pouvez mettre icin'importe quelle valeur que vous tes srs de ne pas utiliser dans votre liste. Une autre so lution consiste renvoyer un pointeursur int au lieu d'un int, vous laissant donc la pos sibilit de renvoyer NULL.

Code : C

#define ERREUR -1intvaleur(llist liste){




14/18

return((liste ==NULL)?ERREUR:(liste->val));}

Compter le nombre d'lments d'une liste chan

C'est un algorithme vraiment s imple. Vous parcourez la liste de bout en bout et incrmentez d'un pour chaque nouvel lment quevous trouvez. Cet algorithme n'ayant aucun intrt au point o nous en sommes, je vais en profiter pour vous faire dcouvrir unnouveau type d'algorithme. Jusqu' maintenant, nous n 'avons utilis que des algorithmes itratifs qui consistent boucler tantque l'on n'est pas au bout. Nous allons voir qu'il existe des algorithmes que l'on appellent rcursifs et qui consistent en fait demander une fonction de s 'appeler elle-mme. Attention : il faudrait un b ig-tuto complet pour tout expliquer propos desalgorithmes rcursifs, ce n'est vraiment que pour vous montrer que ce genre de chos es existe que je vais les utiliser dans les deux

prochains codes .

Avant tout, je pens e qu'un petit point d'explication s 'impose.Pour crer un algorithme rcursif, il faut connatre la condition d'arrt (ou condition de sortie) et la condition de rcurrence. Il fauten fait vous imaginer que votre fonction a fait son office pour les n-1 lments suivants, et qu'il ne reste plus qu' traiter ledernier lment. Lisez le code s uivant. N'ayez pas peur s i ceci vous semble obscur, ce n'est pas essentiel pour utiliser les listeschanes. Maintenant, je suis sr que vous tes au point et vous pouvez donc de manire itrative crer peu prs tout ce qui

peut se faire.

Code : C

intnombreElements(llist liste){ /* Si la liste est vide, il y a 0 lment */ if(liste ==NULL) return0;

/* Sinon, il y a un lment (celui que l'on est en train detraiter)

plus le nombre d'lments contenus dans le reste de la liste */ returnnombreElements(liste->nxt)+1;}

Effacer tous les lments ayant une certaine valeur

Pour cette dernire fonction, nous allons encore une fois utiliser un algorithme rcursif. Mme si la rcursivit vous semble treune notion complexe (et a l'est srement), elle simplifie grandement les algorithmes dans certains cas, et dans celui-ci tout

particulirement. Je vous donne le code titre indicatif, vous pourrez vous mme recoder cette fonction avec un algorithmeitratif si vous le voulez.

Code : C

llist supprimerElement(llist liste, intvaleur){ /* Liste vide, il n'y a plus rien supprimer */ if(liste ==NULL) returnNULL;

/* Si l'lment en cours de traitement doit tre supprim */ if(liste->val ==valeur) { /* On le supprime en prenant soin de mmoriserl'adresse de l'lment suivant */ element*tmp =liste->nxt; free(liste);




15/18

/* L'lment ayant t supprim, la liste commencera l'lment suivant

pointant sur une liste qui ne contient plus aucun lment ayant lavaleur recherche */ tmp =supprimerElement(tmp, valeur); returntmp; } else

{ /* Si l'lement en cours de traitement ne doit pas tresupprim,alors la liste finale commencera par cet lment et suivra uneliste ne contenant

plus d'lment ayant la valeur recherche */ liste->nxt =supprimerElement(liste->nxt, valeur); returnliste; }}

Exercices (2/2)

Exercice n1

Voil... Maintenant, vous tes des as en matire de liste chanes, j'en suis s r. Je vous propos e donc quelques exercices. Lepremier sera de coder de manire itrative la fonction nombreElements dont je vous rappelle le proto type :

Code : C

intnombreElements(llist liste);

C'est un exercice qui ne devrait pas vous poser de problmes : bonne chance.


Code : C

intnombreElements(llist liste){ intnb =0; element*tmp =liste;

/* On parcours la liste */

while

(tmp !=NULL) { /* On incrmente */ nb++; tmp =tmp->nxt; } /* On retourne le nombre d'lments parcourus */ returnnb;}

C'est auss i simple que a. On parcourt s implement la liste tant que l'on n'est pas arriv au bout, et on incrmente le compteurnb que l'on renvoie pour finir.

Exercice n2

Nous allons maintenant crire une fonction permettant d'effacer compltement une liste chane de la mmoire. Je vous propose




16/18

d'crire avec un algorithme itratif dans un premier temps, puis une seconde fois grce un algorithme rcursif. Dans le premiercas, vous devez parcourir la liste, stocker l'lment suivant, effacer l'lment courant et avancer d'une case. A la fin la liste estvide, nous retournerons NULL.


Code : C

llist effacerListe(llist liste){ element*tmp =liste; element*tmpnxt;

/* Tant que l'on n'est pas au bout de la liste */ while(tmp !=NULL) { /* On stocke l'lment suivant pour pouvoir ensuiteavancer */ tmpnxt =tmp->nxt; /* On efface l'lment courant */ free(tmp);

/* On avance d'une case */ tmp =tmpnxt; } /* La liste est vide : on retourne NULL */ returnNULL;}

Code : C

llist effacerListe(llist liste){ if(liste ==NULL) { /* Si la liste est vide, il n'y a rien effacer, onretourneune liste vide i.e. NULL */ returnNULL; } else { /* Sinon, on efface le premier lment et on retourne lereste de laliste efface */ element *tmp; tmp =liste->nxt;

free(liste); returneffacerListe(tmp); }}

Et voil : vous en s avez maintenant un peu plus s ur ce que sont les listes chanes. Vous pourrez amliorer ceci en utilisant leslistes doublement chanes, qui sont en fait une liste d'lments qui pointent la fois s ur l'lment s uivant, mais aussi surl'lment prcdent, ce qui vous permet de revenir en arrire plus facilement qu'avec les listes s implement chanes . Vous pouvezcomplter votre bibliothque avec des fonctions de tri, de recherche de minimum, de maximum et bien d'autre choses...

Passons maintenant un petit QCM, afin de vrifier que vous avez tout saisi !

Q.C.M.

Le premier QCM de ce cours vous est offert en libre accs.Pour accder aux suivants




17/18

Connectez-vousInscrivez-vousUne erreur s'est gliss e dans le code suivant :

Code : C

typedefstructelement element;structelement{

intval;structelement nxt;};

Il manque un typedef

Il manque une toile

Le code est juste

J'excute le programme contenant le main suivant, que va-t-il se passer ?

Code : C

intmain(intargc, char**argv){ element*ma_liste; ma_liste =ajouterEnTete(ma_liste, 12); afficherListe(ma_liste); return0;}

Rien du tout

a ne compile pas : tu as mis element* la place de llist pour dclarer ma_liste

Une erreur de segmentation

Correction !

Statistiques de rponses au Q CM

Eh bien il semblerait que vous tes au point. Comme vous avez pu le cons tater, le choix d'utiliser ou non les listes chanes es tfait lors de l'implmentation de votre algorithme dans un langage. Vous devrez toujours faire des compromis.

J'avais parl d 'introduire les listes doublement chanes, ce que je vais faire maintenant pour vous permettre d'aller plus loin.L'ide est la suivante : un lment ne va plus s e compos er d'une valeur et d'une adresse, mais d'une valeur et de deux adresses :l'adresse de l'lment suivant mais auss i l'adresse de l'lment prcdent. On pourra tirer avantage de cette s pcificit pour liredes listes l'envers. Avoir l'adresse de l'lment prcdent peut s implifier les algorithmes de vos fonctions, mais tout aussi bien

les compliquer car c'est maintenant deux pointeurs qu'il faut grer lors d 'un ajout ou d'une suppression.

Nous sommes loin d'avoir cod une bibliothque complte, mais vos connaissances vous permettent maintenant de continuerseuls et d 'implmenter toutes sortes de fonctions.

Merci d'avoir lu ce tutoriel jusqu'au bout. Si une ou plusieurs erreurs s'y sont g liss es (ce n'est pas exclu), prvenez-moi par MP.

Remerciements Nicolaset Mlegpour avoir vrifi, test ce tutoriel et permis de ce fait sa parution.

Je sais que le s ujet des lis tes chaines est souvent abord lors de l'entre dans les tudes suprieures, auss i jeserais ravis d'apprendre qu'un professeur vous a redirig sur mon tutoriel, s i tel est le cas n'hsitez pas me le fairesavoir par message !

A bientt !


http://fr.openclassrooms.com/http://www.v3.siteduzero.com/tutoriel-15-36245.htmlhttp://www.v3.siteduzero.com/inscriptionhttp://www.v3.siteduzero.com/connexion


18/18

Partager

http://www.v3.siteduzero.com/tutoriel-rss/36245.xml

Documents

Les Listes Chainees