STRUCTURI DE DATE

ALOCATE STATIC ŞI DINAMIC

CĂUTAREA INFORMAŢIEI ÎN LISTE, COZI, STIVE ŞI
ARBORII BINARI

A elaborat: Morari Dumitru

Profesor : Lilia MIhalache
CUPRINSUL LUCRARII
• 1Lista.
• 1.1Operații specifice listei
• 1.2 Căutarea unui nod din listă
• 1.3 Parcurgerea listei
• 2 Stiva.
• 2.1Cum se reprezintă o stivă
• 2.2 Cum se extrag și se introduc elemente în stivă
• 3 Coada.
• 4 Arborele.
 SCOPUL LUCTRĂRII
• Începând cu a doua jumătate a secolului al XX-lea, apariţia şi dezvoltarea calculatoarelor
electronice au declanşat o nouă revoluţie în toate domeniile vieţii economice şi sociale. La baza
acestei revoluţii stau cercetările fundamentale din domeniul matematicii şi realizările din domeniul
microelectronicii.
• Diversificarea spectaculoasă a mijloacelor tehnice din domeniul microelectronicii a dus la o
dezvoltare continuă a software-ului, necesitând totodată adecvarea structurilor de date la aplicaţii
din ce în ce mai complexe. Astfel au apărut structurile de date dinamice, pe lângă cele statice şi
semistatice, care permit o alocare dinamică atât în cadrul structurii cât şi la nivelul întregii
structuri. Lista liniară ca structură de date dinamică s-a dovedit a fi utilă într-o gamă foarte variată
de aplicaţii, unde se pot obţine economie de timp şi memorie, o minimizare a numărului de
operaţii, ajungându-se la algoritmi eficienţi şi, implicit, la programe fiabile, performante.
• Foarte multe produse software care utilizează un volum mare de date folosesc structuri de
date dinamice.
• O primă problemă ce apare în prelucrarea structurilor de date este legată de reprezentarea
în memoria internă şi pe suporturile externe. Lucrarea are drept scop prezentarea câtorva
modalităţi de reprezentare, evidenţiindu-se avantajele fiecăreia în parte.
• Tipurile de date de care avem nevoie în rezolvarea diferitelor probleme fie există ca atare în
limbajul de programare ales, fie se pot declara cu ajutorul tipurilor de date elementare. În
organizarea datelor, conform logicii algoritmului de rezolvare, datele de diferite tipuri se
grupează în structuri, denumite structuri de date.
• O structură de date poate ocupa în memorie o zonă de dimensiune constantă, în care
elementele componente ocupă tot timpul execuţiei programului acelaşi loc. O astfel de
structură se numeşte statică. Alocarea de memorie făcută pentru o structură statică este o
alocare statică atât la nivelul întregii structuri, cât şi pentru fiecare componentă în parte.
• Dacă o structură de date ocupă o zonă de dimensiune constantă, dar elementele
componente ocupă un loc variabil în timpul execuţiei programului atunci o astfel de structură se
numeşte semistatică. Pentru o structură semistatică alocarea este statică la nivelul structurii şi
dinamică la nivelul componentelor,
• Dacă o structură de date ocupă în memoria internă o zonă care se alocă în timpul
execuţiei programului pe măsura nevoii de prelucrare, fără a avea o dimensiune constantă,
atunci structura este dinamică. Pentru o structură dinamică alocarea este dinamică atât la
nivelul componentelor cât şi la nivelul întregii structuri.
• Toate variabilele declarate într-o secţiune var sunt alocate static şi se numesc variabile
statice. O variabilă statică este declarată într-o secţiune var a unui bloc sub un anumit
nume, prin intermediul căruia va fi referită în cadrul acestuia, alocându-i-se memorie la
activarea blocului. Variabila va exista(va ocupa memoria alocată ei) atâta timp cât
blocul în care a fost declarată este activ.
• În urma declarării, compilatorul Pascal rezervă automat pentru fiecare variabilă
statică o zonă fixă în memoria internă RAM, alcătuită din locaţii succesive de memorie.
Mărimea acestei zone depinde de tipul variabilei: 2 octeţi pentru integer , 6 pentru real,
1 octet pentru char etc.
• Spaţiul de memorie aferent unor astfel de date se defineşte şi se rezervă la
dimensiune maximă, prestabilită, ca spaţiu propriu care nu poate fi disponibilizat şi nici
împărţit cu alte date, chiar dacă, în momentul diverselor execuţii ale programului, nu este
în întregime utilizat (rezervare statică sau la momentul compilării).
• Există două moduri de alocare a acestor structuri de date: alocare secvenţială şi
alocare înlănţuită
• Elementele listei vor fi stocate într-un tablou de înregistrări. Câmpurile unei înregistrări vor
conţine în mod specific informaţiile pe care dorim să le reprezentăm în listă.
• Memorarea listei liniare în memoria calculatorului se va realiza prin memorarea
elementelor listei în locaţii succesive de memorie, nod după nod. Se va folosi un tablou în
care vor fi reţinute elementele listei, tabloul având dimensiunea max.
• const nmax=20;
• type element=record
• câmp1:tip_info_1;
• câmp2:tip2_info_2;
• …………..
• end;
• lista=array[1..nmax] of element;
• var l:lista;
• PRIM,ULTIM:integer;
• Variabilele cu ajutorul cărora vom manipula elementele listei sunt :PRIM şi ULTIM care
identifică primul, respective ultimul element al listei.
• În cazul reprezentării înlănţuite, elementele listei nu sunt aşezate succesiv, fiind
nevoie să precizăm în mod suplimentar ordinea lor reală. Fiecare element al listei
trebuie să indice unde se află elementul următor(anterior). În acest caz va trebui
să ştim unde se află primul element al listei, pentru a avea acces apoi, pe baza
înlănţuirilor, şi la elementele următoare ale listei. De asemenea, este necesar să
ştim când nu mai există succesor(este vorba de ultimul element).
• Implementarea alocării înlănţuite se realizează cu ajutorul vectorilor. Lista va fi
un vector care va conţine informaţia ataşată nodului(de exemplu, un număr
întreg) şi adresa nodului următor. Ultimul element nu are nici un succesor; ca
urmare, vom declara o constantă, numită NUL, care va indica o intrare fictivă a
tabloului. Pentru a nu face confuzie între informaţia de adresă, care este tot de
tip integer, şi restul informaţiei memorate, vom „reboteza” tipul integer.
• Const nmax=100;
• nul=0;
• Type adresa=integer;
• nod=record
• inf:integer;
• urm:adresa;
• end;
• Pentru memorarea listei folosim un vector care are componente de tip nod, descris mai jos:
• lista=array[1..nmax] of nod;
• ocupat= array[1..nmax] of 0..1; - reţine 1 dacă componenta corespunzătoare din L memorează un nod, sau 0 în
caz contrar.
• var L:lista;
• Exemplu:
• Vectorul L: ((7,3),( , ),(5,4),(1,5),(4,0),( , ))
• Vectorul o:(1,0,1,1,1,0)
• Lista este: 7, 5, 1, 4.
• Alocarea înlănţuită necesită spaţiu suplimentar de memorie pentru gestionarea locaţiilor
libere/ocupate.

