Miért nem kell a list () függvény a while ismétlésen belül legyen? (Nem értem mi tárolja magát a listát, hisz a head mutatója végig NULL marad. )
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
struct data
{
int value;
struct data *nxt;
};
struct data *head=NULL, *prev, *akt, *next;
void list()
{
akt=head;
while (akt!=NULL)
{
printf("%5d",akt->value);
akt=akt->nxt;
}
}
main()
{
char c;
int i=0,sv;
printf("Következő szám ");
scanf("%d",&sv);
while (sv>0)
{
akt=(struct data *) malloc(sizeof(struct data));
if (!akt)
{
printf("Nincs elég memória!");
return -1;
}
akt->value=sv;
akt->nxt=NULL;
if (i==0)
head=prev=akt;
else
{
prev->nxt=akt;
prev=akt;
}
printf("Következő szám ");
scanf("%d",&sv);
i++;
}
printf("\n");
list();
while ((c=getch()) !=13);
}
A program rendben lefut, csak én nem értem.
válasza:Egy láncolt listáról van szó, csak hogy tudja más is rajtunk kívül :)
Az head mutat a lánc elejére (a "fejére", ez a legelőször hozzáadott elem lesz). Az akt a bejárásnál/hozzáadásnál az aktuálisra, a next-et pedig nem használjuk sehol.
A 36. sorban a beírt értékre beállítja az akt value propertyjét, és az nxt-t ráállítja a NULL-ra. Azaz az akt változó mutat a "semmibe", tehát hozzá már nem kapcsolódik senki.
Látszik a 47. sorban hogy mindig számoljuk hogy hány bekérés történt. A 38. sorban az igaz ágba az első szám beírásánál kerülünk, hisz ekkor igaz hogy i==0. Itt az előző (prev) és a legelső (head) pointereket beállítja az akt-ra, hogy ha 1 elemből áll a lista akkor is be lehessen járni.
Namost a 2. szám beírásánál mindig a hamis ágba kerülsz majd(40. sor).
Nézzük a 2. számot, itt ugrik a majom a vízbe.
30. sorban lefoglalod a memóriát, 36-ban beállítod az értékét, 37-ben kimutatsz a semmibe. Érezhető hogy akkor ez az elem lesz majd a lánc végén valahogy, hisz ehhez nem csatlakozik majd senki. Beugrunk az else ágba. A 42. sorban a prev változó nxt-je mutat az újonnan lefoglalt memóriaterületre (akt). Tudjuk hogy a prev változó az most épp az az érték, amit elsőnek beírtunk (39. sorban jelentetted ki).
A 43. sorban a prev-et ráállítod az akt-ra, vagy magyarul: a prev változón keresztül éred majd el a legutolsó memóriafoglalás eredményét.
Menjünk a list-be:
Az akt-ot ráállítod a head-re. A head a legelőször hozzáadott elem lesz, azaz ennek az elemnek a nxt-je mutat majd valahova. (Azt úgy mellékesen tudjuk, hogy a prev változóban a legutoljára hozzáadott érték van, tehát ha átírnád az akt=head-et akt=prev-re, akkor egyedül a legutolsó számot látnád.)
A 14. sorban azt figyeljük hogy az akt null pointer-e. Itt azért nem akt->nxt van mert pointerekre mutató pointerekről van szó. Feltételezzük hogy az akt mutat valahova, és a 16. sorban kiírjuk az értéket amire mutatunk, majd a 17. sorban az akt-ot ráállítod arra a pointerre ami a saját adattagja az akt-nak. Ha ez egy null, akkor majd a következő iterációnál igaz lesz a feltétel, és kilép a while.
Valahogy így működik
Kapcsolódó kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!