(Capitolul 1 Introducere in problematica structurilor de date si a algoritmilor)

P: 1
I: Sortarea stabila este acea sortare care
V1: pastreaza, pe tot parcursul executarii sale toate inregistrarile in memoria
interna a calculatorului
V2: poate ordona o anumita clasa de obiecte concrete sau abstracte, dupa unul sau
mai multe criterii impuse
V3: in urma executarii sale face ca inregistrarile cu chei egale sa isi
pastreze pozitiile relative
V4: nu pastreaza toate inregistrarile in memoria interna a calculatorului ci foloseste
pentru memorare si spatii pe memoriile externe
R: 3
P: 1
I: Sortarea interna este aceea sortare care
V1: nu pastreaza toate inregistrarile in memoria interna a calculatorului ci foloseste
pentru memorare si spatii pe memoriile externe
V2: pastreaza, pe tot parcursul executarii sale toate inregistrarile in
memoria interna a calculatorului
V3: in urma executarii sale face ca inregistrarile cu chei egale sa isi pastreze
pozitiile relative
V4: poate ordona o anumita clasa de obiecte concrete sau abstracte, dupa unul sau
mai multe criterii impuse
R: 2
P: 1
I: Sortarea externa este aceea sortare care:
V1: pastreaza, pe tot parcursul executarii sale toate inregistrarile in memoria
interna a calculatorului
V2: in urma executarii sale face ca inregistrarile cu chei egale sa isi pastreze
pozitiile relative
V3: poate ordona o anumita clasa de obiecte concrete sau abstracte, dupa unul sau
mai multe criterii impuse
V4: nu pastreaza toate inregistrarile in memoria interna a calculatorului ci
foloseste pentru memorare si spatii pe memoriile externe
R: 4
P: 1
I: Structurile de date reprezinta:
V1: modalitati in care datele sunt dispuse in memoria calculatorului
V2: colectii organizate de date
V3: tipuri de variabile de memorie
V4: tipuri de date definite de utilizator cuprinzand variabile multiple

R: 1
P:1
I: Algoritmii reprezinta
V1: succesiuni de pasi bine definiti scrisi pentru rezolvarea unei probleme
V2: metode de calcul alcatuite din pasi elementari necesari rezolvarii unor probleme
V3: metode generale de rezolvare a unui anumit tip de problema
V4: procedurile pe care programele le efectueaza pentru a manipula
datele din structurile de date
R: 4
P: 1
I: Care din urmatoarele reprezinta avantaje ale tablourilor?
V1: Inserarea si stergerea sunt rapide, iar accesul este foarte rapid
V2: Cautarea si stergerea sunt rapide, iar accesul la celelalte elemente este rapid
V3: Inserare este rapida, iar accesul este foarte rapid daca indexul este
cunoscut
V4: Cautarea, inserarea si stergerea sunt rapide, iar accesul este rapid
R: 3
P: 1
I: Care din urmatoarele reprezinta avantaje ale tablourilor ordonate?
V1: Cautarea este mai rapida decat in cazul tablourilor nesortate
V2: Inserarea, stergerea si accesul la elementul maxim sunt rapide
V3: Accesarea este foarte rapida pe baza unei chei
V4: Inserarea este rapida, iar accesul este foarte rapid daca indexul este cunoscut
R: 1
P: 1
I: Care din urmatoarele reprezinta avantaje ale listelor nlantuite?
V1: Cautarea, inserarea si stergerea sunt rapide
V2: Inserarea si stergerea sunt rapide
V3: Accesarea este foarte rapida
V4: Inserarea este rapida
R: 2

(Capitolul 2 Lista cu doua capete)

P: 1
I: O lista cu doua capete este o lista
V1: in care elementele pot fi sterse la unul din capete si adaugate la celalalt capat
V2: in care elementele pot fi sterse sau adaugate la unul din capete
V3: obisnuita care are in plus o referinta catre ultima legatura din lista

V4: obisnuita care are in plus o referinta catre prima legatura din lista
R: 3

P: 2
I: Urmatorul cod reprezinta inserarea unui element
[pre][code]public void insert(long dd) {
Link newLink = new Link(dd);
if( isEmpty() )
last = newLink;
newLink.next = first;
first = newLink;
}
}[/code][/pre]
V1: inaintea ultimului element din lista cu doua capete
V2: dupa primul element din lista cu doua capete
V3: la sfarsitul listei cu doua capete
V4: la inceputul listei cu doua capete
R: 4
P: 2
I: Urmatoarea secventa de instructiuni reprezinta inserarea unui element
[pre][code]public void insert(long dd) {
Link newLink = new Link(dd);
if( isEmpty() )
first = newLink;
else
last.next = newLink;
last = newLink;
}
}[/code][/pre]
V1: la sfarsitul listei cu doua capete
V2: dupa primul element din lista cu doua capete
V3: inaintea ultimului element din lista cu doua capete
V4: la inceputul listei cu doua capete
R: 1
P: 2
I: Urmatorul cod reprezinta stergerea
[pre][code]public long delete() {
long temp = first.dData;
if(first.next == null)
last = null;
first = first.next;

return temp;
}
}[/code][/pre]
V1: celui de-al doilea element din lista cu doua capete
V2: primului element din lista cu doua capete
V3: celui de-al treilea element din lista cu doua capete
V4: ultimului element din lista cu doua capete
R: 2

(Capitolul 3 Lista dublu inlantuita)

P: 2
I: Urmatoarea secventa de instructiuni este folosita pentru afisarea
[pre][code]public void display() {
System.out.print("Lista: ");
List current = last;
while(current != null) {
current.displayList();
current = current.previous;
}
System.out.println(" ");
}[/code][/pre]
V1: ultimului element din lista
V2: unui liste de la primul pana la ultimul element
V3: primului element din lista
V4: unei liste de la ultimul pana la primul element
R: 4
P: 2
I: Urmatorul cod reprezinta inserarea unui element
[pre][code]public void insert(long dd) {
Link newLink = new Link(dd);
if( isEmpty() )
last = newLink;
else
first.previous = newLink;
newLink.next = first;
first = newLink;
}[/code][/pre]
V1: inaintea ultimului element din lista dublu inlantuita
V2: dupa primul element din lista dublu inlantuita
V3: la inceputul listei dublu inlantuite
V4: la sfarsitul listei dublu inlantuite

R: 3
P: 2
I: Urmatoarea secventa de instructiuni reprezinta inserarea unui element
[pre][code]public void insert(long dd) {
Link newLink = new Link(dd);
if( isEmpty() )
first = newLink;
else {
last.next = newLink;
newLink.previous = last;
}
last = newLink;
}[/code][/pre]
V1: la sfarsitul listei cu doua capete
V2: la sfarsitul listei dublu inlantuite
V3: la inceputul listei cu doua capete
V4: la inceputul listei dublu inlantuite
R: 2
P: 2
I: Urmatorul cod reprezinta stergerea
[pre][code]public Link delete() {
Link temp = first;
if(first.next == null)
last = null;
else
first.next.previous = null;
first = first.next;
return temp;
}[/code][/pre]
V1: primului element din lista dublu inlantuita
V2: ultimului element din lista cu doua capete
V3: primului element din lista cu doua capete
V4: ultimului element din lista dublu inlantuita
R: 1
P: 2
I: Urmatoarea secventa de instructiuni reprezinta stergerea
[pre][code]public Link delete() {
Link temp = last;
if(first.next == null)
first = null;
else

last.previous.next = null;
last = last.previous;
return temp;
}[/code][/pre]
V1: ultimului element din lista dublu inlantuita
V2: primului element din lista cu doua capete
V3: ultimului element din lista cu doua capete
V4: primului element din lista dublu inlantuita
R: 1
P: 2
I: Urmatorul cod reprezinta inserarea unui element
[pre][code]public boolean insert(long e, long dd) {
Link current = first;
while(current.dData != e) {
current = current.next;
if(current == null)
return false;
}
Link newLink = new Link(dd);
if(current==last) {
newLink.next = null;
last = newLink;
}
else {
newLink.next = current.next;
current.next.previous = newLink;
}
newLink.previous = current;
current.next = newLink;
return true;
}[/code][/pre]
V1: inaintea unei valori date de la tastatura in cadrul unei liste dublu inlantuite
V2: dupa o cheie data de la tastatura in cadrul unei liste dublu inlantuite
V3: dupa o valoare precizata in cadrul unei liste dublu inlantuite
V4: inaintea unei chei precizate in cadrul unei liste dublu inlantuite
R: 2
P: 2
I: Urmatoarea secventa de instructiuni reprezinta stergerea elementului
[pre][code]public Link delete(long e) {
Link current = first;
while(current.dData != e) {
current = current.next;

if(current == null)
return null;
}
if(current==first)
first = current.next;
else
current.previous.next = current.next;
if(current==last)
last = current.previous;
else
current.next.previous = current.previous;
return current;
}[/code][/pre]
V1: aflat dupa o cheie data de la tastatura intr-o lista dublu inlantuita
V2: cu o valoare data de la tastatura intr-o lista dublu inlantuita
V3: cu cheia precizata intr-o lista dublu inlantuita
V4: care se gaseste inaintea unei valori precizate intr-o lista dublu inlantuita
R: 3