• Extragerea unui nod dintr-o listă liniară alocată înlănţuit se realizează mult mai uşor decât
extragerea unui nod dintr-o listă liniară alocată secvenţial. Pentru alocarea secvenţială o
asemenea ştergere implică în general deplasarea unei părţi din listă în locaţii diferite. O concluzie
similară se obţine în cazul inserării unui nod în cadrul unei liste liniare.

• Accesul la diferite părţi din listă este mult mai rapid în cazul alocării secvenţiale. Aşa cum am
văzut, locaţia nodului k din listă în cazul alocării secvenţiale este o funcţie liniară de k, deci
pentru a obţine accesul la acest nod se consumă un timp constant. În cazul alocării înlănţuite acest
acces necesită k iteraţii urmărind referinţele a k-1 noduri. Astfel utilizarea memoriei înlănţuite
este mai eficientă când parcurgerea listei se face secvenţial şi nu aleatoriu.

• Alocarea înlănţuită permite o mai mare flexibilitate în ceea ce priveşte reunirea a două sau mai
multor liste într-o singură listă sau desfacerea unei liste în mai multe părţi.
• Spre deosebire de variabilele statice, variabilele dinamice se alocă şi se distrug la
cererea utilizatorului; ele nu sunt declarate într-o secţiune var, deci nu se pot
identifica prin nume şi nici nu există pe toată durata activării blocului în care s-au
creat. Din acest motiv, variabilele dinamice prezintă un mare avantaj comparativ
cu cele statice, şi anume posibilitatea utilizării mult mai eficiente a memoriei.
• Variabilele dinamice se alocă dinamic într-o zonă specială, numită HEAP
care este eliberată la „distrugerea” variabilei dinamice. Neavând nume, variabilele
dinamice trebuie referite prin intermediul altor variabile, numite din acest motiv
variabile reper(sau variabile referinţă).
• Zona HEAP cuprinde, de obicei, memoria liberă rămasă în momentul
executării unui program. Dimensiunea zonei STACK şi/sau dimensiunea minimă şi
maximă a zonei HEAP pot fi specificate prin comanda MEMORY SIZES din meniul
OPTIONS sau prin directiva de compilare $M. Dimensiunea minimă implicită a
zonei HEAP este 0, iar cea maximă 640 KB.
• Variabilele reper sunt alocate static şi au ca valori adrese ale unor variabile
dinamice de un anumit tip.
 Definiţie :

