Colectie de elemente omogene, putem opta pentru a le gestiona, sa lucram cu

un masiv, vector sau matrice.

Masivele au dezavantaje. Daca le prezicam ca fiind statice, vom aloca mai multe
elemente decat avem nevoie.
int v[20];
int *x=new int[n];
Daca alocam dinamic, prin utilizarea unui pointer, putem aloca exact cate
elemente avem nevoie.
Dezavantaj. In cazul redimensionarii trebuie facute dezalocare si realocare.
Listele liniare alta modalitate de a gestiona colectiile de elemente omogene.
Elementele sunt stocate la rand. Nu sunt stocate intr-o zona plina de memorie.
Putem avea un element undeva la o anume adresa.
Valoare + Adresa elementului urmator
Ultimul element trebuie sa aiba drept adresa NULL
Avantaj: Mai putina memorie de gestionat.
Dezavantaj: Mai multa memorie de gestionat. OBVIOUSLY!!! *headdesk*
Prelucrarea este mai greoaie.
In functie de modul de inlantuire a elementelor putem avea mai multe liste:
-lista liniara simplu inlantuita: pastreaza valoarea sa si adresa elementului
urmator.
-lista liniara circulara: adresa ultimului element echivaleaza cu adresa primului
element.
-lista liniara dublu inlantuita: fiecare element va pastra atat adresa elementului
precedent cat si a celui urmator, pe langa valoarea prezenta.
Pentru gestionarea listei inlantuite
struct Nod
{
int val;
Nod*next;
};
Pentru lista dublu inlantuita
struct Nod
{int val;
Nod*prev,*next;
};
Principalele operatii.
-crearea listei care se face prin adaugare, element cu element.
-adaugare element
-parcurere lista
-cautare element
-modificare element
-stergere element

-stergere lista
//initializarea pointerului cu 0
Nod*prim=NULL;
Adaugarea
Adaugarea
Adaugarea
Adaugarea

unui
unui
unui
unui

element
element
element
element

la inceputul listei
la sfarsitul listei
in ordinea de sortare
inainte sau dupa un element

In cazul in care lista e vida si adaug un element, acel element va deveni si primul
element al listei.
void AdaugareInceput(Nod* prim, int valnoua)
{
if (prim==NULL)
{
Nod*nou=new Nod;
nou->val=valnoua;
nou->adr=NULL;
prim=nou;
}
/* In cazul in care lista nu e vida si adaug un element */
else
{
Nod*nou=new Nod;
nou->val=valnoua;
nou->adr=prim;
prim=nou;
}
}
Rezultatul finit pentru ambele situatii:
void AdaugareInceput(Nod*& prim, int valnoua)
{
Nod*nou=new Nod;
nou->val=valnoua;
nou->adr=prim;
prim=nou;
}
In cazul in care intr-o astfel de lista avem multe prelucrari de facut, ceea ce
implica multe parcurgeri, putem pastra adresa ultimului element.
Pointerul in sine il transmitem prin referinta. Ampersantul motherfuckers!.
Am deja elemente in lista. Lista mea e adresata prin pointerul prim. Vreau sa
adaug la sfarsit. Cum procedam. Alocam spatiu pentru noul element pe care il
creem. Ii dam valoarea dorita. Dupa care trebuie sa stabilim legatura intre
ultimul element si noul element adaugat. Aceasta lista trebuie parcursa pana ne
pozitionam pe ultimul element.
Adresa elementului urmator are valoarea null

t->adr=NULL
Vom face parcurgerea in lista pana ce aceasta conditie va fi indeplinita.

Functia in sine:
void (AdaugSfarsit(Nod*&prim, int valnoua)
{
Nod*nou=new Nod;
nou->val=valnoua;
nou->adr=NULL;
if (prim==NULL)
prim=nou;
else
{Nod*t=prim;
while(t->adr!=NULL)
t=t->adr;
t->adr=nou;
}
}
t->val=valcaut
void AdaugDupaElem(Nod*prim, int valnoua, int valcaut)
{
Nod*t=prim;
while(t!=NULL&&t->val!=valout)
t=t->adr;
if (t==NULL)
cout<<Elementul cautat nu exista;
else
{
Nod*nou=new Nod;
nou->val=valnoua;
nou->adr=t->adr;
t->adr=nou;
}
}
void AdaugInainteElem(Nod*&prim, int valnoua, int valcaut)
{
if (prim!=NULL&&prim->val=valcaut)
//elementul cautat este pe prima pozitie
{
Nod*nou=new Nod;
nou->val=valnoua;

nou->adr=prim;
prim=nou;
}
else
{
//elementul cautat exista sau nu exista
Nod*t=prim;
while(t->adr!=NULL && t->adr->val!=valcout)
t=t->adr;
if (t->adr==NULL)
cout<<Elementul cautat nu exista;
else
{
Nod*nou=next Nod;
nou->val=valnoua;
nou->adr=t->adr;
t->adr=nou;
}
}
}