(Capitolul 4 Coada)
P: 1
I: Care este avantajul cozilor?
Accesul se face dup metoda
V1: ultimul sosit, primul servit
V2: primul sosit, ultimul servit
V3: ultimul sosit, ultimul servit
V4: primul sosit, primul servit
R: 4
P: 1
I: Coada este o lista liniara simplu inlantuita, de tip special, pentru care toate
inserarile
V1: si toate stergerile sunt facute la un singur capat
V2: sunt facute la unul din capete, iar toate stergerile la celalalt capat
V3: si toate stergerile sunt facute la inceput
V4: si toate stergerile sunt facute la sfarsit
R: 2
P: 1
I: Coada functioneaza pe principiul
V1: [code]FIFO[/code]
V2: [code]LIFO[/code]

V3: [code]FILO[/code]
V4: [code]LILO[/code]
R: 1
P: 1
I: Spre deosebire de coada obisnuita, intr-o coada cu prioritati:
V1: elementele sunt ordonate crescator, astfel incat elementul cu cheia minima sa
se gaseasca intotdeauna in fata
V2: este permisa insertia unui nou element si suprimarea celui mai mare element
dintre cele existente
V3: elementele sunt ordonate dupa valoarea unei chei, astfel incat
elementul cu cheia minima sau maxima sa se gaseasca intotdeauna in fata
V4: fiecare element are asociata o anumita prioritate
R: 3
P: 2
I: Urmatoarea secventa de instructiuni realizeaza adaugarea unui element intr-o
[pre][code]public void insert(long item) {
int j;
if(nItems==0)
queArray[nItems++] = item;
else {
for(j=nItems-1; j>=0; j--) {
if( item > queArray[j] )
queArray[j+1] = queArray[j];
else
break;
}
queArray[j+1] = item;
nItems++;
}
}[/code][/pre]
V1: lista cu doua capete
V2: coada cu prioritati
V3: lista dublu inlantuita
V4: stiva
R: 2
(Capitolul 5 Stiva)
P: 1
I: Care este avantajul stivelor?
Accesul se face dupa metoda
V1: primul sosit, ultimul servit

V2: ultimul sosit, primul servit

V3: primul sosit, primul servit
V4: ultimul sosit, ultimul servit
R: 2
P: 1
I: Stiva este o lista liniara de un tip special, in care adaugarea:
V1: sau scoaterea unui element se face la inceput
V2: sau scoaterea unui element se face la sfarsit
V3: sau stergerea unui element se face la un singur capat
V4: este facuta la unul din capete, iar stergerea este facuta la celalalt capat
R: 3
P: 1
I: Stiva functioneaza pe principiul
V1: [code]LILO[/code]
V2: [code]FIFO[/code]
V3: [code]FILO[/code]
V4: [code]LIFO[/code]
R: 4
P: 1
I: In cazul stivei se fac operatii de inserare sau stergere numai
V1: in varful stivei
V2: la sfarsitul stivei
V3: in interiorul stivei
V4: la unul din capetele stivei
R: 1

(Capitolul 6 Metoda bulelor)

P: 1
I: Care din urmatoarele reprezinta avantaje ale metodei bulelor?
V1: Algoritmul efectueaza putine deplasari de date
V2: In ceea ce priveste viteza, acesta metoda este cea mai eficienta dintre
metodele simple de cautare si soratre
V3: Metoda este extrem de eficienta in ceea ce priveste utilizarea
memoriei, datorita faptului ca toate operatiunile de triere sunt efectuate
pe multimea initiala de date
V4: Metoda este mult mai eficienta decat cautarea secventiala pentru ca are o
complexitate mai mica, numar de comparari mai mic
R: 3

P:1
I: Sortarea prin meteoda bulelor este o metoda de sortare eficienta pentru un
numar
V1: de zeci de mii de elemente
V2: de maxim 300 de elemente
V3: mare de elemente
V4: mic de elemente, mai putin de 15 elemente
R: 4
P: 2
I: Presupunand ca sortam valorile crescator, sortarea prin metoda bulelor
V1: cicleaza printre valorile tabloului, comparand valori vecine si
deplasand valorile cele mai mari in partea dreapta
V2: cauta in tablou pana gaseste valoarea minima, apoi plaseaza valoarea minima
in primul element, schimband pozitia minimului gasit cu elementul aflat in capatul
din stanga, in pozitia 0. La fiecare pas, algoritmul gaseste elementul minim din
partea nesortata si il adauga la finalul partii sortate. Cand partea nesortata ramane
goala, algoritmul se opreste
V3: lucreaza in iteratii. In prima iteratie compara elemente aflate la distanta s1 mai
mare decat 1. Asta inseamna ca fiecare element din sirul initial este deplasat spre
stanga cu cate s1 pozitii atat timp cat intalneste elemente mai mari decat el. Se
repeta asemenea iteratii cu salturi din ce in ce mai mici, s3, s4, etc. Ultima iteratie
se face cu saltul 1
V4: presupune impartirea tabloului imaginar intr-o parte sortata si una nesortata. La
inceput, partea sortata contine primul element al tabloului si partea nesortata
contine restul tabloului. La fiecare pas, algoritmul ia primul element din partea
nesortata si il insereaza in locul potrivit al partii sortate. Cand partea nesortata nu
mai are nici un element, algoritmul se opreste
R: 1
P: 2
I: Urmatoarea secventa de instructiuni reprezinta sortarea
[pre][code]public void Sort() {
int out, in;
for(out=nElems-1; out>0; out--) {
for(in=0; in<out; in++)
if( a[in] > a[in+1] )
swap(in, in+1);
}
}[/code][/pre]
V1: prin selectie
V2: prin metoda bulelor
V3: onor obiecte
V4: prin insertie

R: 2
P: 2
I: Urmatorul cod
[pre][code]public void functie() {
int s=0;
long c=a[0];
for(int jq=0;jq<nElems;jq++)
if(c > a[jq]) {
c=a[jq];
s=jq;
}
System.out.println("Valoarea este: "+c);
System.out.println("Modificam.....");
System.out.println("Vectorul dupa modificare: ");
a[s]=a[0];
a[0]=c;
}[/code][/pre]
V1: ordoneaza crescator tabloul si il afiseaza
V2: gaseste cel mai mare element din tablou si interschimba maximul gasit cu
primul element din tablou
V3: ordoneaza descrescator tabloul si il afiseaza
V4: selecteaza cel mai mic element din tablou si interschimba minimul
gasit cu primul element din tablou
R: 4

(Capitolul 7 Sortarea prin selectie)