O listă este o structură de date dinamică în care atât

adăugarea cât şi extragerea unui element se poate face de
pe orice poziţie.

Există mai multe tipuri de liste:

•Liste simplu înlănţuite
•Liste dublu înlănţuite
•Liste circulare
•Stive, cozi(cazuri particulare de liste)
Lista simplu înlănţuită este o structură de forma:

inf urm inf urm inf urm ........... inf nil

prim ultim

Nodurile unei liste simplu înlănţuite prezintă două zone :

informaţia adresă de
utilă legătură

Inf urm
Observaţie :
type adresa=^ nod ; Ultimul element al listei (cel aflat la adresa
nod= record ultim) conţine ca informaţie de legătură valoarea
inf :tip_informaţie; constantei predefinite nil, cu semnificaţia că după
urm : adresă; acest element nu mai există în listă nici un alt
end; element .
Var prim ,ultim :adresă

Pentru a gestiona lista se folosesc două variabile reper :

•prim care conţine adresa primului element din listă ;
•ultim care conţine adresa ultimului element din listă;
Crearea primului nod
Adăugare de noduri :
adăugare la sfârşitul listei
adăugare la începutul listei
adăugare după un nod precizat prin adresă
adăugare în faţa unui nod precizat prin adresă
Ştergerea unui nod din listă
ştergerea primului nod din listă
ştergerea ultimului nod din listă
ştergerea unui nod precizat prin valoare sau adresă
Parcurgerea listei
Căutarea unui nod în listă
1. se alocă spaţiu de memorie pentru noul nod
new (prim);
inf urm
2. se completează informaţia utilă din noul nod
write (‘dati informatia :’) ; inf nil
readln (prim^.inf) ; prim
3. se completează zona de legătură cu nil
ultim
prim^.urm:=nil;
4. se memorează adresa nodului prim în pointerul ultim
ultim:=prim

Procedure creare_prim (var prim,ultim:adresa);

begin
new (prim) ;
write (‘dati informatia :’) ;
readln (prim ^.inf) ; Observaţie :
prim ^.urm:=nil ; Lista are un singur nod. Se
folosesc doi pointeri care-i
ultim:=prim;
memorează adresa.
end;
 inf urm inf urm inf urm inf urm

inf urm inf urm inf

inf urm
nil inf nil
......
prim ultim p

1. se alocă spaţiu in heap pentru noul nod

