Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra: Automatica i Tehnologii Informaionale

RAPORT
Lucrare de laborator Nr.3
la Matematica Discreta
Tema:Algoritmul de cautare in largime

A efectuat:

st. gr. TI

A verificat:

lect.univ.
Ceban G.

Chiinu 2015
Scopul lucrrii:

 Studierea algoritmului de cautare in largime.

Elaborarea programului de cautare in largime.

Enuntul problemei:
1. Elaborai procedura care va realiza algoritmul de parcurgere a grafului n lrgime;
2. Folosind procedurile din lucrrile precedente, elaborai programul care va permite::
introducerea grafului n calculator,
parcurgerea grafului n largime,
vizualizarea rezultatelor la display i imprimant.

Listingul programului:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
typedef struct list
{
int info;
struct list *adr;
}list;
list* pushList(list *prev_el, list *&head_el, int inf);
list** saveList(int n, list **adi_list);
void viewList(int n, list **adi_list);
list* popList(list *curr_el);
int* parLatime(int n, int v_st, list **adi_list, int *vect_res, int &k);
void cleanMem(int n, list **adi_list);
int main()
{
list **adi_list, *tmp_list;
int n, *vect_res, v_st, i, k, opt;
FILE *fp;
printf("Introduceti numarul de virfuri: ");
scanf("%d", &n);
adi_list = saveList(n, adi_list);
system("cls");
do
{

system("cls");
printf(" Parcurgerea grafului in largime

\n");

printf("------------------------------------------\n");
printf(" 1.Afisarea listei de adiacenta

\n");

printf(" 2.Pracurgerea in largime

\n");

printf(" 0.Iesire

\n");

printf(" Alegeti optiunea dorita: ");

opt = getche();
switch(opt)
{
case '1':
printf("\nLista de adiacenta: \n");
viewList(n, adi_list);
printf("\n\nApasati orice tasta pentru revenire...");
getch();
system("cls");
break;
case '2':
printf("\n");
viewList(n, adi_list);
printf("Introduceti virful de pornire: ");
scanf("%d", &v_st);
vect_res =

(int *)malloc(n * sizeof(int));

vect_res = parLatime(n, v_st, adi_list, vect_res, k);

printf("Parcurgerea in latime incepind cu virful %d: ", vect_res[0]);
for(i = 0; i < k; i++)
printf("%d ", vect_res[i]);
printf("\n\nApasati orice tasta pentru revenire...");
free(vect_res);
getch();
break;
default:
cleanMem(n, adi_list);
}
}while(opt != '0');
return 0;
}
//Functia pentru adaugarea unui element intr-o lista

list* pushList(list *prev_el, list *&head_el, int inf)

{
list *tmp = (list *)malloc(sizeof(list));
tmp->info = inf;
tmp->adr = 0;
if(prev_el == 0)
head_el = tmp;
else
prev_el->adr = tmp;
prev_el = tmp;
return prev_el;
}
//Functia pentru introducerea listei de adiacenta
list** saveList(int n, list **adi_list)
{
int i, inf;
list *prev_el, *head_el;
adi_list = (list **)malloc(n * sizeof(list *));
for(i = 0; i < n; i++)
{
prev_el = head_el = 0;
printf("%d |", i + 1);
do
{
scanf("%d", &inf);
prev_el = pushList(prev_el, head_el, inf);
}while(inf != 0);
adi_list[i] = head_el;
}
return adi_list;
}
//Functia pentru afisarea listei de adiacenta
void viewList(int n, list **adi_list)
{
int i;
list *curr_el;
for(i = 0; i < n; i++)
{
curr_el = adi_list[i];

printf("%d |", i + 1);

while(curr_el != 0)
{
printf("%d ", curr_el->info);
curr_el = curr_el->adr;
}
printf("\n");
}
}
//Functia pentru parcurgerea in largime
int* parLatime(int n, int v_st, list **adi_list, int *vect_res, int &k)
{
int i, j, v_con, n_line;
list *next_el, *head_el, *stack_el;
next_el = head_el = stack_el = 0;
if(v_st == 0)
return 0;
k = 0;
j = 0;
do
{
next_el = adi_list[v_st - 1];
while(v_st != 0)
{
v_con = 0;
i = 0;
while(i < k)
{
if(v_st == vect_res[i])
{
v_con = 1;
break;
}
i++;
}
if(v_con == 0)
{
stack_el = pushList(stack_el, head_el, v_st);
vect_res[k] = v_st;

v_st = next_el->info;
k++;
}else{
v_st = next_el->info;
}
if(next_el->adr != 0)
next_el = next_el->adr;
else
break;
}
if(head_el->adr != 0)
{
head_el = popList(head_el);
if(head_el != 0)
v_st = head_el->info;
else
v_st = 0;
}
if(v_st == 0)
{
for(i = 0; i < n; i++)
{
v_con = 0;
j = 0;
do
{
if(vect_res[j] == i + 1)
{
v_con = 1;
break;
}
j++;
}while(j < k);
if(v_con == 0)
{
v_st = i + 1;
break;
}
}

}
}while(k != n);
return vect_res;
}
//Functia pentru stergerea unui element din lista
list* popList(list *head_el)
{
list *tmp;
tmp = head_el;
if(head_el->adr == 0)
head_el = 0;
else
head_el = head_el->adr;
free(tmp);
return head_el;
}
//Eliberarea memoriei dinamice ocupate de toate elementele programului
void cleanMem(int n, list **adi_list)
{
int i;
list *curr_el, *prev_el;
for(i = 0; i < n; i++)
{
curr_el = adi_list[i];
while(curr_el != 0)
{
//prev_el = curr_el;
prev_el = curr_el->adr;
free(curr_el);
curr_el = prev_el;
}
}
free(adi_list);

Concluzie:
6

In acest laborator a fost efectuat un porgram care pastreaza un graf in forma de lista de
adiacenta.Pentru aceasta a fost folosit un vector de pointeri si fiecare pointer pastreaza adresa
primului element dintr-o lista simplu inlantuita. Dupa introducerea si memorarea listei a fost
elaborat un algoritm care permite afisarea drumului in largime incepind cu virful introdus de
utilizator. In final programul ne permite posibilitate visuzlizarii rezultatelor nu numai la ecran
dar si salvarea intr-un fisier.