P: 1
I: Care din urmatoarele reprezinta avantaje ale metodei de sortare prin selectie?
V1: Numarul de pasi efectuati este acelasi cu numarul de comparari si este
[code]N(N-1)/2[/code] indiferent de structura datelor de intrare. Insa
pentru cazul in care sirul este ordonat crescator se vor face doar
[code]N[/code] atribuiri
V2: Metoda este foarte eficienta in ceea ce priveste utilizarea memoriei, datorita
faptului ca toate operatiunile de triere sunt efectuate pe multimea initiala de date
V3: Algoritmul este, pentru date alese la intamplare, de doua ori mai rapid decat
sortarea prin insertie
V4: Metoda nu foloseste nici odata mai mult de [code]lg(N-1)[/code] comparatii
R: 1
P: 2
I: Sortarea prin selectie:

V1: presupune impartirea tabloului imaginar intr-o parte sortata si una nesortata. La
inceput, partea sortata contine primul element al tabloului si partea nesortata
contine restul tabloului. La fiecare pas, algoritmul ia primul element din partea
nesortata si il insereaza in locul potrivit al partii sortate. Cand partea nesortata nu
mai are nici un element, algoritmul se opreste
V2: cauta in tablou pana gaseste valoarea minima, apoi plaseaza valoarea
minima in primul element, schimband pozitia minimului gasit cu elementul
aflat in capatul din stanga, in pozitia 0. La fiecare pas, algoritmul gaseste
elementul minim din partea nesortata si il adauga la finalul partii sortate.
Cand partea nesortata ramane goala, algoritmul se opreste
V3: cicleaza printre valorile tabloului, comparand valori vecine si deplasand valorile
cele mai mari in partea dreapta
V4: gaseste un anumit element intr-un tablou ordonat, utilizand un numar minim de
comparatii
R: 2
P: 2
I: Urmatoarea secventa de instructiuni reprezinta sortarea
[pre][code]public void Sort() {
int out, in, min;
for(out=0; out<nElems-1; out++) {
min = out;
for(in=out+1; in<nElems; in++)
if(a[in] < a[min] )
min = in;
swap(out, min);
}
}[/code][/pre]
V1: onor obiecte
V2: prin metoda bulelor
V3: prin selectie
V4: prin insertie
R: 3
(Capitolul 8 Sortarea prin insertie)
P: 1
I: Care din urmatoarele reprezinta avantaje ale metodei de sortare prin insertie?
V1: Numarul de pasi efectuati este acelasi cu numarul de comparari si este
[code]N(N+1)/2[/code] indiferent de structura datelor de intrare
V2: Algoritmul este, pentru date alese la intamplare de doua ori mai rapid
decat metoda bulelor si mai rapid decat sortarea prin selectie

V3: In procesul de sortare cheia cautata este gasita in maximum [code]log(N-1)

[/code] comparatii care este un castig deosebit fata de cele [code]N[/code]
comparatii ale cautarii secventiale
V4: Pentru cazul unor elemente sortate in ordine inversa, sortarea prin insertie
ruleaza de trei ori mai rapid decat sortarea prin selectie
R: 2
P: 2
I: Sortarea prin insertie
V1: se refera la o clasa de algoritmi care au ca principale caracteristici faptul ca
impart problema in subprobleme similare cu problema initiala dar mai mici ca
dimensiune, rezolva subproblemele recursive obtinanduse solutiile acestora si apoi
combina solutiile subproblemelor obtinanduse solutia problemei
V2: cauta in tablou pana gaseste valoarea minima, apoi plaseaza valoarea minima
in primul element, schimband pozitia minimului gasit cu elementul aflat in capatul
din stanga, in pozitia 0. La fiecare pas, algoritmul gaseste elementul minim din
partea nesortata si il adauga la finalul partii sortate. Cand partea nesortata ramane
goala, algoritmul se opreste
V3: cicleaza printre valorile tabloului, comparand valori vecine si deplasand valorile
cele mai mari in partea dreapta
V4: presupune impartirea tabloului imaginar intr-o parte sortata si una
nesortata. La inceput, partea sortata contine primul element al tabloului si
partea nesortata contine restul tabloului. La fiecare pas, algoritmul ia
primul element din partea nesortata si il insereaza in locul potrivit al partii
sortate. Cand partea nesortata nu mai are nici un element, algoritmul se
opreste
R: 4
P: 2
I: Urmatorul cod reprezinta sortarea
[pre][code]public void Sort() {
int in, out;
for(out=1; out<nElems; out++) {
long temp = a[out];
in = out;
while(in>0 && a[in-1] >= temp) {
System.out.println("Mut "+a[in]+ " cu "+a[in-1]);
a[in] = a[in-1];
--in;
}
a[in] = temp;
display();
}
}[/code][/pre]

V1: prin metoda bulelor

V2: prin selectie
V3: prin insertie
V4: unor obiecte
R: 3
P:2
I: Care din urmatoarele sunt adevarate privind compararea algoritmilor simplii de
sortare?
V1: In ceea ce priveste viteza, sortarea prin insertie este cel mai eficient
dintre algoritmi
V2: Metoda de sortare prin insertie este mai putin eficienta in ceea ce priveste
utilizarea memoriei
V3: Sortarea prin selectie este utila atunci cand volumul de date este mare si
permutarea datelor consuma putin timp in raport cu efectuarea de comparatii
V4: Sortarea prin selectie este, pentru date alese la intamplare de doua ori mai
rapida decat sortarea prin insertie
R: 1

(Capitolul 9 Metoda Divide et Impera, metoda Greedy si Metoda Backtracking)

P: 2
I: Divide et Impera
V1: se refera la o clasa de algoritmi care au ca principale caracteristici
faptul ca impart problema in subprobleme similare cu problema initiala
dar mai mici ca dimensiune, rezolva subproblemele recursive obtinanduse
solutiile acestora si apoi combina solutiile subproblemelor obtinanduse
solutia problemei
V2: gaseste un anumit element intr-un tablou ordonat, utilizand un numar minim de
comparatii
V3: cicleaza printre valorile tabloului, comparand valori vecine si deplasand valorile
cele mai mari in partea dreapta
V3: lucreaza in iteratii. In prima iteratie se aplica un insertionSort cu salt s1 mai
mare decat 1. Asta inseamna ca fiecare element din sirul initial este deplasat spre
stanga cu cate s1 pozitii atat timp cat intalneste elemente mai mari decat el. Se
repeta asemenea iteratii cu salturi din ce in ce mai mici, s3, s4, etc. Ultima iteratie
se face cu saltul 1. Aceasta ultima iteratie este practic un insertionSort clasic
V4: construieste solutia in mod progresiv, prin adaugarea cate unei componente la o
solutie partiala care reprezinta o selectie din primele oferte, astfel incat sa
reprezinte de asemeni o solutie partiala
R: 1
P: 2