new(p);
2. completarea informaţiei utile din nodul p
write(‘dati valoarea: ‘);
readln(p^.inf);
3. se va completa zona de legătură a nodului
p cu valoarea constantei nill
p^.urm:=nil;
4. se leagă nodul p la lista
ultim^.urm:=p;
5. se actualizează valoarea variabilei ultim cu
adresa lui p
ultim:=p;
 inf urm inf urm inf urm

inf urm inf urm inf urm ......

p inf urm q^.urm
p^.urm

inf urm

1. se alocă spaţiu în heap pentru noul nod procedure adauga_dupa(p:adresa);

new(q); var q:adresa;
2. se completează zona inf pentru noul nod begin
writeln(‘dati informatia:’); new(q);
readln(q^.inf); writeln(‘dati informatia:’);
3. se leagă noul nod la listă readln(q^.inf);
q^.urm:=p^.urm; q^.urm:=p^.urm;
p^.urm:=q; p^.urm:=q;
end;
 inf urm inf urm inf urm
inf urm inf urm inf urm ......
.....
p inf urm p^.urm
q^.urm

inf urm

q
1. se alocă spaţiu pentru noul nod q
new(q ); procedure adauga_in_fata(p:adresa);
2. se copie informaţia din nodul p în var q:adresa;
nodul q begin
q^.inf:=p^.inf; new(q);
3. se citeşte noua informaţie în p q^.inf:=p^.inf;
write(‘dati informatia: ’); write(‘dati informatia:’);
readln(p^.inf); readln(p^.inf);
4. se leagă nodul q la listă q^.urm:=p^.urm;
q^.urm:=p^.urm; p^.urm:=q;
5. se leagă nodul p de nodul q end;
p^.urm:=q;
 inf urm inf urm inf urm inf urm
inf urm inf urm ................. inf urm
nil inf nil

prim ultim ultim

q q q q q
1. se parcurge lista pentru a afla adresa
penultimului nod, adresă pe care o vom
memora în pointerul q Procedure sterge_ultim(var ultim:adresa);
q:= prim; var q:adresa;
while q^.urm<>ultim do begin
q:=q^.urm; q:=prim;
2. penultimul nod va deveni ultimul după while q^.urm<>ultim do
ştergere, deci legătura sa următoare q:=q^.urm;
devine nil q^.urm:=nil;
q^.urm:=nil; dispose(ultim);
3. se şterge fizic ultimul nod ultim:=q;
dispose(ultim); end;
4. se reactualizează valoarea pointerului
ultim
ultim:=q;
 inf urm inf urm inf urm inf urm
inf urm inf urm ................. inf urm
nil inf nil

prim ultim ultim

q q q q q
1. se parcurge lista pentru a afla adresa
penultimului nod, adresă pe care o vom
memora în pointerul q Procedure sterge_ultim(var ultim:adresa);
q:= prim; var q:adresa;
while q^.urm<>ultim do begin
q:=q^.urm; q:=prim;
2. penultimul nod va deveni ultimul după while q^.urm<>ultim do
ştergere, deci legătura sa următoare q:=q^.urm;
devine nil q^.urm:=nil;
q^.urm:=nil; dispose(ultim);
3. se şterge fizic ultimul nod ultim:=q;
dispose(ultim); end;
4. se reactualizează valoarea pointerului
ultim
ultim:=q;
 inf urm inf urm inf urm
inf urm inf urm inf urm
.............
prim p
prim

1. se memorează adresa celui de-al doilea nod

Procedure sterge_prim(var prim:adresa);
din listă în pointerul p, operatie necesară
var p:adresa;
întrucât după ştergere al doilea nod va deveni
begin
primul
p:=prim^.urm;
p:=prim^.urm;
dispose(prim);
2. se şterge fizic primul nod
prim:=p;
dispose(prim);
end;
3. se reactualizează valoarea pointerului prim
prim:=p;
 inf urm inf urm inf urm inf urm
inf urm inf urm inf urm inf nil .........
.........
prim p p^.urm
q
q

1. se parcurge lista pentru a afla adresa nodului

