TEORIE EXAMEN SDA

//==========================================================
1) Arbore binar total echilibrat
Un arbore binar total echilibrat este un arbore binar care ndeplinete urmtoarea
condiie:
numrul nodurilor unui oricare subarbore stng difer cu cel mult 1 n plus fa de
numrul
nodurilor subarborelui corespunztor drept.
Rezult c frunzele sale se afl pe ultimele dou niveluri.
//==========================================================
2) Subgraf indus
Un graf G =(V, E) este subgraf al lui G daca VC V i EC E. Se spune c
subgraful indus de VC V este G =(V, E ^(VX V)).
//==========================================================
3) Chei sinonime
Funcia f nu este injectiv .Dou chei pentru care f(k1)=f(k2) se spune c intr n
coliziune, iar nregistrrile respective se numesc sinonime.
//==========================================================
4) Arborele de acoperire de cost minim
Fie G =(N, R) un graf neorientat conex. Fiecrei muchii (i, j)R i se asociaz un
cost c[i][j]>0. Problema const n a determina un graf parial conex A = (N, T),
astfel nct suma costurilor muchiilor din T s fie minim. Se observ imediat c
acest graf parial este chiar arborele de acoperire.
//==========================================================

5) Arbore binar de cautare cautare nod cheie NERECURSIVA

TIP_NOD *cautare (TIP_NOD *rad, int key)
{
TIP_NOD *p;
if (rad==0) return 0
p=rad;
while (p!=0)
{
if (p->cheie==key) return p
else if (key<p->cheie) p=p->stg
else p=p->dr;
}
return 0;
}
//==========================================================
6) Reguli de stergere a unui nod intr-un arbore binar de cautare
La tergerea unui nod de cheie dat intervin urmtoarele cazuri:
a)
Nodul de ters este un nod frunz. n acest caz, n nodul tat, adresa
nodului fiu de ters (stng sau drept) devine zero.
b)
Nodul de ters este un nod cu un singur descendent. n acest caz, n
nodul tat,
adresa nodului fiu de ters se nlocuiete cu adresa descendentului nodului fiu de
ters.
c)
Nodul de ters este un nod cu doi descendeni. n acest caz, nodul de
ters se nlocuiete cu nodul cel mai din stnga al subarborelui drept sau cu nodul
cel mai din dreapta al subarborelui stng.
Algoritmul de tergere a unui nod conine urmtoarele etape:

cutarea nodului de cheie key i a nodului tat corespunztor;

determinarea cazului n care se situeaz nodul de ters.
//==========================================================

7) Tabele de dispersie
functie stergere
void stergereNod(char* key)
{
NOD* p;
NOD* q = cautareNod(key,&p);
int hash = getHash(key);
if(q == 0)
{
printf("\n Nodul nu exista\n");
return;
}
if(q == HashTable[hash])
{
HashTable[hash] = q->urm;
free(q);
return;
}
if(q->urm == 0)
{
p->urm = 0;
free(q);
return;
}
p->urm = q->urm;
free(q);
}

 functie cautare
tip_nod *cautare(char key)
{
int k;
tip_nod *p;
h=f(key);
p=HT(h);
while(p!=0)
{
if(strcmp(key,p->cheie)==0) return p;
p=p->urm;
}
return 0;
}
functie dispersie
#define M
int f(char *key)
{
int i,suma;
suma=0;
for(i=0;i<length(key);i++)
suma=suma+*(key+i);
return suma%M;
}

 functie inserare
tip_nod *inserare()
{
tip_nod *p,*q;
int h;
//alocare spatiu p;
h=f(p->cheie);
if (HT[h]==0)
{
HT[h]=p;//prima inreg cu codul de disp h
p->urm=0;
return p;
}
else
{
q=cautare(p->cheie);
if(q==0)
{//nu exista inreg cu cheie resp
p->urm=HT[h];
HT[h]=p;
return p;
}
else {
prelucare(p,q);
return p;
}
}
}

//==========================================================

8) Metode de sortare prin inserare -

+ complexitate