I: Metoda Greedy
V1: se refera la o clasa de algoritmi care au ca principale caracteristici faptul ca
impart problema in subprobleme similare cu problema initiala dar mai mici ca
dimensiune, rezolva subproblemele recursive obtinanduse solutiile acestora si apoi
combina solutiile subproblemelor obtinanduse solutia problemei
V2: lucreaza in iteratii. In prima iteratie se aplica un insertionSort cu salt s1 mai
mare decat 1. Asta inseamna ca fiecare element din sirul initial este deplasat spre
stanga cu cate s1 pozitii atat timp cat intalneste elemente mai mari decat el. Se
repeta asemenea iteratii cu salturi din ce in ce mai mici, s3, s4, etc. Ultima iteratie
se face cu saltul 1. Aceasta ultima iteratie este practic un insertionSort clasic
V3: se utilizeaza in cazul in care se face construirea unei solutii prin
parcurgerea in etape a unor solutii partiale. La fiecare pas se alege o
solutie partiala, pe baza careia se va face cautarea in pasul urmator.
Metoda pleaca de la ideea ca, daca in fiecare pas se alege o solutie optima
pentru pasul respectiv exista, o sansa buna de obtinere a unei solutii
optime in final
V4: construieste solutia progresiv, prin adaugarea cate unei componente la o solutie
partiala care reprezinta o selectie din primele oferte, astfel incat sa reprezinte de
asemeni o solutie partiala
R: 3
P: 2
I: In metoda Backtracking
V1: algoritmul imparte tabloul in doua, observand in care dintre cele doua jumatati
este valoarea cautata, imparte apoi din nou acea jumatate in doua. La fiecare pas,
algoritmul compara valoarea cautata cu valoarea din mijlocul vectorului. Daca se
potrivesc atunci indicele sau pozitia valorii in vector este returnata. In caz contrar se
cauta in subvectorul din stanga valorii din mijloc, daca valoarea cautata este mai
mica decat cea din mijloc, sau in subvectorul din dreapta, daca este mai mare.
Operatia de cautare consta in identificarea subvectorului in care se poate gasi
elementul, prin compararea valorii cautate cu cea din mijloc, dupa care se divizeaza
acest subvector in doi subvectori s.a.m.d. pana cand se gaseste elementul, sau
pana cand nu se mai poate face impartirea in subvectori, ceea ce inseamna ca nu sa gasit elementul
V2: solutia este construita in mod progresiv, prin adaugarea cate unei
componente la o solutie partiala care reprezinta o selectie din primele
oferte, astfel incat sa reprezinte de asemeni o solutie partiala
V3: la fiecare pas se alege o solutie partiala, pe baza careia se va face cautarea in
pasul urmator. Metoda pleaca de la ideea ca, daca in fiecare pas se alege o solutie
optima pentru pasul respectiv exista, o sansa buna de obtinere a unei solutii optime
in final
V4: se lucreaza in iteratii. In prima iteratie se aplica un insertionSort cu salt s1 mai
mare decat 1. Asta inseamna ca fiecare element din sirul initial este deplasat spre
stanga cu cate s1 pozitii atat timp cat intalneste elemente mai mari decat el. Se

repeta asemenea iteratii cu salturi din ce in ce mai mici, s3, s4, etc. Ultima iteratie
se face cu saltul 1. Aceasta ultima iteratie este practic un insertionSort classic
R: 2

(Capitolul 10 Cautarea binara)

P: 1
I: Care din urmatoarele reprezinta avantajele cautarii binare?
V1: Numarul de pasi efectuati este acelasi cu numarul de comparari si este
[code]N(N+1)/2[/code] indiferent de structura datelor de intrare
V2: In procesul de cautare binara recursiv cheia cautata este gasita in
maximum [code]logN[/code] comparatii care este un castig deosebit fata
de cele [code]N/2[/code] comparatii ale cautarii secventiale
V3: Metoda este extrem de eficienta in ceea ce priveste utilizarea memoriei,
datorita faptului ca toate operatiunile de triere sunt efectuate pe multimea initiala
de date
V4: Pentru cazul unor elemente sortate in ordine inversa, sortarea prin insertie
ruleaza de trei ori mai rapid decat sortarea prin selectie
R: 2
P:2
I: Scopul cautarii binare este de a gasi un anumit element
V1: tinand cont de ordinea datelor de intrare
V2: intr-un tablou ordonat consumand un timp scurt in raport cu efectuarea
comparatiilor
V3: permutand cat mai putine elemente
V4: intr-un tablou ordonat, utilizand un numar minim de comparatii
R: 4
P: 2
I: Cautarea binara:
V1: construieste solutia progresiv, prin adaugarea cate unei componente la o solutie
partiala care reprezinta o selectie din primele oferte, astfel incat sa reprezinte de
asemeni o solutie partiala
V2: se utilizeaza in cazul in care se face construirea unei solutii prin parcurgerea in
etape a unor solutii partiale. La fiecare pas se alege o solutie partiala, pe baza
careia se va face cautarea in pasul urmator. Metoda pleaca de la ideea ca, daca in
fiecare pas se alege o solutie optima pentru pasul respectiv exista, o sansa buna de
obtinere a unei solutii optime in final
V3: algoritmul imparte tabloul in doua, observand in care dintre cele doua
jumatati este valoarea cautata, imparte apoi din nou acea jumatate in
doua. La fiecare pas, algoritmul compara valoarea cautata cu valoarea din
mijlocul vectorului. Daca se potrivesc atunci indicele sau pozitia valorii in

vector este returnata. In caz contrar se cauta in subvectorul din stanga

valorii din mijloc, daca valoarea cautata este mai mica decat cea din
mijloc, sau in subvectorul din dreapta, daca este mai mare. Operatia de
cautare consta in identificarea subvectorului in care se poate gasi
elementul, prin compararea valorii cautate cu cea din mijloc, dupa care se
divizeaza acest subvector n doi subvectori s.a.m.d. pana cand se gaseste
elementul, sau pana cand nu se mai poate face impartirea in subvectori,
ceea ce inseamna ca nu s-a gasit elementul
V4: lucreaza in iteratii. In prima iteratie se aplica un insertionSort cu salt s1 mai
mare decat 1. Asta inseamna ca fiecare element din sirul initial este deplasat spre
stanga cu cate s1 pozitii atat timp cat intalneste elemente mai mari decat el. Se
repeta asemenea iteratii cu salturi din ce in ce mai mici, s3, s4, etc. Ultima iteratie
se face cu saltul 1. Aceasta ultima iteratie este practic un insertionSort classic
R: 3
P: 2
I: Urmatorul cod reprezinta
[pre][code]private int functie(long searchKey, int lowerBound,int upperBound) {
int curIn;
curIn = (lowerBound + upperBound ) / 2;
if(a[curIn]==searchKey)
return curIn;
else if(lowerBound > upperBound)
return nElems;
else {
if(a[curIn] < searchKey)
return recFind(searchKey, curIn+1, upperBound);
else
return recFind(searchKey, lowerBound, curIn-1);
}
}[/code][/pre]
V1: cautarea binara
V2: sortarea prin metoda shellsort
V3: partitionarea
V4: sortarea rapida
R: 1

(Capitolul 11 Metoda Shellsort)

P:1
I: Algoritmul Shellsort are preformante bune pentru tablouri de dimensiuni
V1: foarte mici, cu mai putin de 15 elemente
V2: de maxim 300 de elemente

V3: medii, pana la cateva mii de elemente

V4: mari, pana la cateva milioane de elemente
R: 3
P:2
I: Metoda Shellsort
V1: se refera la o clasa de algoritmi care au ca principale caracteristici faptul ca
impart problema in subprobleme similare cu problema initiala dar mai mici ca
dimensiune, rezolva subproblemele recursive obtinanduse solutiile acestora si apoi
combina solutiile subproblemelor obtinanduse solutia problemei
V2: gaseste un anumit element intr-un tablou ordonat, utilizand un numar minim de
comparatii
V3: construieste solutia progresiv, prin adaugarea cate unei componente la o solutie
partiala care reprezinta o selectie din primele oferte, astfel incat sa reprezinte de
asemeni o solutie partiala
V4: lucreaza in iteratii. In prima iteratie se aplica un insertionSort cu salt
s1 mai mare decat 1. Asta inseamna ca fiecare element din sirul initial
este deplasat spre stanga cu cate s1 pozitii atat timp cat intalneste
elemente mai mari decat el. Se repeta asemenea iteratii cu salturi din ce
in ce mai mici, s3, s4, etc. Ultima iteratie se face cu saltul 1. Aceasta
ultima iteratie este practic un insertionSort clasic
R: 4
P: 2
I: Urmatoarea secventa de instructiuni reprezinta
[pre][code]public void Sort() {
int inner, outer;
long temp;
int h = 1;
while(h <= nElems/3)
h = h*3 + 1;
while(h>0) {
for(outer=h; outer<nElems; outer++) {
temp = theArray[outer];
inner = outer;
display();
while(inner > h-1 && theArray[inner-h] >= temp) {
theArray[inner] = theArray[inner-h];
inner -= h;
}
theArray[inner] = temp;
}
h = (h-1) / 3;
}
}[/code][/pre]

V1: cautarea binara

