Ministerul Educaţiei Culturii și Cercetării al Republicii Moldova

Universitatea Tehnica a Moldovei

Facultatea Calculatoare, Informatică si Microelectronică

Departamentul ISA

Lucrare de laborator
La Matematica Discretă

Tema: Pastrarea grafurilor in memoria calculatorului

A efectuat stundentul grupei: TI-182

Numele si prenumele elevului: Damaschin Andrian

A verificat profesorul:

Chisinau 2018
 Cuprins
1. Scopul lucrării---------------------------------------------------------------------- 3
2. Sarcina de bază -------------------------------------------------------------------- 3
3. Teorie -------------------------------------------------------------------------------- 3
4. Exemplu de graf care ne va servi ca exemplu la testarea programului 6
5. Verificarea programului --------------------------------------------------------- 8
6. Codul programului -------------------------------------------------------------- 15
7. Concluzie ---------------------------------------------------------------------------59
 1. Scopul lucrării

1. Studierea metodelor de definire a unui graf : matricea de incidență, matricea de adiacență,

liste.
2. Elaborarea unor proceduri de introducere , extragere si transformare a diferitelor forme de
reprezentare internă a grafurilor cu scoaterea rezultatelor la display si imprimantă.

2. Sarcina de bază

1. Elaborați procedura de introducere a unui graf în memoria calculatorului în formă de matrice de

incidență, de matrice de adiacență și listă de adiacență.

2. Elaborați proceduri de transformare dintr-o formă de reprezentare in alta.

3. Folosind procedurile enumerate , elaborați programul care vă permite:

 introducerea grafului reprezentat sub oricare forma din cele trei forme cu posibilități de
corecție a datelor.
 păstrarea grafului în memoria externă în formă de lista de adiacență.
 extragerea informației într-una dintre cele trei forme la imprimantă și display.

3. Teorie

Se numeşte graf, ansamblul format dintr-o mulţime finită X şi o aplicaţie F a lui X în X. Se

notează G = (X,F). Elementele mulţimii X se numesc vârfurile grafului. Geometric, vârfurile unui
graf le reprezentăm prin puncte sau cerculeţe. Perechea de vârfuri (x,y) se numeşte arc; vârful x
se numeşte originea sau extremitatea iniţială a arcului (x,y), iar vârful y se numeşte
extremitatea finală sau terminală. Un arc (x,y) îl reprezentăm geometric printr-o săgeată
orientată de la vârful x la vârful y.

Arcele unui graf le mai notăm şi cu e1, e2,..., iar mulţimea arcelor grafului o notăm cu E,iar
vîrfurile le notăm şi cu x1, x2,..., iar mulţimea vîrfurilor grafului notăm cu X.

Așadar un graf poate fi reprezentat sub forma unei figuri geometrice alcătuite din puncte
(care corespund vârfurilor) și din linii drepte sau curbe care unesc aceste puncte (care
corespund muchiilor sau arcelor).
Două arce se zic adiacente dacă sunt distincte şi au o extremitate comună. Două vârfuri se
zic adiacente dacă sunt distincte şi sunt unite printr-un arc. Un arc (x,y) se spune că este incident
cu vârful x spre exterior şi este incident cu vârful y spre interior.
Metode de reprezentare a grafului
Există trei metode de bază de definire a unui graf:

1. Matricea de incidenţă;
2. Matricea de adiacenţă;
3. Lista de adiacenţă (incidenţă).

Matricea de incidenţă
Este o matrice de tipul mxn, în care m este numărul de muchii sau arce (pentru un graf
orientat), iar n este numărul vârfurilor. La intersecţia liniei i cu coloana j se vor considera valori
de 0 sau 1 în conformitate cu următoarea regulă:

 1 - dacă muchia i este incidentă cu vârful j (dacă arcul i "intră" în vârful j în cazul unui graf
orientat);
 0 - dacă muchia (arcul) i şi vârful j nu sunt incidente;
 -1 - numai pentru grafuri orientate, dacă arcul i "iese" din vârful j.
x1 x2 x3 x4 x5 x6 x7

e1 -1 0 1 0 0 0 0

e2 -1 0 0 1 0 0 0

e3 0 0 0 -1 0 0 1

e4 0 0 -1 0 0 0 1

e5 0 -1 1 0 0 0 0

e6 0 -1 0 0 1 0 0

e7 0 -1 0 0 0 1 0

e8 0 0 -1 0 0 1 0

Fig. 3. Exemplu de matrice de incidenţă

Este uşor de observat că această metodă este de o eficacitate mică în sensul utilizării memoriei
calculatorului: fiecare linie conţine doar două elemente diferite de zero (o muchie poate fi
incidentă cu nu mai mult de două vârfuri).

Matricea de adiacenţă
Este o matrice pătrată nxn, aici n este numărul de vârfuri. Fiecare element poate fi 0, dacă
vârfurile respective nu sunt adiacente, sau 1, în caz contrar. Pentru un graf fără bucle putem
observa următoarele:

 diagonala principală este formată numai din zerouri;

 pentru grafuri neorientate matricea este simetrică faţă de diagonala principală.
x1 x2 x3 x4 x5 x6 x7

x1 0 0 1 1 0 0 0

x2 0 0 1 0 1 1 0

x3 0 0 0 0 0 1 1

x4 0 0 0 0 0 0 1

x5 0 0 0 0 0 0 0

x6 0 0 0 0 0 0 0

x7 0 0 0 0 0 0 0

Fig. 4. Exemplu de matrice de adiacenţă

