if (strcmp(nouv->Name, deb->Name) < 0) /* D */
{
nouv->suiv =3D deb ;
deb =3D nouv ;
}
else /* si nouv->Name est alphabetiquement plus grand */
{
if (nouv !=3D deb)
{
for (a =3D deb ; a->suiv !=3D NULL && strcmp(a->suiv->Name, nouv-
>Name) < 0 ; a =3D a->suiv) /* E */
;
nouv->suiv =3D a->suiv ;
a->suiv =3D nouv ;
}
}
bkup =3D nouv ;
if (i > 0)
{
printf("\nNbr d'enregistrements : %d\n", i) ;
printf("\nAfficher la liste ? (o/n)\n") ;
rep =3D getc(stdin) ;
if (rep =3D=3D 'o')
{
HEADER(s)
for (a =3D deb, ; a !=3D NULL ; a =3D a->suiv)
printf("\n %-22s\t%ld\n", a->Name, a->qte) ;
}
for (a =3D deb ; a !=3D NULL ; a =3D nouv)
{
nouv =3D a->suiv ;
free(a) ;
}
}
/* A */
listele *deb, *bkup, *nouv, *a ; /* A */
*deb, *bkup, *nouv, *a sont des pointeurs pour accueillir des donn=E9es
de type listele...pour l=92instant, ils ne pointent pas vers une adresse
ne m=E9moire, ils sont simplement d=E9clar=E9s pour recevoir des donn=E9es =
de
type pr=E9d=E9finies.
/* B */
nouv =3D bkup =3D deb ;
Ici nouv et bkup recoivent l=92adresse en m=E9moire de deb
/* C */
deb->suiv =3D NULL ;
deb->suiv recoit l=92adresse nulle
/* D */ si nouv est alphabetiquement plus petit que deb. Comment est-
ce que la comparaison peut se faire lors de la premi=E8re saisie? Ce que
j=92ai compris jusqu=92=E0 pr=E9sent sur les pointeurs et variable non
initialis=E9s c=92est qu=92ils peuvent contenir n=92importe quoi. Et ici nu=
l
part deb a =E9t=E9 initialis=E9, il a seulement re=E7u un espace m=E9moire =
=E0 la
ligne A mais malloc n=92initialise pas, =E7a serait plut=F4t calloc et
encore ce n=92est pas pour des caract=E8res...alors, je me pose la
question avec quoi nouv est compar=E9?
/* E */ strcmp(a->suiv, nouv->name) < 0
L=92auteur :
=AB Il faut effectuer la comparaison avec l=92element suivant et non avec
l=92element actuel, afin de v=E9rifier avant quel element de la liste il
faut ins=E9rer le nouveau. Cela serait impossible si on compara=EEt nouv-
>name et a->name. En effet, on ne disposerait plus alors de l=92adresse
n=E9cessaire du pr=E9d=E9cesseur dans la liste. En proc=E9dant ainsi on ins=
=E8re
le nouvel =E9l=E9ment avant le premier qui lui est alphab=E9tiquement
sup=E9rieur ou =E9gal. Pour cela on actualise de mani=E8re ad=E9quate les
pointeurs nouv->suiv et a->suiv.=BB
Je ne suis pas s=FBre de comprendre : =ABon ne disposerait plus alors de
l=92adresse n=E9cessaire du pr=E9d=E9cesseur dans la liste=BB
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Antoine Leca
jean mike écrivit :
/* A */
listele *deb, *bkup, *nouv, *a ; /* A */
<couic>
/* B */ nouv = bkup = deb ;
Ici nouv et bkup recoivent l’adresse en mémoire de deb
Donc quand on écrit dans deb->xxx, on écrit en même temps dans nouv->xxx et dans bkup->xxx
/* C */
deb->suiv = NULL ;
deb->suiv recoit l’adresse nulle
Et de même pour nouv->suiv et pour bkup->suiv !
/* D */ si nouv est alphabetiquement plus petit que deb. Comment est- ce que la comparaison peut se faire lors de la première saisie?
Cf. supra: en fait ils sont identiques, deb->Name et nouv->Name sont un seul et unique objet.
/* E */ Je ne suis pas sûre de comprendre : «on ne disposerait plus alors de l’adresse nécessaire du prédécesseur dans la liste»
Fait un dessin sur une feuille de papier, et suis les opérations une par une : une liste chaînée est très facile à visualiser. La symbologie habituelle, c'est une boîte pour un objet structure (alloué par malloc()), et une flèche pour un pointeur. Au départ tu as
Crayon et gomme, il n'y rien de mieux en algorithmique !
Antoine
jean mike écrivit :
/* A */
listele *deb, *bkup, *nouv, *a ; /* A */
<couic>
/* B */
nouv = bkup = deb ;
Ici nouv et bkup recoivent l’adresse en mémoire de deb
Donc quand on écrit dans deb->xxx, on écrit en même temps dans nouv->xxx
et dans bkup->xxx
/* C */
deb->suiv = NULL ;
deb->suiv recoit l’adresse nulle
Et de même pour nouv->suiv et pour bkup->suiv !
/* D */ si nouv est alphabetiquement plus petit que deb. Comment est-
ce que la comparaison peut se faire lors de la première saisie?
Cf. supra: en fait ils sont identiques, deb->Name et nouv->Name sont un
seul et unique objet.
/* E */
Je ne suis pas sûre de comprendre : «on ne disposerait plus alors de
l’adresse nécessaire du prédécesseur dans la liste»
Fait un dessin sur une feuille de papier, et suis les opérations une par
une : une liste chaînée est très facile à visualiser. La symbologie
habituelle, c'est une boîte pour un objet structure (alloué par
malloc()), et une flèche pour un pointeur. Au départ tu as
Ici nouv et bkup recoivent l’adresse en mémoire de deb
Donc quand on écrit dans deb->xxx, on écrit en même temps dans nouv->xxx et dans bkup->xxx
/* C */
deb->suiv = NULL ;
deb->suiv recoit l’adresse nulle
Et de même pour nouv->suiv et pour bkup->suiv !
/* D */ si nouv est alphabetiquement plus petit que deb. Comment est- ce que la comparaison peut se faire lors de la première saisie?
Cf. supra: en fait ils sont identiques, deb->Name et nouv->Name sont un seul et unique objet.
/* E */ Je ne suis pas sûre de comprendre : «on ne disposerait plus alors de l’adresse nécessaire du prédécesseur dans la liste»
Fait un dessin sur une feuille de papier, et suis les opérations une par une : une liste chaînée est très facile à visualiser. La symbologie habituelle, c'est une boîte pour un objet structure (alloué par malloc()), et une flèche pour un pointeur. Au départ tu as