aflat înaintea cheii de adresă p; adresa o
Procedure sterge_dupa(p:adresa);
vom memora în pointerul q
var q:adresa;
q:= prim;
begin
while q^.urm<>p do
q:=prim;
q:=q^.urm;
2. adresa memorată în zona urm a nodului p va while q^.urm<>p do
q:=q^.urm
fi reţinută în zona urm a nodului q
q^.urm:=p^.urm;
q^.urm:=p^.urm
3. se şterge fizic nodul p dispose(p);
end;
dispose(p);
 inf urm inf urm inf urm inf urm
inf urm inf urm ............... inf urm inf nil

prim p ultim

Parcurgem nodurile liste cu ajutorul unui pointer p care, plecând de la primul nod
va referi pe rând fiecare nod al listei : prelucrăm informaţia din nodul p, mutăm p la
următorul nod şi prelucrarea continuă.

Procedure parcurgere(prim:adresa);
var p:adresa;
Cât timp pointerul p nu a ajuns la sfârşitul begin
listei {p<>nil}: p:=prim;
- prelucrăm informaţia din nodul p (p^.inf) while p<>nil do
- mutăm pointerul p la nodul următor begin
{p:=p^.urm} {prelucrarea informatiei din nodul p}
p:=p^.urm;
end;
end;
 Cât timp pointerul p nu a ajuns la sfârşitul listei {p<>nil} şi informaţia memorată
în zona inf a nodului curent este diferită de x :
- mutăm pointerul p la nodul următor

Funcţia returnează : Function cauta(prim:adresa;x:byte):adresa;

- nil, dacă valoarea x nu a fost găsită în listă; var p:adresa
- adresa nodului ce are completată zona inf begin
cu valoarea memorată în variabila x; p:=prim;
while (p^.inf<>x) and (p<>nil) do
p:=p^.urm;
cauta:=p;
end;
 Parcurgem nodurile liste cu ajutorul unui pointer p care, plecând de la primul
nod va referi pe rând fiecare nod al listei : prelucrăm informaţia din nodul p,mutăm
p la următorul nod şi prelucrarea continuă.

Procedure parcurgere(prim:adresa);
var p:adresa;
Cât timp pointerul p nu a ajuns la sfârşitul begin
listei {p<>nil}: p:=prim;
- prelucrăm informaţia din nodul p (p^.inf) writeln;
- mutăm pointerul p la nodul următor write(‘rezultatul este:’);
{p:=p^.urm} while p<>nil do
begin
{prelucrarea informatiei din nodul p }
p:=p^.urm;
end;
writeln;
end;
 2. Stiva

Ce este o stiva?
 Prin stivă (în limba engleză stack) înţelegem o listă
unidirecţională cu proprieta-tea că operaţiile de
introducere şi extragere a elementelor se fac la un
singur capăt al ei. Poziţia ocupată în stivă de ultimul
element introdus poartă numele de vîrf. O stivă fără
niciun element se numeşte stivă vidă.
 Pentru exemplificare, în figura 2 este prezentată o
stivă care conţine elementele A, B, C.
Cum se reprezinta o stiva?

S C

S C
B
B
A
A
Reprezentatea generalizată

Reprezentatea detaliata Figura 2

Datele necesare pentru crearea şi prelucrarea unei
stive pot fi definite prin decla-raţii de forma:

type AdresaCelula=^Celula; Celula=record

Info : string; Prec : AdresaCelula
end;
var S : AdresaCelula;
 Cum se introduc și se extrag elementele din stivă?
Figura 3

D D
S
C s s
C C
B B B
A A A
Introducearea elementului D Extragerea elementelor D şi C
Stiva iniţială

Operaţia de introducere a unui element în stivă (fig.3)

este efectuată de secven-ţa de instrucţiuni:
new(R); { crearea unei celule }
{încărcarea informaţiei utile în cîmpul R^.Info }
R^.Prec:=S; {crearea legăturii către celula precedentă din stivă}
S:=R; { actualizarea adresei vîrfului }

unde R este o variabilă de tipul AdresaCelula.

 Extragerea unui element din stivă (fig. 3) este
efectuată de secvenţa:

R:=S; { memorarea adresei celulei extrase }

