Вы находитесь на странице: 1из 8

Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Raport
Lucrarea de laborator Nr.3,4
la Matematica Discreta
Arbori. Vizita in lime si in adincime

A efectuat: st. gr. TI-142

Roman Chicu

A verificat: conf. univ.

Cioban Gheorghe

Chiinu, 2015
Lucrare de laborator Nr.3,4
Notiuni teoretice :
Un arbore este o structur ramificat format dintr-un nod A (rdcina) si un numr
finit de arbori (subarbori) ai lui A.
- orice nod din arbore este rdcin pentru un subarbore iar orice arbore poate
deveni subarbore;
- doi subarbori pot fi n relatie de incluziune, cnd un subarbore este inclus n
cellalt sau de excluziune, cnd nu au noduri comune.
Definitii:
nod = punct n care se ntlnesc doi subarbori;
nivel = numrul de noduri parcurse de la rdcin pn la un nod;
rdcin = nivel 1;
descendent = primul nod al unui subarbore;
nod terminal = nod fr descendenti;
nltimea unui nod = numrul maxim de niveluri;
arbore binar = arbore n care toate nodurile au 2 descendenti;
Orice arbore binar are doi subarbori: stng si drept. Arborii binari pot fi arbori de cutare
si arbori de selectie; ei se caracterizeaz prin faptul c fiecare nod areo"cheie"
reprezentat printr-o informatie specific de identificare a nodului. Cheia permite
alegerea unuia din cei doi subarbori n functie de o decizie tip "mai mic", "mai mare",
etc.
Un arbore este echilibrat dac pentru orice subarbore diferenta dintre naltimile
subarborilor si este cel mult 1.
1. Parcurgerea arborilor
Prin parcurgerea arborelui ntelegem inspectarea (vizitarea) fiecrui nod si
prelucrarea informatiei specifice lui. Pentru un arbore dat, corespunztor unei anumite
aplicatii, se impune o anumit ordine de parcurgere.
n programe se utilizeaz algoritmi de parcurgere sistematic a arborilor
implementati sub form de proceduri. Procedurile eficiente de parcurgere genereaz liste
dinamice cu nodurile ce urmeaz a fi examinate, care sunt reactualizate dup examinarea
fiecrui nod; cnd lista devine vid operatia de parcurgere se ncheie (au fost examinate
toate nodurile). Posibilittile de parcurgere sunt:
1. n ltime , examinnd nodurile pe niveluri, n acelasi sens.

2. n adncime: de la rdcin spre nodurile terminale sau invers;


n cazul parcurgerii n ltime algoritmul contine operatiile:
- se examineaz nodul rdcin si se formeaz lista (coada) descen- dentilor si ntr-o
anumit ordine ( exemplu: de la stnga la dreapta) ;
- se examineaz primul nod din coada de asteptare si se adaug la coad
descendentii si n ordinea stabilit;
- se repet operatia precedent pn cnd coada devine vid.
n cazul parcurgerii n adncime, algoritmul contine operatiile:
- se examineaz nodul rdcin si se formeaz lista (stiva) descen- dentilor si ntr-o
anumit ordine ( exemplu: de la stnga la dreapta) ;
- se examineaz primul nod din stiva de asteptare si se introduc n stiv
descendentii nodului curent pn la cei terminali (ntregul subarbore);
- se repet operatia precedent pn cnd stiva devine vid.