Inserare directa --- Timpul de prelucrare este de ordinul O(n2)

void sort_inserare_directa(int n,float a[nmax])
{
int i,j;
float x;
for(j=1;j<n;j++)
{
x=a[j]; i=j-1;
while((i>=0) && (x<a[i]))
{
a[i+1]=a[i];
i=i-1;
}
a[i+1]=x;
}
}

Inserarea binara --- Timpul de prelucrare este de ordinul O(n *lnn)

Metoda shell --- Timpul de prelucrare este de ordinul O(n *lnn)

void shell_sort(int n,float a[nmax])
/* SORTAREA PRIN METODA SHELL */
{
int i,j,incr;
float x;
incr=1;
while(incr<n)
incr=incr*3 + 1;
while(incr>=1)
{
incr=incr / 3;
for(i=incr;i<n;i++)
{
x=a[i];j=i;
while(a[j-incr]>x)
{
a[j]=a[j-incr];
j=j-incr;
if(j<incr) break;
};
a[j]=x;
}
}
}
//==========================================================
9) Inregistrari sinonime in TD
Daca pentru 2 chei K1 si K2 apartine K avem f(K1)=f(K2) spunem ca ele intra in
coliziune. Inregistrarile cu astfel de chei se numesc sinonime.
//==========================================================

10) Sortare prin selectie -

+ complexitate

Timpul de prelucrare este de ordinul O(n2).

{
int i,j,poz;
float x;
for(i=0;i<n-1;i++)
{
x=a[i];poz=i;
for(j=i+1;j<n;j++)
if(a[j]<x) {
x=a[j];
poz=j;
}
a[poz]=a[i];a[i]=x;
}
}
//==========================================================
11) Arbore binar de cautare optimal
Se numete arbore optimal, un arbore binar de cutare care pentru anumite valori
pi, qi date realizeaz un cost minim
//==========================================================
12) Arbore binar de cautare AVL
Un arbore este echilibrat daca pentru fiecare nod inaltimea celor doi sub-arbori ai
sai difera prin cel mult unu

//==========================================================

13) Sortare prin numarare

Timpul de prelucrare este de ordinul O(n2).
void sort_numarare(int n,float a[nmax])
{
int i,j;
float b[nmax];
int c[nmax];
for(i=0;i<n;i++)
{
c[i]=0;
b[i]=a[i];
}
for(j=1;j<n;j++)
for(i=0;i<=j-1;i++)
if(a[i]<a[j]) c[j]++;
else c[i]++;
for(i=0;i<n;i++)
a[c[i]]=b[i];
}

//==========================================================

13) Sortare prin interschimbare

Metoda bulelor --- Timpul de prelucrare este de ordinul O(n2).
void sort_metoda_bulelor(int n,float a[nmax])
{
int i,j,gata;
float x;
j=0;
do{
gata=1;
j=j+1;
for(i=0;i<n-j;i++)
if(a[i]>a[i+1]){
gata=0;
x=a[i];a[i]=a[i+1];a[i+1]=x;
};
}while(gata==0);
}

Metoda quicksort --- Timpul de prelucrare este de ordinul O(n* lnn).

void quick(int prim,int ultim,float a[nmax])

{
int i,j;
float pivot,x;
i=prim;j=ultim;
pivot=a[(prim + ultim) / 2];
do{
while(a[i]<pivot) i++;
while(a[j]>pivot) j--;
if(i<=j) {
x=a[i];a[i]=a[j];a[j]=x;
i++;j--;
};
}while(i<=j);
if(prim<j) quick(prim,j,a);
if(i<ultim) quick(i,ultim,a);
}
void quicksort(int n,float a[nmax])
/* SORTAREA RAPIDA QUICKSORT */
{
quick(0,n-1,a);
}

//==========================================================
13) Sortare prin interclasare

void divide_impera(int inf,int sup)

{
int med;
if(inf<sup) {
med=(inf+sup) / 2;
divide_impera(inf,med);
divide_impera(med+1,sup);
comb(inf,med,sup);
}
}