RAPORT

Lucrarea de laborator Nr.3

Disciplina : Matematica Specială

RAPORT

Tema : Algoritmul de căutare în Adâncime și Lărgime

Chişinău – 20XX
 SCOPUL LUCRĂRII:
-Studierea algoritmilor de căutare în graf şi a diferitor forme de
păstrare şi prelucrare a datelor;
-Elaborarea procedurii de căutare în adâncimeși lărgime;
ÎNTREBĂRI DE CONTROL
1. Definiţi structurile principale de date: liste, fire de aşteptare,
stive, arbori.
1)Lite - O listă este o colecție de elemente de informație (noduri),
legate între ele prin referințe, realizându-se, astfel, o stocare
necontiguă a datelor în memorie. Lungimea unei liste este dată de
numărul de noduri din listă.
2)Stive - O stivă este o structură de date ale cărei elemente sunt
considerate a fi puse unul peste altul, astfel încât orice element
adăugat se pune în vârful stivei, iar extragerea unui element se
poate face numai din vârful acesteia, în ordinea inversă celei în care
elementele au fost introduse.
3)Arbore - În teoria grafurilor, un arbore este un graf neorientat,
conex și fără cicluri. Arborii reprezintă grafurile cele mai simple ca
structură din clasa grafurilor conexe, ei fiind și cei mai frecvent
utilizați în practică.
4)Fire de aşteptare - Aşteptarea este intervalul de timp între
momentul când a fost solicitată servirea şi începutul efectuării
acesteia într-un sistem de servire. Universalitatea acestui proces şi
creşterea gradului de complexitate au condus la studiul analitic al
fenomenelor de aşteptare în vederea proiectării cât mai eficiente a
sistemelor de servire. Un sistem de servire este considerat eficient
dacă i se asigură un grad ridicat de utilizare, iar servirea se
realizează cu un timp minim de aşteptare.
2. Care sunt operaţiile definite pentru aceste structuri de date?
O structură de date bine concepută permite efectuarea unei
varietăți de operații de bază, utilizând puține resurse (ca de
exemplu memoria necesară și timpul de execuție). Structurile de
date se implementează utilizând tipuri de date, referințe și operații
asupra acestora, toate facilitate de către un limbaj de programare.
4. Definiţi noţiunea de parcurgere a grafului în adâncime/lărgime.
Parcurgerea în adâncime este un algoritm pentru parcurgerea sau
căutarea într-o structură de date de tip arbore(d) sau graf(d). Se
începe de la rădăcină(d) și se explorează cât mai mult posibil de-a
lungul fiecărei ramuri înainte de a face pași înapoi.
Parcurgerea în lățime - este un algoritm de căutare în graf, în care,
atunci când se ajunge într-un nod oarecare v, nevizitat, se vizitează
toate nodurile nevizitate adiacente lui v, apoi toate vârfurile
nevizitate adiacente vârfurilor adiacente lui v, etc. Plecand dintr-un
nod se va parcurge doar componenta conexă din care acesta face
parte. Pentru grafuri cu mai multe componente conexe se vor obține
mai mulți arbori de acoperire.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <malloc.h>
#include <math.h>

int array1[100], array2[100], a[100];

int x;
int** memory1(int);
void memory2(int**,int);
void adjancecymatrix(int**, int),adjacentlist(int**, int),
matrixlist(int**, int),listmatrix(int**, int);
void deep(int**, int,int), width(int**, int,int);
void showwidth(int**, int);

int main(void) {
int **graf;
int peak;
int var;
printf("Dati numarul de varfuri a grafului : ");
scanf("%d", &peak);
for(int i=0; i<peak; i++)
{
array1[i] = 0;
array2[i] = 0;
a[i] = 0;
}
graf = memory1(peak);
printf("Selectati metoda de introducere a grafului: \n");
printf("1. Matrice adiacenta\n");
printf("2. Lista adiacenta\n");
scanf("%d", &var);
switch(var)
{
case 1:
adjancecymatrix(graf,peak);
break;
case 2:
adjacentlist(graf,peak);
break;
default:
printf("Eroare!\n");
int z;
}
int var2;
printf("\n\n");
printf("Selectati operatiunea de executare asupra grafului\n");
printf("1 - Parcurgerea grafului in adancime\n");
printf("2 - Parcurgerea grafului in largime\n");
scanf("%d", &var2);
switch(var2)
{
case 1:
if(var==2)
{
listmatrix(graf,peak);
}
printf("Graful parcurs in adancime: ");
deep(graf,peak,0);
printf("\n");
break;
case 2:
if(var==2)
{
listmatrix(graf,peak);
}
width(graf,peak,0);
showwidth(graf,peak);
printf("\n");
break;

printf("Graful parcurs in adancime : ");

deep(graf,peak,0);
printf("\n");
 }
memory2(graf,peak);
}