V2: sortarea prin metoda shellsort
V3: partitionarea
V4: sortarea rapida
R: 2
(Capitolul 12 Partitionarea)
P:1
I: In urma partitionarii, tabloul
V1: nu se divide neaparat in doua parti egale
V2: se divide in doua parti care au aceeasi dimensiune
V3: este sortat crescator
V4: este impartit in doua tablouri ordonate
R: 1
P:1
I: Dupa efectuarea partitionarii, datele
V1: sunt impartite in doua clase ordonate
V2: sunt impartite in doua clase
V3: sunt sortate crescator
V4: nu sunt sortate, ci doar impartite in doua clase
R: 4
P: 2
I: Partitionarea unui vector in raport cu un pivot, presupune separarea vectorului in
doua zone astfel incat prima partitie sa contina elementele
V1: > cu pivotul, iar cea dea doua partitie, elementele <= decat pivotul. Pivotul
este ultimul element din tablou. Extinderea unei partitii este impiedicata de
prezenta unui element care nu apartine partitiei. In momentul in care se blocheaza
extinderea ambelor partitii se interschimba elementele straine partitiilor, dupa care
extinderea partitiilor continua pana la atingere
V2: <= cu pivotul, iar cea dea doua partitie, elementele > decat pivotul.
Pivotul poate fi oricare element x. Extinderea unei partitii este impiedicata
de prezenta unui element care nu apartine partitiei. In momentul in care
se blocheaza extinderea ambelor partitii se interschimba elementele
straine partitiilor, dupa care extinderea partitiilor continua pana la
atingere
V3: > cu pivotul, iar cea dea doua partitie, elementele <= decat pivotul. Pivotul
este elementul din mijlocul tabloului. Extinderea unei partitii este impiedicata de
prezenta unui element care nu apartine partitiei. In momentul in care se blocheaza
extinderea ambelor partitii se interschimba elementele straine partitiilor, dupa care
extinderea partitiilor continua pana la atingere

V4: <= cu pivotul, iar cea dea doua partitie, elementele > decat pivotul. Pivotul
este primul element din tablou. In momentul in care se blocheaza extinderea
ambelor partitii se interschimba elementele partitiilor, dupa care extinderea
partitiilor continua pana la atingere
R: 2
P: 2
I: Urmatoarea secventa de instructiuni reprezinta
[pre][code]public int functie(int left, int right, long pivot) {
int leftPtr = left - 1;
int rightPtr = right + 1;
while(true) {
while(leftPtr < right && theArray[++leftPtr] < pivot);
while(rightPtr > left && theArray[--rightPtr] > pivot);
if(leftPtr >= rightPtr)
break;
else
swap(leftPtr, rightPtr);
}
return leftPtr;
}[/code][/pre]
V1: cautarea binara
V2: sortarea prin metoda shellsort
V3: partitionarea
V4: sortarea rapida
R: 3
P:2
I: Metoda de alegere a pivotului pentru partitionarea cu schema mediei in trei este
alegerea valorii
V1: mediane intre primul si ultimul element
V2: mediane intre valoarea minima si valoarea maxima a tabloului
V3: mediane a tabloului
V4: mediane intre primul, ultimul si elementul din mijlocul tabloului
R: 4
P: 3
I: Urmatorul cod reprezinta
[pre][code]public int Sort(int left, int right) {
int size = right - left + 1;
if (size <= 3)
fSort(left, right);
else {
long q = functie(left, right);

int p = prtI(left, right, p);

Sort(left, p-1);
Sort(p+1, right);
}
}
public long functie(int left, int roght) {
int center = (left+right)/2;
if(theArray[left] > theArray[center] )
swap(left, center);
if(theArray[left] > theArray[right] )
swap(left, right);
if(theArray[center] > theArray[right] )
swap(center, right);
swap(center, right-1);
return theArray(right-1];
}
public void fSort(int left, int right) {
int size = right - left +1;
if(size<=1)
return;
if(size==2) {
if(theArray[left] > theArray[right] )
swap(left, right);
return;
}
else {
if(theArray[left] > theArray[right-1] )
swap(left, right-1);
if(theArray[left] > theArray[right] )
swap(left, right);
if(theArray[right-1] > theArray[right] )
swap(right-1, right);
}
}[/code][/pre]
V1: cautarea binara
V2: partitionarea cu schema mediei in trei
V3: sortarea prin metoda shellsort
V4: sortarea rapida
R: 2

(Capitolul 13 Sortarea rapida)

P: 1

I: Quicksort este sensibil la

V1: volumul de date
V2: permutarea datelor
V3: efectuarea comparatiilor
V4: ordinea datelor de intrare
R: 4
P: 2
I: Care sunt pasii algoritmului de sortare rapida?
V1: se imparte tabloul intr-o parte sortata si una nesortata. La fiecare pas,
algoritmul ia primul element din partea nesortata si il insereaza in locul potrivit al
partii sortate. Cand partea nesortata nu mai are nici un element, algoritmul se
opreste
V2: se alege o valoare pivot. Partitionarea tabloului in doua grupe: cea din
stanga si cea din dreapta. Apelul recursiv pentru sortarea celor doua
grupuri: stang si drept
V3: in prima iteratie se aplica o sortare rapida cu salt s1 mai mare dect 1. Asta
inseamna ca fiecare element din sirul initial este deplasat spre stanga cu cate s1
pozitii atat timp cat intalneste elemente mai mari decat el. Se repeta asemenea
iteratii cu salturi din ce in ce mai mici, s3, s4, etc. Ultima iteratie se face cu saltul 1.
Aceasta ultima iteratie este practic o sortare rapida clasica
V4: Algoritmul pleaca de la ideea ca, daca in fiecare pas se alege o solutie optima
pentru pasul respectiv; astfel exista, o sansa buna de obtinere a unei solutii optime
in final
R: 3
P: 2
I: Urmatoarea secventa de instructiuni reprezinta sortarea
[pre][code]public void Sort(int left, int right) {
if(right-left <= 0)
return;
else {
long pivot = theArray[right];
int par = parIt(left, right, pivot);
Sort(left, par-1);
Sort(par+1, right);
}
}[/code][/pre]
V1: prin insertie
V2: sortarea rapida
V3: prin selectie
V4: prin metoda shellsort
R: 2

(Capitolul 14 Arbori binari)

P: 1
I: Care din urmatoarele reprezinta proprietatile arborilior binari?
V1: Un arbore binar de inaltime [code]h[/code] are cel mult
[code]2^h[/code] noduri pe ultimul nivel. Ultimul nivel este [code]h[/code]
V2: Exista cel mult [code]2^i-1[/code] noduri pe nivelul [code]i[/code] al arborelui
V3: Daca [code]a[/code] este numarul nodurilor terminale si [code]c[/code] este
numarul nodurilor care au exact 2 descendenti, atunci [code]a=c-1[/code]
V4: Un arbore binar de inaltime [code]h[/code] are cel mult [code][2^(h+1)]1[/code] noduri pe ultimul nivel. Ultimul nivel este [code]h[/code]
R: 1
P: 1
I: Daca nodurile i si j sunt adiacente, nodul
V1: aflat pe un nivel mai mic se numeste descendent, iar cel flat pe nivelul urmator
este ascendent
V2: [code]y[/code] este descendentul nodului [code]x[/code] daca este situat pe un
nivel mai mic decat nivelul lui [code]x[/code]
V3: aflat pe un nivel mai mic se numeste ascendent, iar cel flat pe nivelul
urmator este descendent
V4: [code]y[/code] este ascendentul nodului [code]z[/code] daca este situat pe un
nivel mai mare decat nivelul lui [code]z[/code]
R: 3
P: 1
I: Arborii generali, in care nodurile pot avea mai multi fii, se numesc arbori
V1: binari
V2: de tip B
V3: 2-3-4
V4: multicai
R: 4
P: 1
I: Prin arbore binar se intelege, un arbore
V1: cu radacina, in care fiecare nod are cel mult doua noduri descendente,
cel stang si cel drept