{ prelucrarea informaţiei din cîmpul R^.Info }
S:=S^.Prec; { eliminarea celulei din stivă }
dispose(R); { distrugerea celulei extrase }

Stivele mai poartă şi numele de liste LIFO (last in,

first out — ultimul element care a intrat în stivă va fi
primul care va ieşi din ea) şi sînt frecvent utilizate
pentru aloca-rea dinamică a memoriei în cazul
procedurilor şi funcţiilor recursive. Evident, stivele
pot fi simulate utilizînd tablourile unidimensionale
array[1..n] of ..., însă o astfel de reprezentare este
limitată de cele n componente ale tablourilor.
• Care este utilitatea stivelor?
• În informatică stiva joacă un rol fundamental. Pentru a înțelege mecanisme
fundamentale ale programării (de exemplu, funcțiile sau recursivitatea) este
necesară cunoaşterea noțiunii de stivă. Pe scurt, stiva este utilă în situații în care
este necesară memorarea unor informații şi regăsirea acestora într-o anumită
ordine, descrisă de principiul LIFO. Stiva este utilizată atunci când programul
trebuie să amâne execuția unor operații, pentru a le executa ulterior, în
ordinea inversă a apariției lor. Operația curentă este cea corespunzătoare
vârfului stivei, în stivă fiind reținute toate informațiile necesare programului
pentru a executa operațiile respective.
 3. COADA
• Coada este o structură de date abstractă, pentru care operația de inserare a
unui element se realizează la un capăt, în timp ce operația de extragere a unui
element se realizează la celălalt capăt. Singurul element din coadă la care
avem acces direct este cel de la început.
• Operații caracteristice
• Singurele operații ce pot fi executate cu o coadă sunt:
• crearea unei cozi vide;
• inserarea unui element în coadă;
• extragerea unui element din coadă;
• accesarea unui element.
• Executarea acestor operații asupra unei cozi presupune cunoaşterea începutului
cozii
• Modul de funcționare a unei cozi este foarte uşor de intuit: toată lumea a
„stat la coadă”, măcar o dată. Orice situație în care sunt mai multe cereri de
acces la o resursă unică (de exemplu, mai mulți clienți şi o singură vânzătoare;
o singură pompă de benzină şi mai multe maşini, un singur pod şi mai multe
capre, etc) necesită formarea unei „linii de aşteptare”. Dacă nu apar alte
priorități, cererile sunt satisfăcute în ordinea sosirii. Datorită faptului că
întotdeauna este extras („servit”) primul element din coadă, iar inserarea
oricărui nou element se face la sfârşit („la coadă”), coada este definită ca o
structură de date care funcționează după principiul FIFO (First In First Out –
Primul Intrat Primul Ieşit).
CARE ESTE UTILITATEA UNEI COZI?
• Utilitatea structurii de tip coadă reiese din modul său de funcționare – este necesară
utilizarea unei cozi atunci când informațiile trebuie prelucrate exact în ordinea în
care „au sosit” şi ele sunt reținute în coadă până când pot fi prelucrate. În
informatică, cozile sunt utilizate frecvent. De exemplu, să considerăm că avem o
rețea de calculatoare şi o singură imprimantă. Când utilizatorii rețelei vor da
comenzi de tipărire, imprimanta nu poate răspunde tuturor comenzilor în acelaşi timp
(imaginați-vă ce-ar ieşi!). Prin urmare comenzile de tipărire primite sunt înregistrate
într-o coadă (Print Queue – Coadă de Tipărire). Imprimanta va tipări documentele
pe rând, în ordinea în care au fost înregistrate în coadă. Un alt exemplu: pentru a
mări viteza de execuție, microprocesoarele Intel utilizează o coadă de instrucțiuni în
care sunt memorate instrucțiunile care urmează a fi executate.
• Specific acestei structuri de date este faptul ca adaugarea se va face intotdeauna
la ultim in timp ce prelucrarea (stergerea) se va face la celalat capat. Pentru a
prelucra o coada vor fi necesari doi pointeri: unul il vom numi varful cozii (primul nod
creat) in timp ce la capatul opus ne vom referi la ultimul element.
• Cum implementăm o coadă?
• Coada este o structură de date abstractă, care poate fi implementată în diferite
moduri. Ca şi în cazul stivei, coada poate fi implementată static, reținând elementele
sale într-un vector.
• Extragerea unui element din coadă
• Pentru a extrage un element dintr-o coadă C trebuie să verificăm în primul rând
dacă numărul de elemente din coadă este diferit de 0 (coada nu este vidă). Dacă
da, reținem elementul de la începutul cozii într-o variabilă (să o notăm x), după care
mărim cu o unitate începutul cozii.
 4.Arbori binari
