Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Interrogations sur les structures et liste chainées

1 réponse
Avatar
jean mike
#define CDESIGN 5
#define CQTE 10

typedef struct art3
{
char Name[CDESIGN];
long qte ;
struct art3 *suiv ;
} listele ;

listele *deb, *bkup, *nouv, *a ; /* A */

if ((deb =3D malloc(listele) =3D=3D NULL))
{
printf("\nPas de memoire dispo.\n") ;
exit(EXIT_FAILURE) ;
}

i =3D 0 ;
nouv =3D bkup =3D deb ; /* B */
deb->suiv =3D NULL ; /* C */

do
{
printf("\nEnregistrement no. %d\n", i+1) ;
printf("\nDesignation (5 caract. max., \"0\" pour quitter : \n") ;
nbcar =3D ReadTxt(Bufftxt, CDESIGN, 1) ;
strncpy(nouv->Name, Buffer, nbcar+1) ;

if ((strcmp(nouv->Name, "0"))
{
printf("\nQuantite :\n") ;
nbcar =3D ReadTxt(Buffdigits, CQTE, 2) ;
nouv->qte =3D ReadDigit(Buffdigits) ;

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 ((nouv =3D malloc(sizeof(listele))) =3D=3D NULL)
{
printf("\nPlus de memoire\n") ;
i++ ;
break ;
}
i++ ;
}
else
bkup =3D nouv ;

} while (strcmp(bkup->Name, "0")) ;

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

1 réponse

Avatar
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


deb-------
nouv-------
bkup--------
+---------+
->| |
| suiv---------->NULL
| |
+---------+

Au troisième tour, tu auras

deb-------
nouv---
+------+ +------+ +------+ +------+
->| | ->| | /->| | /->| |
| suiv-->??? | suiv--/ | suiv--/ | suiv-->NULL
| | | | | | | |
+------+ +------+ +------+ +------+

Crayon et gomme, il n'y rien de mieux en algorithmique !


Antoine