Sunteți pe pagina 1din 4

Liste liniare simple inlantuite

Explicatii
Exemplu:
#include<iostream>
#include<conio.h>
using namespace std;
struct llsi
{ int info;
llsi *urm;};
llsi *prim, *ultim;
void creare(llsi *&prim, int val)
{
llsi *c;
if (!prim)
{prim=new llsi;
prim->info=val;
prim->urm=NULL;
ultim=prim;}
else
{c=new llsi;
c->info=val;
c->urm=NULL;
ultim->urm=c;
ultim=c;}
}
void listare(llsi *prim)
{
llsi *c;
c=prim;
while(c)
{
cout<<c->info<<" ";
c=c->urm;}
}
main()
{
int i,n;
cout<<"Introduceti numarul de noduri al listei:"; cout<<endl;
cout<<"n="; cin>>n;

cout<<"Lista se creaza !"<<endl;


for(i=1; i<=n; i++)
{creare(prim,i);}
cout<<"Elementele listei create sunt: ";
listare(prim); cout<<endl;
getch();
}

Explicatii:
#include<iostream>
#include<conio.h>
//Permite folosirea comenzi getch()
using namespace std;
struct llsi /*Declaram o clasa cu numele llsi doar struct este keyword ,in loc
de llsi puteam sa punem si cuvantul gogoasa si tot ar fi mers cu conditia
desigur sa inlocuim in program toate cuvintele llsi cu gogoasa*/
{ int info; /*Declaram o variabila de tip int numita info in care se va
stoca o valoare numerica dorita oricare*/
llsi *urm;}; /*Declaram un pointer urm de tip llsi , asta inseamna ca urm
va avea aceeasi structura ca llsi , insemnand ca pointerul urm va avea la
randul sau int info si llsi *urm.
In pointerul urm vom stoca adresa de memorie a urmatorului element din
lista */
llsi *prim, *ultim; /*Declaram 2 pointeri de tip llsi , la fel vor avea aceesi
structura cu llsi.
Primul pointer prim va retine adresa de memorie a primului element din lista.
Al 2 lea pointer va retine adresa de memorie a celulei de memorie
anterioare*/
void creare(llsi *&prim, int val) /*Declaram o functie cu numele create cu 2
parametri , llsi *&prim (*& este necesar * este pentru ca prim este pointer
iar & pentru ca ne trebuie adresa de memorie de pointerul declarat global
prim) si int val in care se vor pasa valorile dorite*/
{
llsi *c; /*Declaram un pointer de lucru c in el vom efectua operati de
atribuire*/
if (!prim) /*Verificam daca prim are o locatie de memorie NULL
(neocupata) aceasta ramura a lui if se va executa o singura data la inceputul
listei pentru primul element */
{prim=new llsi; /*prim va pointa catre o noua locatie de memorie
creata prin comanda new llsi , llsi va insemna de care tip de locatie de
memorie.

Aceasta locatie de memorie va fi de tipul (sau structura ,de aceea numele de


struct) precizata mai sus anume llsi , va avea la randul sau int info si llsi
*urm */
prim->info=val; /*Lui prim I se va atribui o valoare val in campul info
al acesteia*/
prim->urm=NULL; /*In campul urm a lui prim I se atribuie valoarea
NULL deoarece acesta este primul element din lista */
ultim=prim;} /*Pointerul ultim va pointa catre prim*/
else /*Aceasta ramura se va executa pentru toate celelalte apelari ale
acestei functii (adica nu prima data)*/
{c=new llsi; /*Creeam o noua locatie de memorie de tip llsi si un
pointer catre aceasta*/
c->info=val; /*In noua locatie de memorie creata atribuim valoarea
dorita*/
c->urm=NULL;
/*Nu stim sau nu am atribuit o locatie de memori
urmatoare astfel ii vom atribui valoarea de NULL*/
ultim->urm=c;
/*Cum aceasta ramura a executiei se va efectua doar
in cazul in care aceasta functie a fost apelata cel putin o a 2 oara , astfel
avem deja un element anterior alocat .
Adresa catre acel element anterior va fi retinuta in pointerul ultim acesta
este rolul lui defapt , dar fara acesta instructiune pur si simplu nu exista o
legatura intre elementele anterioare ale listei si elementul nou din c.
In cadrul campului urm al elementului anterior (reprezentat de ultim->urm) ii
vom atribui adresa de memorie a elementului curent unde am retinut
informatia(adica c) , astfel elemental anterior se va putea lega de cel curent.
*/
ultim=c;} /*ultim va retine adresa de memorie a elementului curent
c , astfel la o noua parcurgere , elementul anterior va fi relevant deoarece
elementul curent va fi cel anterior.
Cu alte cuvinte fara aceasta instructiune nu ar exista elemente de mijloc ,
primul element va fi legat catre cel curent */
}
void listare(llsi *prim)
{
llsi *c; //Creem un pointer de lucru c de tip llsi
c=prim; /*c va pointa catre primul element din lista , care a fost retinut in
pointerul prim*/
while(c) //Cat timp c nu este NULL (nealocat) executa . . .
{
cout<<c->info<<" "; /*Afiseaza informatia continuta in c->info*/
c=c->urm;} /*c va pointa catre urmatoarea locatie de memorie
continuta in campul urm.
Astfel la urmatoarea parcurgere , c->info se va referi la urmatorul element*/
}
main()
{

int i,n;
cout<<"Introduceti numarul de noduri al listei:"; cout<<endl;
cout<<"n="; cin>>n;
cout<<"Lista se creaza !"<<endl;
for(i=1; i<=n; i++)
{creare(prim,i);} /*Vom apela functia de creare cu 2 parametri
unul va lista care va fi utilizat doar la o prima apelare si al 2 lea in care
vom stoca o valoare dorita.
De remarcat ca modificand al doilea parametru putem avea o lista cu
orice tip de continut (numeric desigur)*/
cout<<"Elementele listei create sunt: ";
listare(prim); cout<<endl; /*Apelam functia listare pentru a afisa
continutul vom apela functia cu parametrul prim .
A se nota ca functia listare se putea scrie fara parametri si apelata la
fel fara parametri , ea functionand la fel deoarece pointerul prim este
o variabila globala , astfel parametri sunt redundanti in acest caz */
getch(); /*Opreste executia executia instructiuni urmatoare pana cand
nu se apasa o tasta oarecare*/
}