V2: in care fiecare nod are cel putin doi succesori

V3: ale carui noduri au o cheie de identificare, iar pentru orice cheie asociata unui
nod, aceasta din urma este mai mica decat cheia subordonatului stang si mai mare
decat cheia subordonatului drept
V4: ordonat in care fiecare nod are cel putin doi descendenti
R: 1

P: 1
I: Nivelul unui anumit nod reprezinta
V1: gradul nodului respectiv
V2: numarul de muchii parcurse pentru a ajunge de la radacina la acel nod
V3: raportul dintre numarul de elemente din arbore si inaltimea arborelui
V4: numarul de noduri parcurse pentru a ajunge la acel nod
R: 2
P: 1
I: Caracteristica esentiala a unui arbore binar de cautare este
V1: urmatoarea: cheia fiului stang trebuie sa fie mai mica decat cea a
parintelui, iar cheia fiului drept trebuie sa fie mai mare sau egala cu cea a
parintelui
V2: aceea ca, parcurgand nodurile sale in inordine, secventa cheilor este monoton
descrescatoare
V3: urmatoarea: cheia fiului stang trebuie sa fie mai mare decat cea a parintelui, iar
cheia fiului drept trebuie sa fie mai mica sau egala cu cea a parintelui
V4: aceea ca, parcurgand nodurile sale in preordine, secventa cheilor este ordonata
R: 1
P: 1
I: Care din urmatoarele este o proprietate a arborilior binari?
V1: Un arbore binar cu inaltimea [code]h[/code] are cel mult [code]2^(h+1)[/code]
noduri
V2: Daca [code]a[/code] este numarul nodurilor terminale si [code]c[/code]
este numarul nodurilor care au exact 2 descendenti, atunci
[code]a=c+1[/code]
V3: Un arbore binar de inaltime [code]h[/code] are cel mult [code]2^h+1[/code]
noduri pe ultimul nivel. Ultimul nivel este [code]h[/code]
V4: Exista cel mult [code]2i[/code] noduri pe nivelul [code]i[/code] al arborelui
R: 2
P: 1
I: Care din urmatoarele reprezinta proprietatile arborilior binari?
V1: Daca [code]a[/code] este numarul nodurilor terminale si [code]c[/code] este
numarul nodurilor care au exact 2 descendenti, atunci [code]a=c-1[/code]

V2: Exista cel mult [code]2^i-1[/code] noduri pe nivelul [code]i[/code] al arborelui

V3: Un arbore binar cu inaltimea [code]h[/code] are cel mult [code]
[2^(h+1)]-1[/code] noduri
V4: Un arbore binar de inaltime [code]h[/code] are cel mult [code]2h+1[/code]
noduri pe ultimul nivel. Ultimul nivel este [code]h[/code]
R: 3
P: 2
I: Urmatoarea secventa de instructiuni cauta un nod
[pre][code]public Node find(int p) {
Node current = root;
while(current.iData != p) {
if(p < current.iData)
current = current.leftChild;
else
current = current.rightChild;
if(current == null)
return null;
}
return current;
}[/code][/pre]
V1: aflat dupa altul cu o cheie precizata intr-un arbore multicai
V2: aflat inaintea altuia cu o cheie precizata intr-un arbore de tip B
V3: cu o cheia data intr-o tabela de dispersie
V4: cu o anumita cheie intr-un arbore binar
R: 4
P: 3
I: Urmatoarea secventa de instructiuni sterge nodul cu cheia data, pentru cazul in
care nodul:
[pre][code]public boolean delete(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = true;
while(current.iData != key) {
parent = current;
if(key < current.iData) {
isLeftChild = true;
current = current.leftChild;
}
else {
isLeftChild = false;
current = current.rightChild;
}

if(current == null)
return false;
}
Node successor = getSuccessor(current);
if(current == root)
root = successor;
else if(isLeftChild)
parent.leftChild = successor;
else
parent.rightChild = successor;
successor.leftChild = current.leftChild;
return true;
}[/code][/pre]
V1: nu are fiu stang
V2: are doi fii
V3: nu are fiu drept
V4: nu are fii
R: 2
P: 3
I: Urmatoarea secventa de instructiuni sterge nodul cu cheia data, pentru cazul in
care nodul:
[pre][code] public boolean delete(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = true;
while(current.iData != key) {
parent = current;
if(key < current.iData) {
isLeftChild = true;
current = current.leftChild;
}
else {
isLeftChild = false;
current = current.rightChild;
}
if(current == null)
return false;
}
if(current.leftChild==null && current.rightChild==null) {
if(current == root)
root = null;
else if(isLeftChild)
parent.leftChild = null;

else
parent.rightChild = null;
}
}[/code][/pre]
V1: are doi fii
V2: nu are fiu stang
V3: nu are fiu drept
V4: nu are fii
R: 4
P:3
I: Urmatorul cod sterge nodul cu chia data, pentru cazul in care nodul
[pre][code]
public boolean delete(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = true;
while(current.iData != key) {
parent = current;
if(key < current.iData) {
isLeftChild = true;
current = current.leftChild;
}
else {
isLeftChild = false;
current = current.rightChild;
}
if(current == null)
return false;
}
if(current.rightChild==null)
if(current == root)
root = current.leftChild;
else if(isLeftChild)
parent.leftChild = current.leftChild;
else
parent.rightChild = current.leftChild;
}[/code][/pre]
V1: are doi fii
V2: nu are fiu stang
V3: nu are fiu drept
V4: nu are fii
R: 3

P: 3
I: Urmatorul cod:
[pre][code]public void functie(int id, double dd) {
Node newNode = new Node();
newNode.iData = id;
newNode.dData = dd;
if(root==null)
root = newNode;
else {
Node current = root;
Node parent;
while(true) {
parent = current;
if(id < current.iData) {
current = current.leftChild;
if(current == null) {
parent.leftChild = newNode;
return;
}
}
else {
current = current.rightChild;
if(current == null) {
parent.rightChild = newNode;
return;
}
}
}
}
}[/code][/pre]
V1: insereaza un element intr-un arbore binar
V2: sterge un element intr-un arbore binar
V3: cauta un element cu o anumita cheie intr-un arbore binar
V4: determina nodurile care se gasesc pe un nivel dat
R: 1
P: 3
I: Urmatoarea secventa de instructiuni determina:
[pre][code]private Node getF(Node delNode) {
Node qParent = delNode;
Node q = delNode;
Node current = delNode.rightChild;
while(current != null) {
qParent = q;

q = current;
current = current.leftChild;
}
if(q != delNode.rightChild) {
qParent.leftChild = q.rightChild;
q.rightChild = delNode.rightChild;
}
return q;
}[/code][/pre]
V1: daca nodul cautat are doi fii
V2: succesorul unui nod precizat
V3: parintele unui nod dat
V4: predecesorul unui nod dat
R: 2
P: 3
I: Urmatoarea secventa de instructiuni sterge nodul cu o cheie data, pentru cazul in
care nodul
[pre][code ]public boolean delete(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = true;
while(current.iData != key) {
parent = current;
if(key < current.iData) {
isLeftChild = true;
current = current.leftChild;
}
else {
isLeftChild = false;
current = current.rightChild;
}
if(current == null)
return false;
}
if(current.leftChild==null)
if(current == root)
root = current.rightChild;
else if(isLeftChild)
parent.leftChild = current.rightChild;
else
parent.rightChild = current.rightChild;
}[/code][/pre]
V1: nu are fiu drept

V2: are fii

V3: nu are fiu stang
V4: nu are fii
R: 3

(Capitolul 15 Modalitati de parcurgere a arborilor binari)

