Ministerul Educaiei a Republicii Moldova

Universitatea Tehnic a Moldovei

Lucrare de laborator la
Matematica discret

Lucrare de laborator nr. 2

Tema: Algoritmul de cutare n lrgime i adncime.

A elaborat:

st. gr.C-051 Gherdelesco A.

A verificat:

G. Marusic

Chiinu 2006

SCOPUL LUCRRII:
Studierea algoritmilor de cutare n graf i a diferitor forme de pstrare i prelucrare a datelor.
Elaborarea procedurii de cutare n adncime si largime
1.

NOTE DE CURS

Structuri de date: liste

Fiecare tip de list definete o mulime de iruri finite de elemente de tipul declarat. Numrul de elemente care se numete
lungimea listei poate varia pentru diferite liste de acelai tip. Lista care nu conine nici un element se va numi vid. Pentru list
sunt definite noiunile nceputul, sfritul listei i respectiv primul i ultimul element, de asemenea elementul curent ca i
predecesorul i succesorul elementului curent. Element curent se numete acel unic element care este accesibil la momentul dat.
Structuri de date : fire de ateptare
Firele de ateptare (FA, rnd, coad, ir de ateptare) se vor folosi pentru a realiza algoritmul de prelucrare a elementelor listei n
conformitate cu care elementele vor fi eliminate din list n ordinea n care au fost incluse n ea (primul sosit - primul servit).
Operaiile de baz cu firele de ateptare:
Formarea unui FA vid;
Verificare dac FA nu este vid;
Alegerea primului element cu eliminarea lui din FA;
Introducerea unei valori noi n calitate de ultim element al FA.
Structuri de date: stive
Stiva se utilizeaz pentru a realiza algoritmul de prelucrare a elementelor dup principiul "ultimul sosit - primul prelucrat"
(LIFO).
Operaiile de baz cu stivele sunt urmtoarele:
Formarea unei stive vide;
Verificare la vid;
Alegerea elementului din topul stivei cu sau fr eliminare;
Introducerea unui element nou n topul stivei.
Structuri de date - arbori
Se va defini o mulime de structuri fiecare din care va consta dintr-un obiect de baz numit vrf sau rdcina arborelui dat i o
list de elemente din mulimea definit, care (elementele) se vor numi subarbori ai arborelui dat. Arborele pentru care lista
subarborilor este vid se va numi arbore trivial, iar rdcina lui - frunz.
Rdcina arborelui se va numi tatl vrfurilor care servesc drept rdcini pentru subarbori; aceste vrfuri se vor mai numi copiii
rdcinii arborelui: rdcina primului subarbore se va numi fiul cel mai mare, iar rdcina fiecrui subarbore urmtor n list se va
numi frate.
Operaiile de baz pentru arbori vor fi:
Formarea unui arbore trivial;
Alegerea sau nlocuirea rdcinii arborelui;
Alegerea sau nlocuirea listei rdcinilor subarborilor;
Operaiile de baz care sunt valabile pentru liste.

Algoritmul de cutare n adncime:

La cutarea n adncime (parcurgerea unui graf n sens direct, n preordine) vrfurile grafului vor fi vizitate n conformitate cu
urmtoarea procedur recursiv:
mai nti va fi vizitat rdcina arborelui q, apoi, dac rdcina arborelui nu este frunz - pentru fiecare fiu p al rdcinii q ne
vom adresa recursiv procedurii de parcurgere n adncime pentru a vizita vrfurile tuturor subarborilor cu rdcina p ordonate
ca fii ai lui q.
n cazul n care se va lucra cu un graf conex arbitrar cu relaia de ordine lips, nu va mai avea importan ordinea de parcurgere a
vrfurilor. Propunem un algoritm care utilizeaz mai larg posibilitile stivei, cea ce face programul mai efectiv n sensul
diminurii timpului de calcul necesar.

Algoritmul de cutare n lrgime:

Parcurgerea grafului n lrgime, ca i parcurgerea n adncime, va garanta vizitarea fiecrui vrf al grafului exact o singur dat,
ns principiul va fi altul. Dup vizitarea vrfului iniial, de la care va ncepe cutarea n lrgime, vor fi vizitate toate vrfurile
adiacente cu vrful dat, apoi toate vrfurile adiacente cu aceste ultime vrfuri .a.m.d. pn vor fi vizitate toate vrfurile grafului.