După cum este de observat şi în acest caz memoria calculatorului este utilizată nu prea eficace
din care cauză matricea de adiacenţă ca şi matricea de incidenţă se vor utiliza de obicei doar în
cazul în care se va rezolva o problemă concretă pentru care reprezentarea grafului în această
formă aduce unele facilităţi algoritmului respectiv.

Pentru păstrarea grafurilor în memoria calculatorului (în deosebi, memoria externă) se va utiliza
una din posibilităţile de mai jos.

Lista de adiacenţă
Lista de adiacenţă este o listă cu n linii (după numărul de vârfuri n), în linia cu numărul i
vor fi scrise numerele vârfurilor adiacente cu vârful i.

Reprezentarea grafurilor prin intermediul acestor liste permite utilizarea mai eficace a memoriei
calculatorului, însă aceste forme sunt mai complicate atât în realizare, cât şi în timpul procesării.
 4. Exemplu de graf care ne va servi ca exemplu la testarea
programului.

1 e1

2
e3 e2

3 e4

e5 4
5

Matrice adiacentă:

x1 x2 x3 x4 x5

x1 0 1 0 1 0

x2 0 0 0 0 1

x3 0 0 0 1 0

x4 0 0 0 0 0

x5 0 0 1 0 0
Matrice incidentă:

x1 x2 x3 x4 x5

e1 -1 1 0 0 0

e2 0 -1 0 0 1

e3 -1 0 0 1 0

e4 0 0 1 0 -1

e5 0 0 -1 1 0

Listă adiacentă:

1 - 2, 4, 0

2 – 5, 0

3 – 4, 0

4–0

5 – 3, 0

La transformare din listă adiacentă în matrice incidentă, trebuie să

obținem:

x1 x2 x3 x4 x5

e1 -1 1 0 0 0

e2 -1 0 0 1 0

e3 0 -1 0 0 1

e4 0 0 -1 1 0

e5 0 0 1 0 -1
 5. Verificarea programului

1. Meniul principal (Fig. 5)

(Fig. 5)

2. Alegerea variantei 1 din meniu. Introducem graful. (Fig. 6)

(Fig. 6)
 3. Redactarea grafului. (Fig. 7)

(Fig. 7)

4. Adaugarea unui arc. (Fig. 8)

(Fig. 8)

5. Forma de convertire a grafului. (Fig. 9)

(Fig. 9)
 6. Convertirea grafului în toate tipurile. (Fig. 10)

(Fig. 10)
 7. Introducerea unei matrice incidente și convertirea în toate
variantele posibile. (Fig. 11), (Fig. 12)

(Fig. 11)

(Fig. 12)
 8. Introducerea unei matrice adiacente și convertirea în toate
variantele posibile. (Fig. 13), (Fig. 14)

(Fig. 13)

(Fig. 14)
 9. Introducerea unei liste adiacente și convertirea în toate
variantele posibile. (Fig. 15), (Fig. 16), (Fig. 17)

(Fig. 15)
(Fig. 16)

(Fig. 17)
6. Codul programului

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#define maxsize 64

#define ARC_MAX 10000

#define VIRF_MAX 10