int** memory1(int peak)

{
int** graf = calloc(peak,sizeof(int*));
for(int i=0; i<peak; i++)
{
graf[i]= calloc(peak,sizeof(int));
}
for(int i=0; i<peak; i++)
{
graf[i] = calloc(peak,sizeof(int));
}
return graf;
}

void memory2(int **graf, int peak)

{
for (int i = 0; i < peak; i++)
{
free(graf[i]);
}
free(graf);
graf = NULL;
}
void adjancecymatrix(int**graf,int peak)
{
printf("Introduceti graful:\n");
for(int i=0; i<peak; i++)
{
printf("X%d\t",i+1);
for(int j=0; j<peak; j++)
{
scanf("%d", &graf[i][j]);
}
}
printf("\t");
for(int i=0; i<peak; i++)
{
printf("X%d\t",i+1);
}
printf("\n");
for(int i=0; i<peak; i++)
{
printf("X%d\t",i+1);
for(int j=0; j<peak; j++)
{
printf("%d\t", graf[i][j]);
}
printf("\n");
}
}
void adjacentlist(int**graf,int peak)
{
for(int i=0; i<peak; i++)
{
printf("X%d\t",i+1);
for(int j=0; j<peak; j++)
{
scanf("%d", &graf[i][j]);
if(graf[i][j]==0)
{
break;
}
}
}
for(int i=0; i<peak; i++)
{

printf("X%d\t", i+1);
for(int j=0; j<peak; j++)
{
printf("%d\t", graf[i][j]);
if(graf[i][j]==0)
{
break;
}
}
printf("\n");
}
}

void matrixlist(int**graf, int p)

{
int p2;
p2 = p*p;
int tr[p2][p2];
int index_j;
int buffer;
for (int i=0; i<p2; i++)
{
for(int j=0; j<p2; j++)
{
tr[i][j]=0;
}
}
for(int i=0; i<p; i++)
{
for(int j=0; j<p; j++)
{
if(graf[i][j]!=0)
{
index_j = j+1;
tr[i][index_j-1] = index_j;
}
}
}
int i=0;
while(i<p)
{
for(int j=0; j<p; j++)
{
if(tr[i][j]<tr[i][j+1])
{
buffer = tr[i][j];
tr[i][j] = tr[i][j+1];
tr[i][j+1] = buffer;
}
}
i++;
}
for(int i=0; i<p2; i++)
{
for(int j=0; j<p2; j++)
{
if(tr[i][j]>tr[i][j+1] && tr[i][j] !=0 && tr[i][j+1]!=0)
{
buffer = tr[i][j];
tr[i][j] = tr[i][j+1];
tr[i][j+1] = buffer;
}
}
}
for(int i=0; i<p2; i++)
{
for(int j=0; j<p2; j++)
 {
if(tr[i][j]>tr[i][j+1] && tr[i][j] !=0 && tr[i][j+1]!=0)
{
buffer = tr[i][j];
tr[i][j] = tr[i][j+1];
tr[i][j+1] = buffer;
}
}
}

for (int i=0; i<p; i++)

{
for(int j=0; j<p; j++)
{
graf[i][j]= tr[i][j];
}
}

for (int i=0; i<p; i++)

{
for(int j=0; j<p; j++)
{
printf("%d\t", graf[i][j]);
}
printf("\n");
}
}
void listmatrix(int**graf,int p)
{
int index_j;
int tr[p][p];
for(int i=0; i<p; i++)
{
for(int j=0; j<p; j++)
{
tr[i][j]=0;
}
}
for(int i=0; i<p; i++)
{
for(int j=0; j<p; j++)
{
if(graf[i][j]!=0)
{
index_j=graf[i][j]-1;
tr[i][index_j]=1;
}
}
}
for(int i=0; i<p; i++)
{
for(int j=0; j<p; j++)
{
graf[i][j] = tr[i][j];
}
 }
}

void deep(int **graf, int peak, int i)

{
int j;
printf("%d ",i+1);
array1[i]=1;
for(j=0; j<peak; j++)
if(!array1[j]&&graf[i][j]==1)
deep(graf,peak,j);
}

void width(int**graf, int peak,int pl)

{
int i,p,v,ii=1,jj=1;
a[1]=pl;
array1[pl]=1;
p=x=1;
while(p<=x)
{
v=a[p];
p++;
jj=1;
for(i=1; i<=peak; i++)
{
if(graf[v][i]==1 && array2[i]==0)
{
 x++;
a[x]=i;
array2[i]=1;
}
}
}
}

void showwidth(int**graf,int peak)

{
printf(" Graful parcurs in largime: ");
for(int i=1; i<=x; i++)
{
printf("%d ",a[i]+1);
}
printf("\n");
}