Code:
//Lucrare de laborator Nr3 la Matematica Discreta
//Arbori. Vizita in latime si in adincime
#include<stdio.h>
#include<dos.h>
#include<conio.h>
#include<stdlib.h>
#include<alloc.h>
#define DIMENS_MAX 20
struct Graph// p/u lista de adiacenta
{
int v;
struct Graph *next;
};
struct Coada
{
int inf;
struct Coada *next;
};
Coada *top,*end;
int V;
int vizit_adinc[DIMENS_MAX];//tabloul vizitelor in adincime
int vizit_lat[DIMENS_MAX];//tabloul visitelor in latime
typedef Graph *legat;
legat lad[DIMENS_MAX],current;//lista de adiacenta
Coada *creare()
{
Coada *nod;
nod=(Coada *)malloc(sizeof(Coada));
return nod;
}
void inser(int info)
{
Coada *temp;

temp=creare();
end->inf=info;
end->next=temp;
temp->next=NULL;
end=temp;
}
int sc_coada()
{
Coada *temp=top;
int info=top->inf;
top=top->next;
free(temp);
return(info);
}
void Intr_Listei()
{
int i,j;
clrscr();
printf("Numarul de virfuri: ");
scanf("%d",&V);
for(i=0;i<V;i++)
{
printf("Virful.%d-> ",i+1);
lad[i]=current=(legat)malloc(sizeof(Graph));
l13:
scanf("%d",&current->v);
if(current->v>V)
{
puts("Ati introdus un numar prea mare...");
goto l13;
}
while(current->v)
{
current->next=(legat)malloc(sizeof(Graph));
current=current->next;
l11:
scanf("%d",&current->v);
if(current->v>V)
{
puts("Ati introdus un numar prea mare...");
goto l11;
}
}
current->next=NULL;
}
}
void Caut_Adinc_Prim(int Virf)
{
void Travers_Adinc(int k);
for(int i=0;i<Virf;i++)
if(vizit_adinc[i]==0)
Travers_Adinc(i+1);
}
void Travers_Adinc(int k)

{
printf("%4d",k);
vizit_adinc[k-1]=1;
for(legat t=lad[k-1];t!=0;t=t->next)
if(!vizit_adinc[t->v-1]) Travers_Adinc(t->v);
}
void Caut_Lat_Prim(int Virf)
{
void Travers_Adinc(int k);
for(int i=0;i<Virf;i++)
if(vizit_lat[i]==0)
Travers_Adinc(i+1);
}
void Travers_Latime(int k)
{
inser(k);
while(top!=end)
if(vizit_lat[(k=sc_coada())-1]==0)
{
printf("%4d",k);
vizit_lat[k-1]=1;
for(legat t=lad[k-1];(t->next)!=0;t=t->next)
if(vizit_lat[t->v-1]==0) inser(t->v);
}
}
void Caut_Adincime()
{
int optiune;
clrscr();
l12:
printf("Introdu capul arborelui: ");
scanf("%d",&optiune);
if(optiune>V)
{
printf("Ati introdus un numar prea mare");
goto l12;
}
Travers_Adinc(optiune);
Caut_Adinc_Prim(V);
}
void Caut_Largime()
{
int optiune;
clrscr();
printf("Introdu capul arborelui: ");
scanf("%d",&optiune);
Travers_Latime(optiune);
Caut_Lat_Prim(V);
//printf("\nTastati orice tasta pentru a continua...");
}
void Anulare_Adincime()
{
int i;

for(i=0;i<DIMENS_MAX;i++)
vizit_adinc[i]=0;
}
void Anulare_Largime()
{
int i;
for(i=0;i<DIMENS_MAX;i++)
vizit_lat[i]=0;
}
void Prezt()
{ clrscr();
_setcursortype(_NOCURSOR);
printf("\n\n\n\n\t\t");
textcolor(2); cprintf("Lucrare de laborator Nr3 la Matematica Discreta");
printf("\r\n\n\t\t");
cprintf("
Chicu Roman gr.TI-142");
printf("\r\n\n\t\t");
cprintf("Arbori. Vizita in largime si in adincime");
textcolor(2);
getch();
}
void main()
{
int k=1;
char c; clrscr();
Prezt();
l:clrscr();
textcolor(2);
textbackground(0);
while (1)
{
clrscr();
puts("1. Introduceti lista de adiacenta");
puts("2. Vizita in adincime");
puts("3. Vizita in largime");
puts("0. Exit");
scanf("%d",&k);
switch (k)
{
case 1: _setcursortype(_NORMALCURSOR);
Intr_Listei();
break;
case 2: _setcursortype(_NORMALCURSOR);
Caut_Adincime();
Anulare_Adincime();
getch();
break;
case 3: _setcursortype(_NORMALCURSOR);
Caut_Largime();
Anulare_Largime();
getch();
break;
case 0: exit(0);
break;

}
}
}

Listing-ul programului
Rezultatele obtinute
Varianta 18

Vizita in adincime:

Concluzie: n rezultatul acestei lucrri de laborator am studiat metodele de parcurgere n graf, adica
in adincime si largime. A fost alcatuit programul care permite introducerea a unui graf in calculator,
parcurgerea acestuia in adincime, largime si vizualizarea rezultatelor pe ecran.