void main() {

// switch

int optiune, graf_to_matrice, MatrIncidenta_Graf_Matr,

MatrAdiacenta_Graf_Matr;

// matrici graf -> matrici

int graf[ARC_MAX][2];

int graf_matrice_incidenta[ARC_MAX][VIRF_MAX];

int graf_matrice_adiacenta[VIRF_MAX][VIRF_MAX];

// matrici incidenta ->graf + matrici

int matrice_incidenta[ARC_MAX][VIRF_MAX];

int mi_graf[ARC_MAX][2];

int mi_matrice_adiacenta[VIRF_MAX][VIRF_MAX];

// matrici adiacenta ->graf + matrici

int matrice_adiacenta[ARC_MAX][VIRF_MAX];

int ma_graf[ARC_MAX][2];
int ma_matrice_incidenta[ARC_MAX][VIRF_MAX];

// lista adiacenta ->graf+matrici

int lista_adiacenta[VIRF_MAX][ARC_MAX];

int la_graf[ARC_MAX][2];

int la_matrice_adiacenta[VIRF_MAX][VIRF_MAX];

int la_matrice_incidenta[VIRF_MAX][VIRF_MAX];

// arc, virf, contor

int arc_count = 0, virf_count = 0;

int i = 0, j = 0, v = 0, n = 0, cont = 0;

int z = 0, u, n1, m1;

int k;

char pause;

int la_to_all;

int grafs, grafRed;

int rasp, lung, temp;

int contV, contC, contZ;

int stDup;

int l_arc;

int grafLineDel, grafLineAdd, virfDel, virfAdd, arcAdd;

while(1){

for (i = 0; i < VIRF_MAX; i++)

for (j = 0; j < VIRF_MAX; j++)

graf_matrice_incidenta[i][j] = 0;

// 0 0 0 0 0 0 0 0 0 graf matrice_adiacenta

for (i = 0; i < VIRF_MAX; i++)

 for (j = 0; j < VIRF_MAX; j++)

graf_matrice_adiacenta[i][j] = 0;

for (i = 0; i < ARC_MAX; i++)

for (j = 0; j < VIRF_MAX; j++)

matrice_adiacenta[i][j] = 0;

for (i = 0; i < ARC_MAX; i++)

for (j = 0; j < VIRF_MAX; j++)

matrice_incidenta[i][j] = 0;

for (i = 0; i < VIRF_MAX; i++)

for (j = 0; j < VIRF_MAX; j++)

mi_matrice_adiacenta[i][j] = 0;

for (i = 0; i < ARC_MAX; i++)

for (j = 0; j < VIRF_MAX; j++)

ma_matrice_incidenta[i][j] = 0;

for (i = 0; i < VIRF_MAX; i++)

for (j = 0; j < ARC_MAX; j++)

lista_adiacenta[i][j] = 0;

printf("~~~ Pentru inceput alegeti ce ati dori sa introduceti. "

"~~~\n\n"); // sleep(1);

printf("\t[1]. Graf.\n");

printf("\t[2]. Matricea incidenta.\n");

printf("\t[3]. Matriea de adiacenta.\n");

printf("\t[4]. Lista de adiacenta.\n");

printf("\nVarianta dorita este: ");

scanf("%d", &optiune);

// switch principal

switch (optiune) {
case 1:

// system("cls");

printf("\t\t Graf\n\n");

// nr virfuri

printf("Dati numarul de virfuri: ");

scanf("%d", &virf_count);

// nr arce

printf("Dati numarul de arce: ");

scanf("%d", &arc_count);

while (arc_count > pow(virf_count, 2)) {

printf(

"\nAti introdus date imposibile. Incercati din nou.\n\n");

printf("Dati numarul de virfuri: ");

scanf("%d", &virf_count);

// nr arce

printf("Dati numarul de arce: ");

scanf("%d", &arc_count);

// introducem arcele

printf("Introduceti arcele:\n");

for (i = 0; i < arc_count; i++) {

printf("Virful %d iesire : ", i + 1);

scanf("%d", &graf[i][0]);
 printf("Virful %d intrare : ", i + 1);

scanf("%d", &graf[i][1]);

if ((graf[i][0] > virf_count) || (graf[i][1] > virf_count) ||

(graf[i][0] <= 0) || (graf[i][1] <= 0)) {

printf("Arcul nu corespunde datelor introduse mai sus. "

"Introduceti repetat arcul.\n");

i--;

for (u = 0; u < 10; u++) {

for (int i = 0; i < arc_count; i++) {

for (int j = i + 1; j < arc_count; j++) {

if (graf[i][0] == graf[j][0] &&

graf[i][1] == graf[j][1]) {

memcpy(

&graf[j][0],

&graf[j + 1][0],

(arc_count - j) * 8);

memset(&graf[--arc_count][0], 0, 8);

printf(

"Arcul (%d %d) a fost introdus mai

devreme.\n",graf[i][0],graf[i][1]);

}
printf("Graful introdus este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

printf("Aveti nevoie de a redacta graful?\n1. Da. \n2. "

"Nu.\nAlegeti variant dorita: ");

scanf("%d", &rasp);

switch (rasp) {

case 1:

printf("Alegeti ce ati dori sa redactam in graf?\n");

printf("1. Adaugarea unui arc.\n");

printf("2. Stergerea unui arc.\n");

printf("3. Adaugarea unui virf.\n");

printf("4. Stergerea unui virf.\n");

printf("Alegeti optiunea dorita: ");

scanf("%d", &grafRed);

switch (grafRed) {

case 1:

printf("Introduceti arcul nou:\n");

for (i = arc_count; i < arc_count + 1; i++) {

printf("Virful %d iesire : ", i + 1);

scanf("%d", &graf[i][0]);
 printf("Virful %d intrare : ", i + 1);

scanf("%d", &graf[i][1]);

if ((graf[i][0] > virf_count) || (graf[i][1] > virf_count) ||

(graf[i][0] <= 0) || (graf[i][1] <= 0)) {

printf("Arcul nu corespunde datelor introduse mai sus. "

"Introduceti repetat arcul.\n");

i--;

arc_count++;

contZ=0;

for (int i = 0; i < arc_count; i++) {

for (int j = i + 1; j < arc_count; j++) {

if (graf[i][0] == graf[j][0] &&

graf[i][1] == graf[j][1]) {

contZ++;

if(contZ!=0)

printf("In graf arcul dat exista deja.\n");

printf("Ce este nevoie de efectuat cu noul

arc?\n");

printf("1. De sters.\n2. De modificat.\n3. De

adaugat in orice caz.\n");

printf("Alegeti varianta dorita: ");

scanf("%d", &stDup);
 switch(stDup){

case 1:

for (u = 0; u < 10; u++) {

for (int i = 0; i < arc_count; i++) {

for (int j = i + 1; j < arc_count; j++) {

if (graf[i][0] == graf[j][0] &&

graf[i][1] == graf[j][1]) {

memcpy(

&graf[j][0],

&graf[j + 1][0],

(arc_count - j) * 8);

memset(&graf[--arc_count][0], 0, 8);

printf(

"Arcul [%d,%d] a fost sters.\n", graf[i][0],

graf[i][1]);

break;

case 2:

printf("Introduceti arcul. Daca acesta iar v-a fi identic cu un alt

din graf, acesta nu se va adauga.\n");

for (i = arc_count; i < arc_count + 1; i++) {

printf("Virful %d iesire : ", i + 1);

 scanf("%d", &graf[i][0]);

printf("Virful %d intrare : ", i + 1);

scanf("%d", &graf[i][1]);

if ((graf[i][0] > virf_count) || (graf[i][1] > virf_count) ||

(graf[i][0] <= 0) || (graf[i][1] <= 0)) {

printf("Arcul nu corespunde datelor introduse mai sus. "

"Introduceti repetat arcul.\n");

i--;

arc_count++;

for (u = 0; u < 10; u++) {

for (int i = 0; i < arc_count; i++) {

for (int j = i + 1; j < arc_count; j++) {

if (graf[i][0] == graf[j][0] &&

graf[i][1] == graf[j][1]) {

memcpy(

&graf[j][0],

&graf[j + 1][0],

(arc_count - j) * 8);

memset(&graf[--arc_count][0], 0, 8);

printf(

"Arcul [%d,%d] a fost sters.\n", graf[i][0],

graf[i][1]);

}
 }

break;

default:

printf("Arcul a fost adaugat.");}

case 2:

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

printf("Selectati numarul arcului care doriti sa il stergeti: ");

scanf("%d", &grafLineDel);

if(grafLineDel>arc_count || grafLineDel<=0){

printf("Arcul cu asa numar nu exista.\nIntroduceti un arc

valid: ");

scanf("%d", &grafLineDel);

for (i = grafLineDel - 1; i < (arc_count - 1); i++)

for (j = 0; j < 2; j++)

graf[i][j] = graf[i + 1][j];

arc_count--;

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

}
 break;

case 3:

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

printf("Cite virfuri doriti sa adaugati: ");

scanf("%d", &virfAdd);

printf("Cite arcuri se mai creaza cu aceste virfuri:");

scanf("%d", &arcAdd);

for (i = arc_count; i < arc_count + arcAdd; i++) {

printf("Virful %d iesire : ", i + 1);

scanf("%d", &graf[i][0]);

printf("Virful %d intrare : ", i + 1);

scanf("%d", &graf[i][1]);

if ((graf[i][0] > virf_count + virfAdd) ||

(graf[i][1] > virf_count + virfAdd) ||

(graf[i][0] <= 0) || (graf[i][1] <= 0)) {

printf("Arcul nu corespunde datelor introduse

mai "

"sus. Introduceti repetat arcul.\n");

i--;

arc_count = arc_count + arcAdd;

 virf_count = virf_count + virfAdd;

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

contZ=0;

for (int i = 0; i < arc_count; i++) {

for (int j = i + 1; j < arc_count; j++) {

if (graf[i][0] == graf[j][0] &&

graf[i][1] == graf[j][1]) {

contZ++;

if(contZ!=0)

printf("Unele arce din graf coincid cu cele introduse acum.\n");

printf("Ce este nevoie de efectuat cu arcele care

coincid?\n");

printf("1. De sters.\n2. De adaugat in orice

caz.\n");

printf("Alegeti varianta dorita: ");

scanf("%d", &stDup);

switch(stDup){

case 1:
 for (u = 0; u < 10; u++) {

for (int i = 0; i < arc_count; i++) {

for (int j = i + 1; j < arc_count; j++) {

if (graf[i][0] == graf[j][0] &&

graf[i][1] == graf[j][1]) {

memcpy(

&graf[j][0],

&graf[j + 1][0],

(arc_count - j) * 8);

memset(&graf[--arc_count][0], 0, 8);

printf(

"Arcul [%d,%d] a fost sters.\n", graf[i][0],

graf[i][1]);

break;

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

}
 break;

case 4:

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

printf("Introduceti virful care trebuie sters: ");

scanf("%d", &virfDel);

if (virfDel > virf_count) {

printf("Acest virf nu exista. Introduceti virful din "

"nou.");

printf("Virful care trebuie sters este: ");

scanf("%d", &virfDel);

for (contC = 0; contC < 10; contC++) {

for (i = 0; i < arc_count; i++) {

for (j = 0; j < 2; j++)

if (graf[i][j] == virfDel) {

for (n1 = i; n1 < (arc_count - 1);

n1++)

for (m1 = 0; m1 < 2;

m1++)

graf[n1][m1] =
graf[n1 + 1][m1];

arc_count--;

}
 }

printf("Graful dumneavoastra este:\n");

for (i = 0; i < arc_count; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

break;

break;

default:

printf("Graful nu a fost redactat. \n\n");

}}

printf("\t\tAlegeti in ce forma convertim graful.\n");

printf("1. Matrice incidenta.\n");

printf("2. Matrice adiacenta.\n");

printf("3. Lista de adiacenta.\n");

printf("4. In toate tipurile.\n");

printf("Alegeti optiunea dorita:");

scanf("%d", &graf_to_matrice);

printf("\n\n\n");

switch (graf_to_matrice) {

case 1:
 for (i = 0; i < arc_count; i++)

if (graf[i][0] == graf[i][1])

graf_matrice_incidenta[i][graf[i][0] - 1] = 2;

else {

graf_matrice_incidenta[i][graf[i][0] - 1] = -1;

graf_matrice_incidenta[i][graf[i][1] - 1] = 1;

// numere sus

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

// line----

for (i = 0; i < virf_count; i++)

printf("--------");

printf("\n");

// afisare matrice in

for (i = 0; i < arc_count; i++) {

for (j = 0; j < virf_count; j++)

printf("%4d\t", graf_matrice_incidenta[i][j]);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

printf("\n\n\n\n\n\n\n\n");

break;

//-------------------------------Case 2------------------

case 2:
 for (i = 0; i < arc_count; i++)

graf_matrice_adiacenta[graf[i][0] - 1][graf[i][1] - 1] = 1;

fputs("\t", stdout);

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

for (i = 0; i < virf_count + 1; i++)

printf("--------");

printf("\n");

for (i = 0; i < virf_count; i++) {

printf("%3d:\t", i + 1);

for (j = 0; j < virf_count; j++)

printf("%4d\t", graf_matrice_adiacenta[i][j]);

printf("\n");

break;

//-----------------------------Case 3-----------------------

case 3:

printf("Lista adiacenta.\n\n");

for (i = 0; i < arc_count; ++i) {

for (j = 0; j < 2; ++j)

if (graf[i][0] > n)

n = graf[i][0];

}
 for (i = 0; i < n; ++i) {

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

for (j = 0; j < arc_count; ++j) {

if (i + 1 == graf[j][0])

printf("%d,", graf[j][1]);

if (j == arc_count - 1)

printf("%d\n", 0);

printf("\n");

break;

//---------------------------Case

//4--------------------------------------

case 4:

// incident

printf("\nIn matrice incidenta.\n");

for (i = 0; i < arc_count; i++)

if (graf[i][0] == graf[i][1])

graf_matrice_incidenta[i][graf[i][0] - 1] = 2;

else {

graf_matrice_incidenta[i][graf[i][0] - 1] = -1;

graf_matrice_incidenta[i][graf[i][1] - 1] = 1;

// numere sus

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

puts("");

// line----

for (i = 0; i < virf_count; i++)

printf("--------");

printf("\n");

// afisare matrice in

for (i = 0; i < arc_count; i++) {

for (j = 0; j < virf_count; j++)

printf("%4d\t", graf_matrice_incidenta[i][j]);

printf("(%d,%d)", graf[i][0], graf[i][1]);

printf("\n");

// adiacent

printf("\nIn matrice adiacenta.\n");

for (i = 0; i < arc_count; i++)

graf_matrice_adiacenta[graf[i][0] - 1][graf[i][1] - 1] = 1;

fputs("\t", stdout);

for (j = 0; j < virf_count; j++)

printf("%3d:\t", j + 1);

printf("\n");

for (i = -1; i < virf_count; i++)

printf("--------");

printf("\n");

for (i = 0; i < virf_count; i++) {

printf("%3d:\t", i + 1);

for (j = 0; j < virf_count; j++)

printf("%4d\t", graf_matrice_adiacenta[i][j]);
 printf("\n");

printf("\nIn lista adiacenta.\n\n");

for (i = 0; i < arc_count; ++i) {

for (j = 0; j < 2; ++j)

if (graf[i][0] > n)

n = graf[i][0];

for (i = 0; i < n; ++i) {

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

for (j = 0; j < arc_count; ++j) {

if (i + 1 == graf[j][0])

printf("%d,", graf[j][1]);

if (j == arc_count - 1)

printf("%d\n", 0);

printf("\n");

break;

default:

printf("Optiune gresita.Incercati din nou.\n");

break;

case 2:

arc_count = 0;

virf_count = 0;
printf("\t\tMatricea de incidenta.\n");

virf_count = 0;

arc_count = 0;

printf("Introduceti numarul de virfuri: ");

scanf("%d", &virf_count);

printf("Introduceti numarul de arcuri: ");

scanf("%d", &arc_count);

printf("Introduceti matricea de incidenta.\n");

for (i = 0; i < arc_count; i++) {

printf("Arcul %d: ", i+1);

for (j = 0; j < virf_count; j++) {

scanf("%d", &matrice_incidenta[i][j]);

if (matrice_incidenta[i][j] != 0 &&

matrice_incidenta[i][j] != 1 &&

matrice_incidenta[i][j] != -1 &&

matrice_incidenta[i][j] != 2) {

printf(

"Introduceti repetat elementul [%d][%d]",

i + 1,

j + 1);

scanf("%d", &matrice_incidenta[i][j]);

printf("\t\tAlegeti in ce forma convertim matricea.\n");

printf("1. Intr-un graf\n");

printf("2. In matrice de adicenta\n");

printf("3. In lista de adiacenta\n");

printf("4. In toate tipurile.\n");

printf("Alegeti optiunea dorita:");

scanf("%d", &MatrIncidenta_Graf_Matr);

switch (MatrIncidenta_Graf_Matr) {

case 1:

// system("cls");

printf("\nGraf.\n");

for (i = 0; i < arc_count; i++)

for (j = 0; j < virf_count; j++)

switch (matrice_incidenta[i][j]) {

case 2:

mi_graf[i][0] = j;

mi_graf[i][1] = j;

break;

case -1:

mi_graf[i][0] = j;

break;

case 1:

mi_graf[i][1] = j;

break;

printf("Au fost gasite arcele:\n");

for (i = 0; i < arc_count; i++)

printf("[%d]. (%d,%d)\n",i+1, mi_graf[i][0] + 1, mi_graf[i][1] + 1);

printf("\n");

break;
case 2:

printf("\nMatrice adiaceta.\n");

for (i = 0; i < arc_count; i++)

for (j = 0; j < virf_count; j++)

switch (matrice_incidenta[i][j]) {

case 2:

mi_graf[i][0] = j;

mi_graf[i][1] = j;

break;

case -1:

mi_graf[i][0] = j;

break;

case 1:

mi_graf[i][1] = j;

break;

for (i = 0; i < arc_count; i++)

mi_matrice_adiacenta[mi_graf[i][0]][mi_graf[i][1]] = 1;

fputs("\t", stdout);

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

for (i = 0; i < virf_count + 1; i++)

printf("--------");

printf("\n");
 for (i = 0; i < virf_count; i++) {

printf("%3d:\t", i + 1);

for (j = 0; j < virf_count; j++)

printf("%4d\t", mi_matrice_adiacenta[i][j]);

printf("\n");

break;

case 3:

printf("\nLista adiacenta.\n");

for (i = 0; i < arc_count; i++)

for (j = 0; j < virf_count; j++)

switch (matrice_incidenta[i][j]) {

case 2:

mi_graf[i][0] = j + 1;

mi_graf[i][1] = j + 1;

break;

case -1:

mi_graf[i][0] = j + 1;

break;

case 1:

mi_graf[i][1] = j + 1;

break;

n = 0;

for (i = 0; i < arc_count; ++i) {

for (j = 0; j < 2; ++j)

if (mi_graf[i][0] > n)
 n = mi_graf[i][0];

for (i = 0; i < n; ++i) {

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

for (j = 0; j < arc_count; ++j) {

if (i + 1 == mi_graf[j][0])

printf("%d,", mi_graf[j][1]);

if (j == arc_count - 1)

printf("%d\n", 0);

printf("\n");

break;

case 4:

printf("\nGraf\n");

for (i = 0; i < arc_count; i++)

for (j = 0; j < virf_count; j++)

switch (matrice_incidenta[i][j]) {

case 2:

mi_graf[i][0] = j;

mi_graf[i][1] = j;

break;

case -1:

mi_graf[i][0] = j;

break;

case 1:

mi_graf[i][1] = j;
 break;

printf("Au fost gasite arcele:\n");

for (i = 0; i < arc_count; i++) {

printf(

"[%d]. (%d,%d)\t",

i + 1,

mi_graf[i][0] + 1,

mi_graf[i][1] + 1);

printf("\n");

printf("\nMatrice adiaceta.\n");

for (i = 0; i < arc_count; i++)

for (j = 0; j < virf_count; j++)

switch (matrice_incidenta[i][j]) {

case 2:

mi_graf[i][0] = j;

mi_graf[i][1] = j;

break;

case -1:

mi_graf[i][0] = j;

break;

case 1:

mi_graf[i][1] = j;

break;

printf("\n");
for (i = 0; i < arc_count; i++)

mi_matrice_adiacenta[mi_graf[i][0]][mi_graf[i][1]] = 1;

fputs("\t", stdout);

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

for (i = 0; i < virf_count + 1; i++)

printf("--------");

printf("\n");

for (i = 0; i < virf_count; i++) {

printf("%3d:\t", i + 1);

for (j = 0; j < virf_count; j++)

printf("%4d\t", mi_matrice_adiacenta[i][j]);

printf("\n");

printf("\nLista adiacenta.\n");

for (i = 0; i < arc_count; i++)

for (j = 0; j < virf_count; j++)

switch (matrice_incidenta[i][j]) {

case 2:

mi_graf[i][0] = j + 1;

mi_graf[i][1] = j + 1;

break;

case -1:

mi_graf[i][0] = j + 1;

break;

case 1:

mi_graf[i][1] = j + 1;
 break;

n = 0;

for (i = 0; i < arc_count; ++i) {

for (j = 0; j < 2; ++j)

if (mi_graf[i][0] > n)

n = mi_graf[i][0];

for (i = 0; i < n; ++i) {

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

for (j = 0; j < arc_count; ++j) {

if (i + 1 == mi_graf[j][0])

printf("%d,", mi_graf[j][1]);

if (j == arc_count - 1)

printf("%d\n", 0);

printf("\n");

break;

/*------------------------------------------------------------------------------*/

case 3:

printf("\t\tMatricea de adiacenta.\n");
printf("Introduceti numarul de virfuri: ");

scanf("%d", &virf_count);

printf("Introduceti matricea de adiacenta.\n");

for (i = 0; i < virf_count; i++) {

printf("%d-linine : ", i + 1);

for (j = 0; j < virf_count; j++) {

scanf("%d", &matrice_adiacenta[i][j]);

printf("\t\tAlegeti in ce forma convertim matricea.\n");

printf("1. Intr-un graf\n");

printf("2. In matrice de incidenta\n");

printf("3. In lista de adiacenta\n");

printf("4. In toate tipurile.\n");

printf("Alegeti optiunea dorita:");

scanf("%d", &MatrAdiacenta_Graf_Matr);

switch (MatrAdiacenta_Graf_Matr) {

case 1:

printf("\n Graf.\n");

arc_count = 0;

for (i = 0; i < virf_count; i++)

for (j = 0; j < virf_count; j++)

if (matrice_adiacenta[i][j]) {

ma_graf[arc_count][0] = i;

ma_graf[arc_count][1] = j;

arc_count++;

printf("Au fost gasite arcele:\n");

for (i = 0; i < arc_count; i++)

 printf("[%d]. (%d,%d)\n",i+1, ma_graf[i][0] + 1, ma_graf[i][1] +
1);

printf("\n");

break;

case 2:

printf("\n Matrice incidenta.\n");

for (i = 0; i < virf_count; i++)

for (j = 0; j < virf_count; j++)

if (matrice_adiacenta[i][j]) {

ma_graf[arc_count][0] = i;

ma_graf[arc_count][1] = j;

arc_count++;

printf("Au fost gasite arcele:");

for (i = 0; i < arc_count; i++)

printf("(%d,%d)\t", ma_graf[i][0] + 1, ma_graf[i][1] + 1);

printf("\n");

for (i = 0; i < arc_count; i++)

if (ma_graf[i][0] == ma_graf[i][1])

ma_matrice_incidenta[i][ma_graf[i][0]] = 2;

else {

ma_matrice_incidenta[i][ma_graf[i][0]] = -1;

ma_matrice_incidenta[i][ma_graf[i][1]] = 1;

// numere sus

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

 printf("\n");

// line----

for (i = 0; i < virf_count; i++)

printf("--------");

printf("\n");

// afisare matrice in

for (i = 0; i < arc_count; i++) {

for (j = 0; j < virf_count; j++)

printf("%4d\t", ma_matrice_incidenta[i][j]);

printf("(%d,%d)", ma_graf[i][0] + 1, ma_graf[i][1] + 1);

printf("\n");

break;

case 3:

printf("\nLista adicenta.\n");

arc_count = 0;

for (i = 0; i < virf_count; i++)

for (j = 0; j < virf_count; j++)

if (matrice_adiacenta[i][j]) {

ma_graf[arc_count][0] = i + 1;

ma_graf[arc_count][1] = j + 1;

arc_count++;

printf("Au fost gasite arcele:");

for (i = 0; i < arc_count; i++)

printf("(%d,%d)\t", ma_graf[i][0], ma_graf[i][1]);

printf("\n");
 n = 0;

for (i = 0; i < arc_count; ++i) {

for (j = 0; j < 2; ++j)

if (ma_graf[i][0] > n)

n = ma_graf[i][0];

for (i = 0; i < n; ++i) {

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

for (j = 0; j < arc_count; ++j) {

if (i + 1 == ma_graf[j][0])

printf("%d,", ma_graf[j][1]);

if (j == arc_count - 1)

printf("%d\n", 0);

printf("\n");

break;

case 4:

printf("\n Graf.\n");

arc_count = 0;

for (i = 0; i < virf_count; i++)

for (j = 0; j < virf_count; j++)

if (matrice_adiacenta[i][j]) {

ma_graf[arc_count][0] = i;

ma_graf[arc_count][1] = j;

arc_count++;

printf("Au fost gasite arcele:\n");

 for (i = 0; i < arc_count; i++)

printf("[%d]. (%d,%d)\n",i+1, ma_graf[i][0] + 1, ma_graf[i][1] +

1);

printf("\n");

printf("\nMatrice incidenta.\n");

for (i = 0; i < arc_count; i++)

if (ma_graf[i][0] == ma_graf[i][1])

ma_matrice_incidenta[i][ma_graf[i][0]] = 2;

else {

ma_matrice_incidenta[i][ma_graf[i][0]] = -1;

ma_matrice_incidenta[i][ma_graf[i][1]] = 1;

// numere sus

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

// line----

for (i = 0; i < virf_count; i++)

printf("--------");

printf("\n");

// afisare matrice in

for (i = 0; i < arc_count; i++) {

for (j = 0; j < virf_count; j++)

printf("%4d\t", ma_matrice_incidenta[i][j]);

printf("(%d,%d)", ma_graf[i][0] + 1, ma_graf[i][1] + 1);

 printf("\n");

printf("\nLista adicenta.\n");

arc_count = 0;

for (i = 0; i < virf_count; i++)

for (j = 0; j < virf_count; j++)

if (matrice_adiacenta[i][j]) {

ma_graf[arc_count][0] = i + 1;

ma_graf[arc_count][1] = j + 1;

arc_count++;

printf("\n");

n = 0;

for (i = 0; i < arc_count; ++i) {

for (j = 0; j < 2; ++j)

if (ma_graf[i][0] > n)

n = ma_graf[i][0];

for (i = 0; i < n; ++i) {

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

for (j = 0; j < arc_count; ++j) {

if (i + 1 == ma_graf[j][0])

printf("%d,", ma_graf[j][1]);

if (j == arc_count - 1)

printf("%d\n", 0);

}
 }

printf("\n");

break;

break;

/*-------------------------------------------*/

case 4:

// system("cls");

printf("Lista de adiacenta.\n");

arc_count = 0;

virf_count = 0;

printf("Introduceti numarul de virfuri:");

scanf("%d", &virf_count);

printf("Introduceti lista. Linia se sfirseste in 0.\n");

for (i = 0; i < virf_count; i++) {

printf("%d linie:", i + 1);

for (j = 0; j < 1000; j++) {

l_arc++;

scanf("%d", &lista_adiacenta[i][j]);

if (lista_adiacenta[i][j] > virf_count) {

printf(

"Virful %d nu exista.Acesta va fi sters "

"autotmat.\n",

lista_adiacenta[i][j]);

scanf("%d", &lista_adiacenta[i][j]);
 }

if (!lista_adiacenta[i][j]) {

l_arc--;

break;

printf("Ati introdus lista de adiacenta:\n\n");

for (i = 0; i < virf_count; i++) {

{ printf("%d: ", i + 1); }

for (j = 0; j < 1000; j++)

if (lista_adiacenta[i][j] != 0) {

printf("%d,", lista_adiacenta[i][j]);

} else {

printf("%d\n", 0);

break;

printf("\n\n");

k = 0;

for (i = 0; i < virf_count; ++i) {

for (j = 0; lista_adiacenta[i][j]; ++j) {

la_graf[k][0] = i + 1;

la_graf[k][1] = lista_adiacenta[i][j];

++k;

}
 for (int i = 0; i < l_arc; i++) {

for (int j = i + 1; j < l_arc; j++) {

if (la_graf[i][0] == la_graf[j][0] &&

la_graf[i][1] == la_graf[j][1]) {

contZ++;

if(contZ!=0)

printf("In lista au fost intilnite arce identice.\n");

printf("Este nevoie de sters aceste arce?\n");

printf("1. Da.\n2. Nu.\n");

printf("Alegeti varianta dorita: ");

scanf("%d", &stDup);

switch(stDup){

case 1:

for (u = 0; u < 10; u++) {

for (int i = 0; i < l_arc; i++) {

for (int j = i + 1; j < l_arc; j++) {

if (la_graf[i][0] == la_graf[j][0] &&

la_graf[i][1] == la_graf[j][1]) {

memcpy(

&la_graf[j][0],

&la_graf[j + 1][0],

(l_arc - j) * 8);

memset(&la_graf[--l_arc][0], 0, 8);
 printf(

"Arcul [%d,%d] a fost

sters.\n",la_graf[i][0],la_graf[i][1]);

printf("\nLista adiacenta dupa redactare.\n");

for (i = 0; i < l_arc; ++i) {

for (j = 0; j < 2; ++j)

if (la_graf[i][0] > n)

n = la_graf[i][0];

for (i = 0; i < n; ++i) {

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

for (j = 0; j < l_arc; ++j) {

if (i + 1 == la_graf[j][0])

printf("%d,", la_graf[j][1]);

if (j == l_arc - 1)

printf("%d\n", 0);

printf("\n");

break;

default:
 printf("Lista nu a fost redactata. \n\n");

}}

printf("\n");

printf("In ce convertim lista adiacenta?\n");

printf("1. Intr-un graf.\n");

printf("2. In matrice incidenta.\n");

printf("3. In matrice adiacenta.\n");

printf("4. In toate tipurile.\n");

printf("Alegeti optiunea dorita: ");

scanf("%d", &la_to_all);

switch (la_to_all) {

case 1:

printf("Graful dumneavoastra este:\n");

for (i = 0; i < l_arc; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", la_graf[i][0], la_graf[i][1]);

printf("\n");

break;

case 2:

k = 0;

for (i = 0; i < virf_count; ++i) {

for (j = 0; lista_adiacenta[i][j]; ++j) {

la_graf[k][0] = i + 1;

la_graf[k][1] = lista_adiacenta[i][j];

++k;
 }

for (i = 0; i < l_arc; i++)

if (la_graf[i][0] == la_graf[i][1])

la_matrice_incidenta[i][la_graf[i][0] - 1] = 2;

else {

la_matrice_incidenta[i][la_graf[i][0] - 1] = -1;

la_matrice_incidenta[i][la_graf[i][1] - 1] = 1;

// numere sus

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

// line----

for (i = 0; i < virf_count; i++)

printf("--------");

printf("\n");

// afisare matrice in

for (i = 0; i < l_arc; i++) {

for (j = 0; j < virf_count; j++)

printf("%4d\t", la_matrice_incidenta[i][j]);

printf("(%d,%d)", la_graf[i][0], la_graf[i][1]);

printf("\n");

break;
case 3:

printf("Lista adiacenta.\n");

k = 0;

for (i = 0; i < virf_count; ++i) {

for (j = 0; lista_adiacenta[i][j]; ++j) {

la_graf[k][0] = i + 1;

la_graf[k][1] = lista_adiacenta[i][j];

++k;

for (i = 0; i < l_arc; i++)

la_matrice_adiacenta[la_graf[i][0] - 1][la_graf[i][1] - 1] = 1;

fputs("\t", stdout);

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

for (i = 0; i < virf_count + 1; i++)

printf("--------");

printf("\n");

for (i = 0; i < virf_count; i++) {

printf("%3d:\t", i + 1);

for (j = 0; j < virf_count; j++)

printf("%4d\t", la_matrice_adiacenta[i][j]);

printf("\n");
 }

break;

case 4:

printf("\n\n");

k = 0;

for (i = 0; i < virf_count; ++i) {

for (j = 0; lista_adiacenta[i][j]; ++j) {

la_graf[k][0] = i + 1;

la_graf[k][1] = lista_adiacenta[i][j];

++k;

printf("Arcele grafului sunt:\n");

for (i = 0; i < l_arc; ++i) {

printf("[%i]. ", i + 1);

printf("(%d,%d)", la_graf[i][0], la_graf[i][1]);

printf("\n");

printf("\n\n\n\nLista incidenta este:\n");

k = 0;

for (i = 0; i < virf_count; ++i) {

for (j = 0; lista_adiacenta[i][j]; ++j) {

la_graf[k][0] = i + 1;

la_graf[k][1] = lista_adiacenta[i][j];

++k;

for (i = 0; i < l_arc; i++)

if (la_graf[i][0] == la_graf[i][1])

la_matrice_incidenta[i][la_graf[i][0] - 1] = 2;

else {

la_matrice_incidenta[i][la_graf[i][0] - 1] = -1;

la_matrice_incidenta[i][la_graf[i][1] - 1] = 1;

// numere sus

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

// line----

for (i = 0; i < virf_count; i++)

printf("--------");

printf("\n");

// afisare matrice in

for (i = 0; i < l_arc; i++) {

for (j = 0; j < virf_count; j++)

printf("%4d\t", la_matrice_incidenta[i][j]);
 printf("(%d,%d)", la_graf[i][0], la_graf[i][1]);

printf("\n");

printf("\n\n\n\n Lista de adicenta este: \n");

for (i = 0; i < l_arc; i++)

la_matrice_adiacenta[la_graf[i][0] - 1][la_graf[i][1] - 1] = 1;

fputs("\t", stdout);

for (j = 0; j < virf_count; j++)

printf(" %3d\t", j + 1);

printf("\n");

for (i = 0; i < virf_count + 1; i++)

printf("--------");

printf("\n");

for (i = 0; i < virf_count; i++) {

printf("%3d:\t", i + 1);

for (j = 0; j < virf_count; j++)

printf("%4d\t", la_matrice_adiacenta[i][j]);

printf("\n");

printf("\n\n");

break;

default:

printf("Eroare.");

}
 break;

/*------------------------------------*/

default:

printf("Optiune gresita.Incercati din nou.\n");

}}}

7. Concluzie:

În această lucrare de laborator am făcut cunoștință cu diferite modalități de reprezentare a

grafului în memoria calculatorului: Matricea de adiacență, Matricea de incidență, Lista de
adiacență. Am elaborat un program în limbajul C, care permite utilizatorului să introducă un
graf aleator sau o matrice incidentă, o matrice adiacentă sau o lista adiacentă și să-l afișeze în
una din cele 3 forme sau chiar în toate formele posibile din program. Am acumulat
cunoștințe despre grafuri și metodele practice de implementare a lor in programare. Efectuînd
analiza asupra programului am ajuns la concluzia că cea mai eficientă formă de păstrare a
grafului în memoria calculatorului este lista de adiacență. Verificarea ne-a demonstrat că
programul rulează corect, iar în transformările efectuate de program, nu au fost admise
greșeli.