• Definiţie. Un arbore binar este un arbore orientat cu proprietatea că pentru
orice vîrf v, od(v)2. Dacă od(v)=2, cei doi descendenţi sînt desemnaţi ca
descendent stîng (fiu stînga) respectiv descendent drept (fiu dreapta). Pentru
vîrfurile cu od(v)=1, unicul descendent este specificat fie ca fiu stînga, fie ca
fiu dreapta

• Definiţie. Se numeşte arbore strict binar un arbore binar cu poprietatea că

pentru orice vîrf v, od(v)≠1.

• Definiţie. Se numeşte nod terminal (sau frunză) orice vîrf v al arborelui cu

od(v)=0. În caz contrar nodul v este neterminal.
• Arbori de sortare (căutare)
• Definiţie. Un arbore de sortare este un arbore binar cu
următoarele proprietăţi
• fiecărui nod i al arborelui îi este ataşată o informaţie INF(i)
dintr-o mulţime ordonată de valori;
• pentru fiecare nod i, INF(i) este mai mare decît INF(j),
pentru toate nodurile j din subarborele stîng al arborelui cu
rădăcină i;
• pentru fiecare nod i, INF(i) este mai mică decît INF(j),
pentru toate nodurile j din subarborele drept al arborelui
cu rădăcină i;
• pentru orice vîrfuri i şi j daca i  j atunci INF(i)  INF(j).
• Operaţii
• Parcurgeri (pe niveluri, preordine, inordine, postordine)
• Adăugare informaţie
• Ştergere informaţie
10

6 13

4 8 12 15

2 5 7 9 11 14 16

1 3

• Preordine : 10, 6, 4, 2, 1, 3, 5, 8, 7, 9, 13, 12, 11, 15, 14, 16

• Inordine : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
• Postordine : 1, 3, 2, 5, 4, 7, 9, 8, 6, 11, 12, 14, 16, 15, 13, 10
• Pe niveluri : 10, 6, 13, 4, 8, 12, 15, 2, 5, 7, 9, 11, 14, 16, 1, 3
 Arbori binari de căutare.

O mulţime total ordonată după valoarea cheii, având ca operaţii

reprezentative: căutarea, inserarea şi ştergerea. O implementare
eficientă a dicţionarelor se face cu arbori binari de căutare. Intr-un
arbore binar de căutare, pentru fiecare nod, cheile din subarborele
stâng sunt mai mici decât cheia din nod, care este mai mică decât cheile
din subarborele drept
• Proprietăţile arborilor binari de căutare:
• • fiecare subarbore este un arbore binar de căutare
• • cheile din subarborele stâng al unui nod sunt mai mici decât cheia din nod
• • cheile din subarborele drept al unui nod sunt mai mari decât cheia din nod
• • cheia minimă (/maximă) se află în cel mai din stânga (/dreapta) nod
• • înălţimea arborelui binar de căutare este cuprinsă între log2n şi n-1.
• Bibliografie
• E. Cerchez, M. Şerban – „Programarea în limbajul C/C++”. Volumul I; Editura
Polirom
• Cerchez E., Şerban M., Informatică. Manual pentru clasa a X-a, Editura
Polirom, Iaşi, 2000 2. Mateescu G, Moraru
Phttp://ro.wikipedia.org/wiki/Lista_(structur%C4%83_de_date) 6.
http://ro.wikipedia.org/wiki/Stiv%C4%83_(structur%C4%83_de_date) 7.
http://en.wikipedia.org/wiki/Stack_(abstract_data_type)