Universitatea Tehnic a Moldovei

Catedra de Tehnologii Informationale

Catedra Tehnologii Informaionale

Raport
La Matematic Discret
Pentru laboratorul nr 1

TEMA: PSTRAREA GRAFURILOR N MEMORIA CALCULATORULUI

A ndeplinit

st. gr. C 131

Efros Andrei

A verificat

Dohotaru Leonid

Chisinu 2014

SCOPUL LUCRRII:
Studierea metodelor de definire a unui graf: matrice de inciden, matrice de adiacen, liste;
Elaborarea unor proceduri de introducere, extragere i transformare a diferitor forme de reprezentare
intern a grafurilor cu scoaterea rezultatelor la display i imprimant.

NOTE DE CURS

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).
Vom face cunotin cu fiecare dintre aceste metode.

Matricea de inciden
Este o matrice de tipul mxn, n care m este numrul de muchii sau arce (pentru un graf orientat), iar n este
numrul vrfurilor. La intersecia liniei i cu coloana j se vor considera valori de 0 sau 1 n conformitate cu
urmtoarea regul:
1 - dac muchia i este incident cu vrful j (dac arcul i "intr" n vrful j n cazul unui graf
orientat);
0 - dac muchia (arcul) i i vrful j nu sunt incidente;
-1 - numai pentru grafuri orientate, dac arcul i "iese" din vrful j.

Matricea de adiacen
Este o matrice ptrat nxn, aici n este numrul de vrfuri. Fiecare element poate fi 0, dac vrfurile
respective nu sunt adiacente, sau 1, n caz contrar. Pentru un graf fr bucle putem observa urmtoarele:
diagonala principal este format numai din zerouri;
pentru grafuri neorientate matricea este simetric fa de diagonala principal.

Lista de adiacen
Este o list cu n linii (dup numrul de vrfuri n), n linia cu numrul i vor fi scrise numerele vrfurilor
adiacente cu vrful i.

SARCINA DE BAZ
1. Elaborai procedura introducerii unui graf n memoria calculatorului n form de matrice de inciden,
matrice de adiacen i list de adiacen cu posibiliti de analiz a corectitudinii.
2. Elaborai proceduri de transformare dintr-o form de reprezentare n alta.
3. Folosind procedurile menionate elaborai programul care va permite:
introducerea grafului reprezentat sub oricare din cele trei forme cu posibiliti de corecie a
datelor;
pstrarea grafului n memoria extern n form de list de adiacen;
extragerea informaiei ntr-una din cele trei forme la imprimant i display.

Problema: Se da un graf G=(X,F) ,unde X este multimea de virfuri : X={x1,x2,,x3, x4,x5,x6,x7,x8}.