P: 1
I: Traversarea in inordine trebuie sa efectueze doar trei operatii. Care este ordinea
acestora?
V1: Vizitarea nodului curent, varful. Apelul recursiv pentru a traversa subarborele
stang al nodului. Apelul recursiv pentru a traversa subarborele drept al nodului.
V2: Apel recursiv pentru a traversa subarborele stang al nodului. Vizitarea
nodului current, varful. Un apel recursiv pentru a traversa subarborele
drept al nodului.
V3: Apel recursiv pentru a traversa subarborele stang al nodului. Apel recursiv
pentru a traversa subarborele drept al nodului. Vizitarea nodului current, varful.
V4: Apel recursiv pentru a traversa subarborele drept al nodului. Apel recursiv
pentru a traversa subarborele stang al nodului. Vizitarea nodului current, varful.
R: 2
P: 1
I: Traversarea in preordine trebuie sa efectueze doar trei operatii. Care este ordinea
acestora?
V1: Vizitarea nodului curent, varful. Apelul recursiv pentru a traversa
subarborele stang al nodului. Apelul recursiv pentru a traversa
subarborele drept al nodului.
V2: Apel recursiv pentru a traversa subarborele stang al nodului. Apel recursiv
pentru a traversa subarborele drept al nodului. Vizitarea nodului current, varful.
V3: Apel recursiv pentru a traversa subarborele stang al nodului. Vizitarea nodului
current, varful. Un apel recursiv pentru a traversa subarborele drept al nodului.
V4: Apel recursiv pentru a traversa subarborele drept al nodului. Apel recursiv
pentru a traversa subarborele stang al nodului. Vizitarea nodului current, varful.
R: 1
P: 1
I: Traversarea in postordine trebuie sa efectueze doar trei operatii. Care este ordinea
acestora?
V1: Apel recursiv pentru a traversa subarborele drept al nodului. Apel recursiv
pentru a traversa subarborele stang al nodului. Vizitarea nodului current, varful.
V2: Apel recursiv pentru a traversa subarborele stang al nodului. Vizitarea nodului
current, varful. Un apel recursiv pentru a traversa subarborele drept al nodului.

V3: Apel recursiv pentru a traversa subarborele stang al nodului. Apel

recursiv pentru a traversa subarborele drept al nodului. Vizitarea nodului
current, varful.
V4: Vizitarea nodului curent, varful. Apelul recursiv pentru a traversa subarborele
stang al nodului. Apelul recursiv pentru a traversa subarborele drept al nodului.
R: 3
P: 2
I: Urmatorul cod traverseaza arborele binar in:
[pre][code] private void traverse(Node localRoot) {
if(localRoot != null) {
traverse(localRoot.leftChild);
traverse(localRoot.rightChild);
System.out.print(localRoot.iData + " ");
}
}[/code][/pre]
V1: inordine
V2: preordine
V3: inaltime
V4: postordine
R: 4

Brez
1)P: 1
I: Inaltimea arborelui este
V1: diferenta dintre nivelul maxim din arbore si nivelul 1
V2: cel mai mare nivel pe care se afla un nod al sau
V3: lungimea drumului dintre radacina si lungimea penultimului varf
V4: maximul dintre inaltimile subarborilor sai -1
R: 2
2)P:1
I: Un nod este vizitat atunci cand
V1: drumul dintre alte doua noduri trece prin acel nod
V2: are gradul 1
V3: controlul programului este transmis acelui nod, in scopul executarii
unor operatii asupra nodului, cum ar fi verificarea valorii unuia din
campurile sale, sau afisarea informatiei utile a nodului
V4: permite existenta mai multor informatii si a mai multor fii pentru nodul respectiv
R: 3
3) P: 1
I: Care din urmatoarele reprezinta proprietatile arborilior binari?

V1: Un arbore binar de inaltime [code]h[/code] are cel mult [code]2h[/code] noduri
pe ultimul nivel. Ultimul nivel este [code]h[/code]
V2: Un arbore binar cu inaltimea [code]h[/code] are cel mult [code]2^h-1[/code]
noduri
V3: Daca a este numarul nodurilor terminale si c este numarul nodurilor care au
exact 2 descendenti, atunci a=c-1
V4: Exista cel mult [code]2^i[/code] noduri pe nivelul [code]i[/code] al
arborelui
R: 4
4) P: 1
I: Care din urmatoarele reprezinta proprietatile arborilior binari?
V1: Un arbore binar cu inaltimea [code]h[/code] are cel mult [code]
[2^(h+1)]-1[/code] noduri
V2: Exista cel mult [code]2^i-1[/code] noduri pe nivelul [code]i[/code] al arborelui
V3: Daca [code]a[/code] este numarul nodurilor terminale si [code]c[/code] este
numarul nodurilor care au exact 2 descendenti, atunci [code]a=c-1[/code]
V4: Un arbore binar de inaltime [code]h[/code] are cel mult [code]2h+1[/code]
noduri pe ultimul nivel. Ultimul nivel este [code]h[/code]
R: 1

5) P: 3
I: Urmatorul cod:
[pre][code]public void functie(int id, double dd) {
Node newNode = new Node();
newNode.iData = id;
newNode.dData = dd;
if(root==null)
root = newNode;
else {
Node current = root;
Node parent;
while(true) {
parent = current;
if(id < current.iData) {
current = current.leftChild;
if(current == null) {
parent.leftChild = newNode;
return;
}
}
else {

current = current.rightChild;
if(current == null) {
parent.rightChild = newNode;
return;
}
}
}
}
}[/code][/pre]
V1: determina nodurile de pe un nivel dat
V2: sterge un element intr-un arbore binar
V3: cauta un element cu o anumita cheie intr-un arbore binar
V4: insereaza un element intr-un arbore binar
R: 4

6) P: 3
I: Urmatoarea secventa de instructiuni sterge nodul cu o cheie data, pentru cazul in
care nodul
[pre][code ]public boolean functie(int key) {
Node current = root;
Node parent = root;
boolean isLeftChild = true;
while(current.iData != key) {
parent = current;
if(key < current.iData) {
isLeftChild = true;
current = current.leftChild;
}
else {
isLeftChild = false;
current = current.rightChild;
}
if(current == null)
return false;
}
if(current.leftChild==null)
if(current == root)
root = current.rightChild;
else if(isLeftChild)
parent.leftChild = current.rightChild;
else
parent.rightChild = current.rightChild;

}[/code][/pre]
V1: nu are fiu drept
V2: are fii
V3: nu are fiu stang
V4: nu are fii
R: 3

Traversarea arborilor binari

7) P: 2
I: Traversarea in preordine trebuie sa efectueze doar trei operatii. Care este ordinea
acestora?
V1: Vizitarea nodului curent, varful. Apelul recursiv pentru a traversa
subarborele stang al nodului. Apelul recursiv pentru a traversa
subarborele drept al nodului.
V2: Apel recursiv pentru a traversa subarborele stang al nodului. Apel recursiv
pentru a traversa subarborele drept al nodului. Vizitarea nodului current, varful.
V3: Un apel recursiv pentru a traversa subarborele stang al nodului. Vizitarea
nodului current, varful. Un apel recursiv pentru a traversa subarborele drept al
nodului.
V4: Apel recursiv pentru a traversa subarborele drept al nodului. Apel recursiv
pentru a traversa subarborele stang al nodului. Vizitarea nodului current, varful.
R: 1

8) P: 2
I: Urmatorul cod traverseaza arborele binar in:
[pre][code] private void traverse(Node localRoot) {
if(localRoot != null) {
System.out.print(localRoot.iData + " ");
traverse(localRoot.leftChild);
traverse(localRoot.rightChild);
}
}[/code][/pre]
V1: inordine
V2: preordine
V3: postordine
V4: adancime
R: 2

Calculul valorilor maxime si minime dintr-un arbore binar de cautare

9) P: 2
I: Urmatorul cod intoarce
[pre][code]public Node() {
Node current, last;
current = root;
while(current != null) {
last = current;
current = current.rightChild;
}
return last;
}[/code][/pre]
V1: nodurile frunza din arbore binar de cautare
V2: nodul cu valoarea maxima din arborele binar de cautare
V3: nodul cu valoarea minima din arborele binar de cautare
V4: nodurile tata din arbore binar de cautare
R: 2

