ATPA

Tabloul = structura de date de acelasi tip care ocupa o zona continua de memorie.
* in limbajul JAVA acelasi tip poate fi si clasa Object
int tab[]=new int[10]
* pt !trin" trebuie utilizata con#ersia cast
AVA$%AJ&'
( accesul rapid la elementele tabloului prin inde)[]
*&+AVA$%AJ&'
(manipularea ,adau"are-inserare-ster"ere. se realizeaza prin deplasarea elementelor
sau modificarea structurii.
Lista = set de noduri- intre noduri e)istand le"atura.
/e"aturile pot fi unidirectionale si bidirectionale.
* informatia stocata in cadrul unui nod poate sa aiba orice natura- de asemenea in cadrul
unui nod e)ista obli"atoriu le"atura catre nodul urmator = referinta
* in cazul le"aturii bidirectionale e)ista referinta si catre nodul precedent
AVANTAJE:
* nu necesita zone continue de memorie
* alocarea dinamica a unui nod ,new. distribuie nodul intr(o zona libera.
* in limbajul 011 ster"erea nodului dintr(o lista presupune si in#ocarea metodei delete
care bifeaza acea zona ca fiind libera
* in JAVA nu e)ista operatia delete- eliminarea nodurilor sterse ,bifarea nodurilor sterse
ca fiind libere. fancandu(se automat.
* manipulare facila a nodurilor ,inserare- adau"are- ster"ere.
DEZAVANTAJE:
* accesul dificil la elementele listei
* de obicei e)ista o referinta catre capul listei ,t.
* accesul catre alte elemente facandu(se sec#ential- lista se #a parcur"e de la t pana la
final.
2n functie de le"atura dintre noduri'
1. liste simplu inlantuite ,le"atura intr(un sens.
3. liste dublu inlantuite ,le"atura in ambele sensuri.
O lista se poate termina cu le"atura catre un nod special sau referinta catre 4null4 sau
catre primul nod ,t. =5 liste circulare.
$od.ja#a
!tructura.ja#a
%estare.ja#a
class Nod {
Object val;
Nod urmator;
// Nod precedent;
public Nod (Object val) {
this.val = val;
urmator = null;
precedent = null;
} //constructor
//fiind vorba de campuri publice nu e necesar sa definim metodele specifice (get/set)
}
6ie urmatoarea lista'
class Nod {
int val;
Nor urmator;
public Nod (public Nod) {
this.val=val;
urmator=null;
}
}
%estare.ja#a
Nod t = ne Nod(!);
t.urmator = ne Nod(");
t.urmator.urmator = ne Nod(#);
t.urmator.urmator.urmator = ne Nod($);
* este esential sa cunoastem modul in care inc7eie lista deoarece parcur"erea
sec#entiala trebuie sa se inc7eie.
* in cazul aceste 4null4 e conditia de inc7eiere.
8arcur"erea sec#entiala'
Nod %=t;
//% are rolul variabilei increment cauta i din
//for (int i=&;i'N;i(()
//pentru parcurgere
hile (% )= null) {
%=%.urmator; //i((
}
2nserarea pentru o lista simpla inlantuita'
Nod * = ne Nod($);
*.urmator = t.urmator.urmator;
t.urmator.urmator = *;
Obs' la operatia de inserare intr(o lista se conecteaza mai intai elementul nou creat.
8roblema'
6ie o lista de noduri de dimensiune data. /ista reprezinta memoria disponibila pentru
pro"ram. !e #or implementa operatii de creare- inserare- ster"ere- pt o lista folosind
nodurile din lista memoriei.
Liste dublu inlantuite
2$!&9A9&
Nod * = ne Nod($);
*.urmator = t.urmator.urmator;
t.urmator.urmator.precedent=*;
*.precedent=t.urmator;
t.urmator.urmator=*;
Obs'
* pentru inserare intr(o lista simplu inlantuita sunt necesare 3 operatii
* pentru inserare intr(o lista dublu inlantuita sunt necesare : operatii
* elementul ; este un nod care nu mai poate fi accesat
* la un anumit moment masina #irtuala il #a ster"e
!%&9<&9&A
1. lista simpla
t.urmator=t.urmator.urmator;
3. lista dublu inlantuita
t.urmator=t.urmator.urmator;
t.urmator.precedent=t;
* pentru operatia de adau"are nodul nou creat se trece in capul listei
* operatie intalnita in cadrul sti#ei.
8roblema lui JO!&8=>!
!e da un numar de $ noduri ,?. si se #a elimina fiecare al @ nod. ,;.
$=?
@=;
* numaratoarea se face numarand si nodul curent
* se utilizeaza o lista circulara simplu inlantuita
int N = integer.parseint (st.ne%t+o,en());
int - = integer.parseint (st.ne%t+o,en());
Not t = ne Nod(.);
Nod % = t;
for (int i=/; i'=N; i(() {
%.urmator = ne Nod(i);
% = %.urmator; //incrementare
}
%.urmator=t; //lista circulara
hile (%)=%.urmator) {
for (int i=.; i'-;i((){
%=%.urmator;
}
%.urmator = %.urmator.urmator;
}
ta.append(%.val);
STIVE SI COZI
!ti#a'
( structura de date de tip /26O
( structura fundamentala a#and implementari atat la ni#el 7ardware cat si la ni#el
software
( structuri de tip sti#a se re"asesc la ni#elul ar7itecturii microprocesoarelor- la masini
#irtuale si pro"rame software.
&)' in limbajele OO8 anumite portiuni de pro"ram pot fi e)ecutate de functii specifice'
( controlul din pro"ramul principal e transferat catre o functie
( punctul ,pozitia. de intoarcere in pro"ramul principal fiind stocat intr(o sti#a
* in cazul in care sti#a nu este implementata eficient sau limbajul de pro"ramare nu este
unul functional in cazul recursi#itatii sti#a se umple foarte repede.
!e mai compara in limbajul JAVA din punct de #edere al timpului de e)ecutie acelasi
pro"ram in #arianta recursi#a si iterati#a.
* in #arianta recursi#a se autoapeleaza functia'
$A=$*,$(1.A
f,$.=n*f,n(1.
* diferenta este data de implementarea sti#ei
* limbajele functionale' &9/A$<- 6B sunt optimizate pentru cod recursi#
Operatiile principale asupra sti#ei'
1. 8>!= ( adau"a un element in #arful sti#ei
3. 8O8 ( e)tra"e elementul din #arful sti#ei
C. 8&&D ( #izualizeaza elementul din #arful sti#ei
:. 2!&@8%E ( sti#a are sau nu elemente
;. 2!6>// ( sti#a este plina
*pd# al implementarii sti#a poate fi constituita pe o structura de tip tablou sau pe o
structura de tip lista.
2mplementarea pe structura de tablou
* pentru implementare este necesara cunoasterea #arfului sti#ei
* con#entii'
1 consideram #arful sti#ei ca fiind pozitia libera din sti#a
1 elementul ne #a adau"a in sti#a la pozitia indicata de #arf'
+ab0varf1;
varf((;
( sti#a este #ida ,is&mptF == true . daca #arf=0
( sti#a este plina ,is6ull == true . daca #arf=tab.len"t7
( in cadrul pac7etului Ja#a.>til e)ista o implementare de tip sti#a
Obs' #erificarile de tip is&mptFGis6ull se pot realiza in cadrul clasei !ti#a sau e)tern in
cadrul clasei %est. *e asemenea is&mptFGis6ull se pot implementa folosind e)ceptii.
!ti#a.ja#a
class 2tiva {
int tab01=ne int0.&1;
int varf=&;
public 2tiva() {}
public void push (int *) {
if ()is3ull()) {tab0varf((1=*;}
}
public int pop () {
if ()is4mpt5()) { return tab066varf1;}
return null;
}
public int pea,() {
if ()is4mpt5()) {return tab0varf6.1;}
return null;
}
public boolean is4mpt5() {
return (varf==&);
}
public boolean is3ull() {
return (varf==tab.length);
}
}
%estare.ja#a
2tiva stv = ne 2tiva();
stv.push(!);
stv.push(");
stv.pop();
Implementarea stivei pe o strutura de tip lista
,t==null. =5 sti#a "oala
* sti#a implementata pe o structura de tip lista poate a#ea ca si conditie de #id ,is&mptF.
elementul null sau special
!ti#a/.ja#a
class 2tiva7 {
Nod t = null;
public 2tiva7() {}
public void push (int *) {
Nod 5 = ne Nod(*);
5.urmator = t;
t = 5;
}
public int pop() {
if (t)=null) {
int val=t.val;
t=t.urmator;
return val;
}
}
public int pee,() {
return t.val;
}
H
Coada
* structura de tip 626O
* se intalneste in cazul Iufferelor ,memorii tampon.
* scopul principal' a stoca si a li#ra coerent informatia.
&)' se poate construi o zona de memorie de tip coada care acumuleaza o serie de
actiuni sosite la di#erse momente de timp si pe care le srie o data pe =**(!!*.
Iaze de date in memorie 1 cac7e.
* un ser#iciu de con#ersie a filmelor dintr(un format in altul se poate construi pe o
structura de tip coada.
* ser#iciul A@A+O$ pune la dispozitie un sistem de cozi care preiau informatia de la
utilizatori si o distribuie catre alte ser#icii !J!.
2mplementare'
1. pe structura de tip tablou
3. pe structura de tip lista
0oada%.ja#a
* sunt necesari 3 indecsi'
a. D ( cap ( introducere
b. capat ( coada ( e)tra"ere
* in cazul implementarii pe o structura de tip tablou apare fenomenul de mi"rare a cozii
in tablou.
cap(.==coada
* conditia is6ull are loc atunci cand inde)ul cap se afla pe ultima pozitie si inde)ul coada
pe prima. !au cand cap(.==coada
Operatii specifice'
1. put ( adau"a
3. "et ( e)tra"e
* structurile de sti#a si coada se #or folosi in cazul arborilor ca structuri ajutatoare
0oada implementata pe o structura de tip lista'
* trebuie tratate urmatoarele cazuri
a. niciun elenent
b. un sin"ur element
c. mai multe elemente
* #aianta de implementare'
( introducerea nodurilor speciale care sa delimiteze coada
hile (%.urmator)=coada)
a. is&mptF,. ( coada #ida
cap.urmator = coada
b. introducere'
Nod * = ne Nod(!);
*.urmator = cap.urmator;
cap.urmator = *;
c. e)tra"ere' se parcur"e pana la ultimul sau se #a crea o lista dublu inlantuita.
Aplicatii
1. 2n#ersarea unui sir de caractere'
2tring str=8abcdef8;
for (int i=&; i'str.length();i(()
strcharcat(i);
3. Verificarea unei e)presii matematice
4KL 1 [; ( ,C1:.]H4
* folosind o structura de tip sti#a in care se #a trece parantezele desc7ise.
Al!oritmi simpli de sortare
( sunt potri#iti pentru seturi reduse de date
( in cazil unui se redus de date este preferabil sa utilizam unul dintre al"oritmii simpli de
sortare deoarece timpul de sortare este la fel sau c7iar mai bun decat in cazul unui
al"oritm mai comple).
( al"oritmi complecsi de sortare se folosesc in cazul seturilor uriase de date sau a unor
confi"uratii deosebite a datelor.
( pe seturi mari de date al"oritmii complecsi "aranteaza un timp de sortare mic
( de obicei sortarea este o etapa care pre"ateste setul de date pentru alte operatii
,cautare liniara.
( operatii de sortari frec#ente in cadrul I* sunt A!0- *&!0.
!ortarea prin selectie
* este selectat un element si se considera a fi minimul ,D.
* se cauta in restul tabelului un element care sa aiba o #aloare mai mica ,M D.
* daca se "aseste un astfel de element se sc7imba pozitia celor 3 elemente intre ele
* se parcur"e de fiecare data tot tabloul ramas pentru a "asi minimul
* dupa o prima parcur"ere pe prima pozitie a#em "arantat cel mai mic element
( tabloul tab (5 introdus !trin"%oNen
public void sortare9selectie() {
for (int i=&; i'n6.;i(() {
int ,=i; //mem po*itia elementului presupus minim
for (int j=i(.; i'n; j(() {
if (tab0j1'tab0,1) ,=j;
if (, )= i) {int t=tab0i1;
tab0i1=tab0,1;
tab0,1=t;
}
}
}
}
tab[j]Mtab[N] N=j
!ortarea prin insertie
* se considera ca pana la pasul i(1 toate elementele sunt sortate
* elementul de pe pozitia i se #erifica cu elementul de la stan"a pana cand se intalneste
un element cu o #aloare mai mica decat elementul de pe pozitia i
* elementele comparate se #or deplasa cu o pozitie la dreapta
for (int i=.; i'n6.;i(() {
int ,=i; //mem po*itia
int p = tab0i1; //mem valoare
hile (tab0,6.1:p ;; ,:&) {
tab0,1=tab0,6.1;
,66;
}
tab0,1=p;
}
!ortarea prin metoda bulelor
( la o prima parcur"ere a tabelului metoda "aranteaza ca pe ultima pozitie se #a afla
elementul cel mai mare.
( la parcur"ere se compara elementele #ecine si se sc7imba pozitia intre ele.
for (int i=n6.; i:&; i66) {
for (int j=.; j'=i; j(()
if tab0j6.1:tab0j1 {
int t=tab0j1;
tab0j1=tab0j6.1;
tab0j6.16t;
}
}
@etodele comple)e de sortare se bazeaza pe recursi#itate.
* este dificil de scris si de inteles un al"oritm comple) de sortare sub forma iterati#a
"eursivitatea
* presupune rezol#area unei probleme prin rezol#area unor dimensiuni mici ale aceleiasi
probleme.
* un al"oritm recursi# contine o dimensiune suficient de mica a problemei pentru care se
cunoaste raspunsul
* presupunem apelul aceleiasi metode cu o #aloare mai mica a dimensiunii problemei
1. triun"7iular
f,N. = N 1 f,N(1.
f,C. = C 1 f,3.
f,3. = 3 1 f,1.
f,1. = 1
*la al"oritmi recursi#i =5 sunt functii ce intorc o #aloare
public int triunghi(int val) {
if (val==.) return .;
return val(triunghi(val6.);
}
3. factorial
public int factorial (int val) {
if (val==&) return .;
return val<factorial(val6.);
}
Interlasarea a doua tablouri
( se obtine un al C(lea tablou care are dimensiunea data de suma dintre cele doua
tablouri
tab!.length=tab/.length(tab..length;
&ste format astfel'
( se compara pozitia curenta din primul tablou cu pozitia curenta din al 3(lea tablou- iar
#aloarea mai mica se trece in tablou
( pozitia curenta din tabloul cu #al mai mica se incrementeaza
( daca pozitiile comparate au aceeasi #aloare- #alorile se #or trece in tabC incrementand
#alorile in ambele tabele
( operatia continua pana cand se parcur"e unul sau ambele tabele- restul #alorilor
ramase fiind copiate in aceeasi ordine in tabC
( prin interclasarea a 3 tablouri ordonate se obtine un tablou ordonat ,@er"e !ort.
public void interclasare() {
int tab!01 = ne int0tab..length ( tab/.length1;
int i=&=j=&=,=&;
hile (i'tab...length ;; j'tab/.length) {
if (tab.0i1' tab0j1) {tab!0,1= tab.0i1; i((; ,((;}
if (tab/0i1'tab0j1) {tab/0,1= tab/0i1; j((; ,((;}
}
hile (i'tab..length) {tab!0,1=tab.0i1; i((; ,((;}
hile (j'tab/.length) {tab!0,1=tab/0j1;j((;,((;}
}
"eursivitate# Cautare liniara $iterativa% reursiva&
0autarea liniara presupune cautarea unei #alori intrun set de date dat. *aca datele nu
sunt sortate este posibl sa trebuiasca parcurs intre"ul set de date. *aca datele sunt
ordonate nu mai este necesara parcur"erea tuturor datelor din set.
0autare liniara
@etoda ,functia. de cautare liniara afla pozitia pe care se re"aseste elementul c7eie.
public int cauta> (int ch= int i.= int i/) {
//in ca*ul alg de cautare si ordonare recursivi se obisnuieste sa se foloseasca
//mijlocul internalului
int ,=(i.(i/)//;
if (tab0,1==ch) return ,;
//cond de oprire pt alg recursiv
if (i/'i.) return 6.; //eroare
else {
if (tab0,1'ch) cauta>(ch=,(.=i/);
if (tab0,1:ch) cauta>(ch=i.=,);
}
}
Divide et impera
%e7nica de pro"ramare ,stil de pro"ramare.
* presupune descompunerea unei probleme de o dimensiune $ in probleme de
dimeniune mai mica si rezol#area acestora indi#iduala
!a se afle ma)imul unui set de date in mod recursi#'
public int ma% (int tab01= int i.= int i/) {
if (i.==i/) return tab0i.1;
int ,=(i.(i/)//;
int u=ma%(tab=i.=,);
int v=ma%(tab=,(.=i/);
if (u:v) return u;
else return v;
}
Sortarea 'er!eSort
* utilizeaza te7nica di#ide et impera- descompunand problema initiala pana la
dimensiunea 1.
* cele 3 tablouri de dimensiune 1 sunt interclasate obtinandu(se un tablou de
dimensiune 3 ordonat.
public int -erge2ort(int tab01=int i.=int i/) {
if (i/6i.:.) {
int ,=(i.(i/)//;
-erge2ort(tab=i.=,6.);
-erge2ort(tab=,=i/);
interclasare(tab=i.=,=i/);
} else if (i.6i/==.) {
if (tab0i.1:tab0i/1) {
int t=tab0i/1;
tab0i/1=tab0i.1;
tab0i.1=t;
}
}
}
(ui)Sort
* al"oritmul de sortare foloseste te7nica di#ide et impera'
( este aleasa o #aloare oarecare din tablou ,pi#ot.
( #alorile mici sunt trecute in stan"a
( #alorile mari sunt trecute in dreapta
* se poate face o sortare folosind o structura au)iliara
* sau o sortare in place ,pe loc. in tablou
public void interclasare (int tab01=int i.= int ,= int i/) {
int tab!01=ne int0tab.length1;
hile (i',6. ;; ?'i/) {
if (tab0i1:=tab0j1 { tab!0?1=tab0j1; ?((; j((; }
if (tab0i1'tab0j1 { tab!0?1=tab0i1; ?((; i((; }
}
hile (i.',6.) { tab!0?1=tab0i1; ?((; i((; }
hile (j'i/) { tab!0?1=tab0j1; ?((; j((; }
// se copia*a tab! in tab
}
Obs' sortarea se realizeaza dupa #aloarea pi#otului si nu dupa pozitia acestuia in tablou
(ui)Sort pe tablou u sortare in plae
* ale"erea pi#otului consta in ale"erea mijlocului tabloului.
* se definesc doi indicatori de pozitie
i ( pt #al mai mici din stan"a
j ( pt #alori mai mari din dreapta
* in momentul in care in zona din stan"a se intalneste o #aloare mai mare decat pi#otul-
aceasta se #a sc7imba cu #aloarea mai mica decat pi#otul aflata in dreapta.
hile (i'j)
hile (i'pivot) i((;
hile (j:pivot) j((;
schimbare();
A"*O"I
* structuri de date ierar7izate combinand facilitati oferite'
( de structuri de tip tablou
( de structuri de tip lista
* in functie de structura si or"ani"rama arborelui sunt facilitate anumite operatii- structura
unui arbore poate influenta decisi# modul de rezol#are a unei probleme.
( Arbori(I ,baze de date.
( Arbori binari ,3(C(:.
( Arbori rosu(ne"ru
%ipuri "enerale de arbori
( arbori liberi
( arbori radacina
( arbori ordonati
( binari
( n(ari
Abori liberi
* arbori in care toate nodurile au acelasi rol
* atat timp cat intre 3 noduri e)ista o sin"ura cale ,drum. structura respecti#a este un
arbore
* daca mai e)ista un alt drum- structura se numeste "raf.
Arbori radacina
* prezinta o or"anizare ierar7ica
* nodul de pe ni#elul 0 = nod radacina
* in cazul arborilor radacina se intalnesc noduri parinte- noduri copil- noduri frati- noduri
frunza.
* nodurile care nu mai au alte noduri copii se numesc noduri terminale sau frunza.
* !tructura arborelui radacina este o structura recursi#a
Arbori ordonati ( arbori radacina la care pentru fiecare ni#el e)ista o ordonare pe ni#el.
3 copii =5 arbori binari
n copii =5 arbori n(ari
Arbori binari de cautare
Ordonare'
#aloarea nodului copil stan"a M #aloarea parintelui M #aloarea copilului din
dreapta
%ra#ersari'
1. 9ecursi#e (5 Adancime ,preordine- inordine- postordine.
3. 2terati#e (5 Adancime ,preordine- inordine- postordine.
(5 /atime
@etodele iterati#e de tra#ersare se fac cu ajutorul structurilor au)iliare'
( pt adancime' sti#a
( pt latime' coada
2n cadrul unei tra#ersari se poate realiza operatia de #izitare = posibilitatea e)ecutarii
unei operatii cu #aloarea nodului respecti#.
Obs' >n nod poate fi tra#ersat de mai multe ori- dar #izitat o sin"ura data.
%ra#ersarea arborilor liniari
class Nod@ {
char val;
Nod@ s;
Nod@ d;
public Nod@ (char val) {
this.val=val;
s=null;
d=null;
}
}
%ra#ersarea in Adancime'
1. 8reordine A(I(0(*(&(6(<(=
3. 2nOrdine *(0(&(I(A(<(=(6
C. 8ostordine *(&(0(I(=(<(6(A
:. /atime ,ni#eluri.
A
I 6
0 <
* & =
%ra#ersarea adancime ,recursi#a.
public void traversare9recursiv (Nod@ %) { //%= radacina
A. if (%==null) return;
25stem.out.println(%.val);
A/ if ((%.s))=null) traversare9recursiv(%.s);
A! if ((%.d))=null) traversare9recursiv(%.d);
}
8re 2n 8ost
====================
1 3 3
3 1 C
C C 1
%ra#ersarea iterati#a
* in cazul tra#ersarii iterati#e e necesara folosirea unei structuri au)iliare de tip sti#a
public void traversare9interativa(Nod@ %) {
//2tiva stv = ne 2tiva();
stv.push(%);
hile ()stv.is4mpt5()) {
Nod@ %t=stv.pop();
A. 25stem.out.println(%t.val);
// deoarece structura au%iliara e o stiva pt a vi*ita st apoi dr
// acestia trebuie introdusi invers ca ordine
A/ if (%t.d)=null) stv.push(%t.d);
A! if (%t.s)=null) stv.push(%t.s);
}
}
* pentru adresarea iterati#a 2nOrdine si 8ostOrdine trebuie sa cunoastem cand
tra#ersam un nod si cand e #izitat
* este posibil ca un nod sa(l tra#ersez de 3 ori si sa(l #izitez 1 data. ,#izitare=afisare.
* #om folosi un parametru o #ariabila care #a indica starea nodului
1. este pt prima data in sti#a
3. a fost anterior in sti#a
public void traversare9iterativa(Nod@ %) {
2tiva stv=ne 2tiva %();
stv.push(ne Nod(%=&));
hile (stv.is4mpt5()) {
Nod %=stv.pop();
if (%t.%.s==null ;; %t.%.d==null)
25stem.out.println(%t.%.val);
else if (%t.*==.)
25stem.out.println(%t.%.val);
else {
if (%t.t.d)=null) stv.push(ne Nod B(%t.%.d=&);
if (%t.t.s)=null) stv.push(ne Nod B(%t.%.s=&);
stv.push(ne Nod %(%t.%=.));
}
}
}
8re 2n 8ost
===================
1 1 C
3 C 1
C 3 3
%ra#ersarea in latime
* se foloseste o structura au)iliara de tip coada
( ordinea de introducere a nodurilor in coada este de la stan"a la dreapta pe ni#el
public void +raversare9latima(Nod@ %) {
Coada ?=ne Coada();
?.put(%);
hile ()?.is4mpt5()) {
Nod@ %t=?.get();
25stem.out.println(%t.val);
if (%t.s)=null) ?.put(%t.s);
if (%t.d)=null) ?.put(%t.d);
}
H
=&*<06IA =5 AI60<*&=