F(x1)={x2,x4}, F(x2)={ x3,x5,}, F(x3)={ x4,x6, x7}, F(x4)={x7}, F(x5)={ x3, x6,x8}, F(x6)={ x7,x8},
F(x7)={ x8}, F(x8)={o};
Codul surs (Listing-ul programului)
#include "stdafx.h"
#include<conio.h>
#include<malloc.h>
#include<stdlib.h>
struct Vertex
{
int ID;
Vertex *link;
};
typedef Vertex *PVertex;
void PrintAdjacentsList(Vertex** list,int vertices);
void PrintIncidenceMatrix(int* list,int &anr,int &vnr);
void PrintAdjcentMatrix(int* list,int nr);
void PrintAdjacentsList(Vertex** list,int vertices){
PVertex temp=NULL;
printf("\nReprezentarea prin lista de adiacenta\n");
for( int i=0;i<vertices;i++){
if(list[i]==NULL)printf(" %d >> virf terminal\n",i+1);
else{
printf(" %d.| ",i+1);
temp=list[i];
while(temp!=NULL){
printf("%d,",temp->ID+1);
temp=temp->link;
}
printf("0\n");
}
}
}
void PrintIncidenceMatrix(int* list,int &anr,int &vnr){
printf("\nReprezentarea prin matricea de incidenta\n");
for(int i=0;i<anr;i++){
printf(" %d | ",i+1);
for(int j=0;j<vnr;j++){
printf(" %d | ",list[i*vnr+j]);
}
printf("\n");
}
}
void PrintAdjcentMatrix(int* list,int nr){
printf("\nReprezentarea prin matricea de adiacenta\n");
for(int i=0;i<nr;i++){
printf("%d: ",i+1);
for(int j=0;j<nr;j++){
printf("%d | ",list[i*nr+j]);
}
printf("\n");
}
}
int NewAdjacentList(Vertex** &list){
int vertices=0,vertex=0;
printf("Introduceti numarul de virfuri ale grafului\n");
while((scanf_s("%d",&vertices)==1) && (vertices<0))printf("Gresit!Introduceti
numarul(pozitiv) de virfuri ale grafului\n>>");
list=(Vertex**)malloc(sizeof(Vertex*)*vertices);

unsigned int *input=(unsigned int*)malloc(sizeof(int)*vertices);

for(int i=0;i<vertices;i++)input[i]=0;
PVertex temp=NULL,head=NULL;
for( int i=0;i<vertices;i++){
for(int m=0;m<vertices;m++)input[i]=0;
printf("Intoduceti virfurile adiacent virfului\n");
printf("%d: | ",i+1);
while(1){
while(scanf_s("%d",&vertex)==1){
if((vertex>vertices) || (vertex<0))
printf("Introduceti alt virf\n>>");
else
break;
}
if(vertex==0)
break;
if(temp==NULL){
temp=(Vertex*)malloc(sizeof(Vertex));
temp->ID=vertex-1;
temp->link=NULL;
head=temp;
}
else{
temp=head;
while(temp->link!=NULL)temp=temp->link;
temp->link=(Vertex*)malloc(sizeof(Vertex));
temp->link->ID=vertex-1;
temp->link->link=NULL;
}
}

list[i]=head;
vertex=0;
head=NULL;temp=NULL;

return vertices;
}
int NewAdjacentMatrix(int* &list){
int nr,temp;
printf("Introduceti numarul de virfuri ale grafului \n>>");
scanf_s("%d",&nr);
list=(int*)malloc(sizeof(int)*nr*nr);
for(int i=0;i<nr;i++){
printf("Introduceti datele pentru virful %d (adiacent[1] sau
neadiacent[0])\n\n",i+1);
for(int j=0;j<nr;j++){
printf("Virful %d | ",j+1);
while(!(scanf_s("%d",&temp)==1) || !((temp==1) || (temp==0)))
printf("Gresit!Intoduceti [0] sau [1] .\n Virful %d | ",j+1)
;
list[i*nr+j]=temp;
}
}
return nr;
}
void NewIncidenceMatrix(int* &list,int &anr,int &vnr){
int temp,ch;
printf("Introduceti nr. de arcuri\n>>");
scanf_s("%d",&anr);
printf("Introduceti nr. de virfuri\n>>");
scanf_s("%d",&vnr);
list=(int*)malloc(sizeof(int)*anr*vnr);
for(int i=0;i<anr;i++)
for(int k=0;k<vnr;k++)
list[i*vnr+k]=0;
printf("Liniar indicind doar 2 virfuri pentru arcul respectiv \n>>");
for(int i=0;i<anr;i++){
printf("Introduceti datele pentru arcul %d \n",i+1);
printf("Din care virf iese arcul %d \n>>",i+1);
while(!(scanf_s("%d",&temp)==1) || !((temp<=vnr) && (temp>0)))

printf("Gresit!Intoduceti alte date .\n>> ") ;

list[i*vnr+temp-1]=-1;
printf("In care virf intra arcul %d \n>>",i+1);
while(!(scanf_s("%d",&temp)==1) || !((temp<=vnr) && (temp>0)))
printf("Gresit!Intoduceti alte date .\n>> ") ;
list[i*vnr+temp-1]=1;

}
}
Vertex** AdjcentMatrixToAdjacentsList(int *adjmatrix,int msize){
Vertex** list=NULL;
if(adjmatrix==NULL)exit(0);
list=(Vertex**)calloc(msize,sizeof(Vertex*));
PVertex temp=NULL,head=NULL;
for(int i=0;i<msize;i++){
for(int j=0;j<msize;j++){
if(adjmatrix[i*msize+j]==1){
if(head==NULL){
head=(Vertex*)malloc(sizeof(Vertex));
head->ID=j;
head->link=NULL;
}
else{
temp=head;
while(temp->link!=NULL)temp=temp->link;
temp->link=(Vertex*)malloc(sizeof(Vertex));
temp->link->ID=j;
temp->link->link=NULL;
}
}
}
list[i]=head;printf("\n");
head=NULL;temp=NULL;
}
return list;
}

Vertex** IncidenceMatrixToAdjacentsList(int *incmatrix,int msize,int nsize){

Vertex** list=NULL;
if(incmatrix==NULL)exit(0);
list=(Vertex**)calloc(nsize,sizeof(Vertex*));
PVertex temp=NULL;
int vertex1=-1,vertex2=-1,j,i;
for(i=0;i<msize;i++){
for(j=0;j<nsize;j++){
if(incmatrix[i*nsize+j]==-1)vertex1=j;
if(incmatrix[i*nsize+j]==1)vertex2=j;
if(incmatrix[i*nsize+j]==2)vertex1=vertex2=j;
}
if(vertex1 !=-1 && list[vertex1]==NULL){
list[vertex1]=(Vertex*)malloc(sizeof(Vertex));
list[vertex1]->ID=vertex2;
list[vertex1]->link=NULL;
}
else
if((vertex2!= -1) && (vertex1!=-1) && (list[vertex1]!=NULL)){
temp=list[vertex1];
while(temp->link!=NULL)temp=temp->link;
temp->link=(Vertex*)malloc(sizeof(Vertex));
temp->link->ID=vertex2;
temp->link->link=NULL;
}
vertex1=vertex2=-1;
}
return list;
}
int * AdjacentsListToIncidenceMatrix(Vertex** list,int vertices,int *arcs){
if(list==NULL)exit(0);
*arcs=0;

Vertex* temp=NULL;
for( int i=0;i<vertices;i++){
temp=list[i];
while(temp!=NULL){
(*arcs)+=1;
temp=temp->link;
}
}
int *incmatrix=(int*)calloc((*arcs)*vertices,sizeof(int));
int arc=0;
for( int i=0;i<vertices;i++){
temp=list[i];
while(temp!=NULL){
if(temp->ID==i)
incmatrix[arc*vertices+ i]=2;
else{
incmatrix[arc*vertices+ i]=-1;
incmatrix[arc*vertices+ temp->ID]=1;
}
arc+=1;
temp=temp->link;
}
}
return incmatrix;

int * AdjacentsListToAdjcentMatrix(Vertex** list,int vertices){

if(list==NULL)exit(0);
Vertex* temp=NULL;
int *adjmatrix=(int*)calloc(vertices*vertices,sizeof(int));
for( int i=0;i<vertices;i++){
temp=list[i];
while(temp!=NULL){
adjmatrix[i*vertices+temp->ID]=1;
temp=temp->link;
}
}
return adjmatrix;
}
int * IncidenceMatrixToAdjcentMatrix(int*incmatrix,int vertices,int arcs){
int * adjmatrix=(int*)calloc(vertices*vertices,sizeof(int));
int one=0,_one=0;
for(int i=0;i<arcs;i++){
for(int j=0;j<vertices;j++){
if(incmatrix[i*vertices+j]==2){
adjmatrix[j*vertices+j]=1;
break;
}
if(incmatrix[i*vertices+j]==1)one=j;
if(incmatrix[i*vertices+j]==-1)_one=j;
}
adjmatrix[_one*vertices+one]=1;
_one=one=0;
}
return adjmatrix;
}
int * AdjcentMatrixToIncidenceMatrix(int*adjmatrix,int vertices,int * arcs){
for(int i=0;i<vertices;i++)
for(int j=0;j<vertices;j++)
if(adjmatrix[i*vertices+j]==1)++(*arcs);
int *incmatrix=(int*)calloc(vertices*(*arcs),sizeof(int));
int arc=0;
for(int i=0;i<vertices;i++)
for(int j=0;j<vertices;j++){
if(adjmatrix[i*vertices+j]==1 && (i==j)){
incmatrix[arc++*vertices+j]=2;
continue;

}
if(adjmatrix[i*vertices+j]==1){
incmatrix[arc*vertices+i]=-1;
incmatrix[arc++*vertices+j]=1;
}
}
return incmatrix;
}
void main(){
Vertex**adjlist=NULL;
int* adjmatrix=NULL,*incmatrix=NULL;;
int vertices=0,arc=0,var=0;
printf("Introducerea si afisarea unui graf\n\n");
printf("Alegeti modul de prezentare a unui graf;\r\n");
printf("
1.Matricea de Adiacenta:\r\n");
printf("
2.Matricea de Incidenta:\r\n");
printf("
3.Lista de Adiacenta:\r\n");
printf(">>");
while(!(scanf_s("%d",&var)==1) || !((var==1) || (var==2) ||(var==3)))
printf("Gresit!Intoduceti alte date .\n>> ") ;
switch(var){
case 1:{
printf("\nAti ales tipul de introducere sub forma de Matrice de
Adiacenta:\n");
vertices=NewAdjacentMatrix(adjmatrix);
PrintAdjcentMatrix(adjmatrix,vertices);
break;
}
case 2:{
printf("\nAti ales tipul de introducere sub forma de Matrice de
Incidenta:\n");
NewIncidenceMatrix(incmatrix,arc,vertices);
PrintIncidenceMatrix(incmatrix,arc,vertices);
break;
}
case 3:{
printf("\nAti ales tipul de introducere sub forma de Lista de
Adiacenta:\n");
vertices=NewAdjacentList(adjlist);
PrintAdjacentsList(adjlist,vertices);
break;
}
}
N:{
printf("\nAlegeti modalitatea de transformare a Grafului:\n");
printf("
1.Matricea de adiacenta ---> Lista de adiacenta\n");
printf("
2.Matricea de adiacenta ---> Matricea de incidenta\n");
printf("
3.Matricea de incidenta ---> Lista de adiacenta\n");
printf("
4.Matricea de incidenta ---> Matricea de adiacenta\n");
printf("
5.Lista de adiacenta ---> Matricea de adiacenta\n");
printf("
6.Lista de adiacenta ---> Matricea de incidenta\n");
printf("
7.Iesire di program\n");
printf(">>");
while(!(scanf_s("%d",&var)==1) || !((var==1) || (var==2) ||(var==3) || (var==4) ||
(var==5) || (var==6) ||(var==7)))
printf("Gresit!Intoduceti alte date .\n>> ");
switch(var){
case 1:{
printf("\nAti ales tipul Matricea de adiacenta ---> Lista de
adiacenta:\n");
adjlist=AdjcentMatrixToAdjacentsList(adjmatrix,vertices);
PrintAdjacentsList(adjlist,vertices);
break;
}
case 2:{
printf("\nAti ales tipul Matricea de adiacenta ---> Matricea de
incidenta:\n");
incmatrix=AdjcentMatrixToIncidenceMatrix(adjmatrix,vertices,&arc);

PrintIncidenceMatrix(incmatrix,arc,vertices);
break;
}
case 3:{
printf("\nAti ales tipul Matricea de incidenta ---> Lista de
adiacenta:\n");
adjlist=IncidenceMatrixToAdjacentsList(incmatrix,arc,vertices);
PrintAdjacentsList(adjlist,vertices);
break;
}
case 4:{
printf("\nAti ales tipul Matricea de incidenta ---> Matricea de
adiacenta:\n");
adjmatrix=IncidenceMatrixToAdjcentMatrix(incmatrix,vertices,arc);
PrintAdjcentMatrix(adjmatrix,vertices);
break;
}
case 5:{
printf("\nAti ales tipul Lista de adiacenta ---> Matricea de
adiacenta:\n");
adjmatrix=AdjacentsListToAdjcentMatrix(adjlist,vertices);
PrintAdjcentMatrix(adjmatrix,vertices);
break;
}
case 6:{
printf("\nAti ales tipul Lista de adiacenta ---> Matricea de
incidenta:\n");
incmatrix=AdjacentsListToIncidenceMatrix(adjlist,vertices,&arc);
PrintIncidenceMatrix(incmatrix,arc,vertices);
break;
}
case 7:{
goto Q;
free(incmatrix);
free(adjmatrix);
free(adjlist);
break;
}
}
}
goto N;
Q:getch();
}

1.Reprezentarea grafului G ={X,F} forma de list de adiacent i afiarea lui la display.

2.Reprezentarea din list de adiacent n form de matrice de adiacent i afisarea acesteia la display.

3.Reprezentarea din list de adiacent n form de matrice de incident i afisarea acesteia la display.

Concluzie:
n urma acestei lucrari de laborator am facut cunostinta cu noiunea de graf i modurile n care poate fi
reprezentat graful: lista de adiacen, matricea de adiacen i matricea de inciden. Am fobservat ca cea
mai obtim modalitate de introducere a grafului estea ce n form de list de adiacen. La fel programul
realizat d posibiliatatea de trecere de la o metod de reprezentate la una din celelalte.