10)P:3
I: Urmatoarea secventa de instructiuni determina numarul:
[pre][code]public void functie() {
displayTree();
int n = 0;
int nv=0;
int d = 0;
Stack globalStack = new Stack();
globalStack.push(root);
boolean isRowEmpty = false;
while (isRowEmpty == false) {
Stack localStack = new Stack();
isRowEmpty = true;
while (globalStack.isEmpty() == false) {
Node temp = (Node) globalStack.pop();
if (temp != null) {
localStack.push(temp.leftChild);
localStack.push(temp.rightChild);
if (temp.leftChild == null && temp.rightChild == null) {
++n;
System.out.println("Nodul
cu
cheia:
"+
temp.iData+ " de pe nivelul "+nv);

d += temp.iData;
}
if (temp.leftChild != null || temp.rightChild != null)
isRowEmpty = false;
}
else {
localStack.push(null);
localStack.push(null);
}
}
while (localStack.isEmpty() == false)
globalStack.push(localStack.pop());
nv++;
}
System.out.println("Numar : " + n);
System.out.println("Afiseaza: " + d);
}
V1: frunzelor din arborele binar, afiseaza cheile frunzelor arborelui binar si
suma cheilor frunzelor arborelui binar
V2: nodurilor de pe un nivel dat, afiseaza cheile nodurilor de pe nivelul precizat si
calculeaza suma cheilor de pe nivelul precizat
V3: nodurilor frati din arborele binar, afiseaza cheile acestor noduri si suma cheilor
nodurilor frati din arborele binar
V4: nodurilor tata si sa se precizeze daca nodul cu cheia data este fiu stang sau fiu
drept
R: 1

Alte tipuri de arbori

11) P:2
I: Arborii B sunt un alt tip de arbori multicai, utilizati pentru
V1: modelarea unor situatii din lumea reala
V2: a selecta cea mai buna directie de actiune in situatiile in care trebuie luata o
decizie
V3: cautarea anumitor informatii in fisiere de dimensiuni foarte mari
V4: organizarea datelor memorate pe suport extern
R: 4
12) P: 2
I: Intr-un arbore2-3-4 un nod care nu este frunza trebuie sa aiba
V1: numarul legaturilor catre fii egal cu numarul elementelor minus 1
V2: cu un fiu mai putin decat numarul de elemente pe care il contine

V3: numarul legaturilor catre fii egal cu numarul elementelor plus unu
V4: cu doi fii mai mult decat numarul de elemente pe care il contine
R: 3
13) P: 2
I: Urmatorul cod:
[pre][code]public Node (int childNum) {
Node tempNode = childArray[childNum];
childArray[childNum] = null;
return tempNode;
}[/code][/pre]
V1: cauta fiul corespunzator unui nod
V2: deconecteaza un fiul de la un nod, intorcandu-l
V3: cauta un nod cu o cheie precizata
V4: conecteaza un fiu la nodul current, intorcandu-l
R: 2

14) P: 2
I: Urmatorul cod
[pre][code] public int functie(long m) {
Node curNode = root;
int childNumber;
while(true) {
if(( childNumber=curNode.findItem(m) ) != -1)
return childNumber;
else if( curNode.isLeaf() )
return -1;
else
curNode = getNextChild(curNode, m);
}
}[/code][/pre]
V1: cauta un anumit element cu o anumita cheie
V2: insereaza un element
V3: cauta o frunzele din arbore
V4: insereaza un nou element in nod, deplasand elementele deja existente, dc este
cazul
R: 1
15) P: 1
I: Urmatoarea secventa de instructiuni
[pre][code]public Node functie(Node theNode, long theValue) {
int j;
int numItems = theNode.getNumItems();

for(j=0; j<numItems; j++) {

if( theValue < theNode.getItem(j).dData )
return theNode.getChild(j);
}
return theNode.getChild(j);
}[/code][/pre]
V1: cauta un element cu o valoare data
V2:
V3: intoarce fiul corespunzator al nodului in cautarea valorii theValue
V4: cauta un element cu o anumita cheie
R: 3

Arborii de tip B

16) P: 2
I: operatia de inserare intr-un arbore de tip B
V1: nu difera de inserarea in arborii 2-3-4
V2: B difera de inserarea in arborii 2-3-4 prin trei aspecte: Divizarea unui nod
imparte elementele in mod egal: jumatate sunt distribuite nodului nou creat, iar
cealalta jumatate raman in cel vechi. Divizarile din noduri se efectueaza atat de sus
in jos cat si de jos in sus. Elementul care va fi inserat in nodul parinte nu este cel din
mijlocul nodului divizat, ci cel din mijlocul secventie formate din elementele nodului
si noul element.
V3: B difera de inserarea in arborii 2-3-4 prin doua aspecte: Divizarile din noduri se
efectueaza atat de sus in jos cat si de jos in sus. Elementul care va fi inserat in
nodul parinte este cel partea dreapta a nodului divizat.
V4: B difera de inserarea in arborii 2-3-4 prin trei aspecte: Divizarea unui
nod imparte elementele in mod egal: jumatate sunt distribuite nodului nou
creat, iar cealalta jumatate raman in cel vechi. Divizarile din noduri se
efectueaza de jos in sus si nu invers. Elementul care va fi inserat in nodul
parinte nu este cel din mijlocul nodului divizat, ci cel din mijlocul secventie
formate din elementele nodului si noul element.
R: 4

Tabele de dispersie
17) P: 2
I: Forma polinomiala consta in:

V1: convertirea literelor unui cuvant in cifrele echivalente, inmultirea

fiecarui numar cu puterea corespunzatoare a lui
27 si adunarea
rezultatelor
V2: reprezentarea numerica a caracterelor unui cuvant folosind codificarea ASCII,
urmata de adunarea rezultatelor
V3: convertirea literelor unui cuvant in cifrele echivalente, inmultirea fiecarui numar
cu puterea corespunzatoare a lui 10 si adunarea rezultatelor
V4: reprezentarea numerica a caracterelor unui cuvant folosind codificarea ASCII,
urmata de inmultirea rezultatelor
R: 1
18) P: 2
I: Coliziunea apare atunci cand
V1: pentru doua cuvinte distincte se asociaza aceeasi celula dintr-un

tablou
V2: raportul dintre numarul de elemente dintr-o tabela de dispersie si dimensiunea
tabelei este mai mare decat 1
V3: se inlocuiesc celule distribuite pe o arie ceva mai larga cu celulele imediat
adiacente locului in care trebuie efectuata inserarea
V4: algoritmul de sondaj patratic genereaza intotdeauna aceiasi pasi
R: 1
19) P: 2
I: Sondajul este
V1:
V2:
V3:
V4: procedeul de cautare a celulei potrivite, in urma unei coliziuni
R: 4

20) P: 1
I: Urmatoarea secventa de instructiuni
[pre][code] public DataItem functie(int m) {

int Val = Func(m);

while(Array[Val] != null) {
if(Array[Val].getKey() == m)
return Array[Val];
++Val;
Val %= arraySize;
}
return null;

}[/code][/pre]
V1: cauta un element cu o valoare data intr-un arbore 2-3-4
V2: insereaza un element cu o cheie precizata intr-o tabela de dispersie
V3: cauta elementul cu cheia data intr-o tabela de dispersie
V4: insereaza un element cu o valoare precizata intr-un arbore 2-3-4
R: 3
21) P: 2
I: Acumularea secundara se produce din cauza faptului ca
V1: algoritmul de sondaj patratic genereaza intotdeauna aceiasi pasi
V2: raportul dintre numarul de elemente dintr-o tabela de dispersie si dimensiunea
tabelei este mai mare decat 1
V3: se inlocuiesc celule distribuite pe o arie ceva mai larga cu celulele imediat
adiacente locului in care trebuie efectuata inserarea
V4: se trece cheia prin functia de dispersie pentru a doua oara, cu o alta functie de
dispersie, utilizand rezultatul obtinut ca pas de deplasare
R: 1