Evident, este necesar ca graful s fie conex. Aceast modalitate de parcurgere a grafului (n lrgime sau postordine), care mai este
adesea numit parcurgere n ordine orizontal, realizeaz parcurgerea vrfurilor de la stnga la dreapta, nivel dup nivel.
Algoritmul pentru cazul general este analogic cu cel pentru un graf n form de arbore cu o mic modificare care const n aceea
c fiecare vrf vizitat va fi marcat pentru a exclude ciclarea algoritmului.

3. SARCINA DE BAZ
1. Elaborai procedura cutrii n adncime si largime ntr-un graf arbitrar;
2. Elaborai un program cu urmtoarele posibiliti:
introducerea grafului n calculator;
parcurgerea grafului n adncime si largime;
vizualizarea rezultatelor la display sau imprimant.

4.LISTINGUL PROGRAMULUI
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------------------------void Prezt()
{ clrscr();
_setcursortype(_NOCURSOR);
printf("\n\n\n\n\t\t");
textcolor(3); cprintf("Lucrare de laborator Nr2 la Matematica Discreta.");
printf("\r\n\n\t\t\t");
cprintf("Cautarea in largime si adincime.");
textcolor(15);
getch();
}
//------------------------------------------------------------------void main()
{ int i,j,k,l,n,s,x,y,h;
char ch;
//------------------------------------------------------------------Prezt();
L1:static int a[30][20],b[30];
clrscr();
textcolor(15);
_setcursortype(_NORMALCURSOR);
printf("\n\t");
textcolor(3); cprintf("Introduceti numarul de virfuri ale arborelui : ");
textcolor(15);
scanf("%i",&n);
printf("\n\t");
textcolor(3); cprintf("Introduceti lista de adiacenta :\n\n ");
for(i=0;i<n;i++)
{ printf("\r%2i|",i+1);
scanf("%i",&a[i][0]);
for(j=1;j<n+1;j++)
if(a[i][j-1]!=0) scanf("%i",&a[i][j]);
else break;
}
//------------------------------------------------------------------for(i=0;i<n;i++) b[i]=i+1;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(a[i][j]!=0)

if(b[a[i][j]-1]!=0&&0<a[i][j]&&a[i][j]<=n) b[a[i][j]-1]=0;
else goto l2; // Eror!
else break;
for(i=0,x=0;x<n;x++)
if(b[x]!=0) {b[0]=x+1; i++;}
if(i>1) goto l2; // Eror!
x=y=0;
printf("\n\n\r");
textcolor(3); cprintf("PARCURGEREA IN LARGIME :\n\r");
printf("\n x%d;",b[0]);
for(i=1;i<n;i++)
{ if(a[b[x]-1][y]==0) {x++; y=0; i--;}
else { b[i]=a[b[x]-1][y]; y++;
printf(" x%d;",b[i]);
if(i%15==0) printf("\n");
}
}
goto l4;
l2:printf("\n\n\t\t\t");
textcolor(4); cprintf("Eroare!");
goto l3;
//------------------------------------------------------------------l4:printf("\n\n\n\r");
textcolor(3); cprintf("PARCURGEREA IN ADINCIME:\n");
i=b[0]-1;j=s=h=0;
printf("\n x%d;",b[0]);
while(h<n)
{ k=i;
if(a[k][j]!=0)
{ printf(" x%i;",a[k][j]);
i=a[k][j]-1;
}
l1:if(a[k][j]==0)
{ if(s==0) l=k+1;
if(s==1) l=x+2;
for(x=0;x<n;x++)
for(y=0;y<n+1;y++)
{ if(a[x][y]==l&&a[x][y+1]!=0)
{ printf(" x%i;",a[x][y+1]);
i=a[x][y+1]-1;
s=0;
goto l5;
}
if(a[x][y]==l&&a[x][y+1]==0)
{ s=1;
goto l1;
}
}
}
l5:h++;
if(h%15==0) printf("\n");
}
//------------------------------------------------------------------l3:_setcursortype(_NOCURSOR);
textcolor(2); cprintf("\r\n\n\n Tastati Enter pentru a reincarca programul...\n\n");

textcolor(4); cprintf("\r
textcolor(15);
while(1)
{ ch=getch();
if(ch==27) exit(0);
if(ch==13) goto L1;
}

Tastati Esc pentru a esi din program!");

Concluzie : Efectund lucrarea data de laborator, m-am familiarizat cu

algoritmul parcurgerii n adncime i lrgime,care st la baza
elaborrii majoritii aplicaiilor ce au ca scopul de cutare sau
parcurgere ct mai rapid i eficient a unui volum de memorie
structurat ntr-o erarhie dup careva caracteristici specifice .