Ministerul Educației, Culturii Și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul ISA

Raport

Tema: Păstrarea grafurilor în memoria calculatorului

A realizat: st. Gr. TI-172 Iordan Ana-Maria

A verificat: lector superior Andrievschi-Bagrin Veronica

Chișinău 2018
 Cuprins

1. Scopul și obiectivele lucrării ................................................................................................... 3

2. Sarcina lucrării ....................................................................... Error! Bookmark not defined.
3. Considerații teoretice ............................................................. Error! Bookmark not defined.
4. Mersul lucrării ....................................................................... Error! Bookmark not defined.
5. Concluzii ................................................................................ Error! Bookmark not defined.
Anexa ……………………………………………………………………………………………………....9
Bibliografie.....................................................................................................................................10
1. Scopul și obiectivele lucrării

a) Studierea metodelor de definire a unui graf:

- Matricea de incidență
- Matricea de adiacență
- Liste

b) Elaborarea unor proceduri de introducere, extragere și transformare a diferitelor forme de

reprezentare internă a grafurilor cu scoaterea rezultatelor la display și imprimantă.

c) Studierea metodelor de redactare/modificare a grafului.

2. Sarcina lucrării
1. Elaborarea a unui program care să permită introducerea unui graf arbitrar.

2. Afișarea de la ecran a trei forme de stocare a grafului:

a) Matrice de incidență

b) Matrice de adiacență

c) Listă de adiacență

3. Redacatare grafului:

a) Ștergerea unui arc

b) Adăugarea unui arc

c) Ștergerea unui vârf

d) Adăugarea unui vârf

 3. Considerații teoretice

Se numește graf, G=(X,F), ansamblu format dintr-o mulțime finită X si o aplicație F a lui X în X.
Elementele mulțimii X se numesc vârfurile grafului. Perechea de vârfuri (x,y) se numește arc, vârful x se
numeste originea sau extremitatea inițială a arcului (x,y) iar vârful y se numește extremitatea finală sau
terminală.

Dacă un vârf nu este extremitatea nici unui arc el se numeste vârf izolat, iar dacă este extremitatea a
mai mult de două arce- nod. Un arc (x,y) pentru care extremitatea inițială coincide cu cea finală se numește
buclă.

Exista 3 metode de baza de definire a unui graf:

1. Matricea de incidență;
2. Matricea de adiacentă;
3. Lista de adiacență.

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, 1 sau -1 în conformitate
cu următoarea regulă:
 1 - dacă muchia/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 - dacă arcul i "iese" din vârful j.

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.

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.

Xi F(xi) MA x1 x2 x3 x4 x5 x1 x2 x3 x4 x5
MI
x1 2,0 x1 0 1 0 0 0
x2 4,0 x2 0 0 0 1 0 u1 0 1 0 0 -1
x3 2,4,0 x3 0 1 0 1 0 u2 1 0 0 0 -1
x4 0 x4 0 0 0 0 0
x5 1 1 1 0 0 u3 -1 1 0 0 0
x5 1,2,3,0
u4 0 0 1 0 -1
Fig.1 Lista Fig.2 Matricea de adiacenta
u5 0 0 -1 1 0
u6 0 1 -1 0 0
u7 0 -1 0 1 0
Fig.3 Matricea de incidenta
 4. Mersul lucrării
Sarcina nr.1

Am încercat să efectuez introducerea unui graf arbitrar sub trei forme:

a) Matrice de incidență
b) Matrice de adiacență
c) Listă de adiacență

a) Introducerea unei matrici sub forma unei matrice de incidență:

Pentru aceasta am creat funcția read_matinc.
Introducem nunărul de vârfuri n, și numărul de muchii b:
putstr(" Nr. de varfuri:");
scanf("%d", &n);
putstr("Nr.de muchii : ");
scanf("%d", &b);

apoi introducem elementele matricei, k, sub formă de -1 (plecarea din vârf), 1(sosirea în vârf), și
0, în cazul cînd nu există drum.
for(i=1; i<=b; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor (WHITE);
for(j=1; j<=n; j++)
{
t=NULL;
scanf("%d", &k);
if(k==1)
node=j;
else if (k==-1)
t=find_node(*begin,j);
else if(k!=0)
{
node=j;
t=find_node(*begin,j);
}
}

Elementele se vor citi sub forma unei matrici cu dimensiunea nxb, unde n - numărul de vârfuri, b -
numărul de arce. Pentru convertirea ulterioară a grafului în celelatle forme, efectuăm toate
sarcinile alocînd memoria dinamic.

b) Introducerea unei matrici sub forma unei matrice de adiacență:

Pentru citire matricei sub această formă, utilizăm funcția read_matad, e necesar să introducem
nr de vîrfuri n:
puts("Nr. de varfuri: ");
scanf("%d", &n);
formând matricea patratică cu dimensiunea nxn, completăm matricea cu zerouri și unități, dacă există
drum din xi în xj, atunci se completeză cu 1, în caz contrar cu 0.
for(j=1; j<=n; j++)
{
scanf("%d", &k);
if(k!=0)
list_add(&(t->bow),j,k);
}
 c) Introducerea unei matrici sub forma unei liste de adiacență:
Lista de adiacenţă este o listă cu n linii, în linii vor fi scrise numerele vârfurilor adiacente cu vârful i.
Inițial introducem nr de vîrfuri n
puts("Nr. de varfuri: ");
scanf("%d", &n);
și fiecărui vârf îi atribuim vârfurile spre care ele pleacă. Completând linia numărul 1, pentru vârful
inițial, trecem la vârful numărul 2, marcând finalul liniei prin 0.
for (i=1; i<=n; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor(WHITE);
k=0;
t=graph_add(begin,i);
scanf("%d", &k);
while(k)
{
list_add(&(t->bow),k,1);
scanf("%d", &k);
}
}
Pentru a lua în consideraţie lungimea variabilă a liniilor se utilizează variabile dinamice şi pointeri.

Sarcina nr.2

Afișarea de la ecran a trei forme de stocare a grafului:

a) Matrice de incidență
b) Matrice de adiacență
c) Listă de adiacență

a) Afișarea ca matrice de incidență:

Pentru aceasta am creat o funcție show_matinc. În cazul dacă matricea nu a fost inițial citită, se va
afișa la ecran alerta “Graful este vid”. Inițializez o matrice 2d de tip int **mat, și o egalez cu funcția
ft_newmat, astfel alocîndu-i memorie dinamic:
mat=(int**)malloc(sizeof(int*) *m);
if (!mat) return (NULL);
for (i=0; i<m; i++){ mat[i]=(int*)malloc(sizeof(int) *n);

Apoi cu ajutorul funcției ft_initmat, în care sunt păstrate valorile matricei:

for(i=0; i<m; i++)
for(j=0; j<n; j++)
mat[i][j]=value;
În cazul în care valoarea vârfului inițial era egală cu valoarea vârfului final (buclă), se afișează
valoarea- 2. Iar în restul cazurilor vârfului inițial i se atribuia -1, iar celui final 1. După care se afișează
matricea, și apoi îi dealocăm memorie prin funcția ft_freemat.

while(begin)
{
lst=begin->bow;
while(lst)
{
if (lst->node==begin->node)
mat[i++][lst->node-1]=2;
else
{
mat[i][lst->node-1]=1;
mat[i++][begin->node-1]=-1;
}
lst=lst->next;
}
begin=begin->next;
 b) Afișarea ca matrice de adiacență
Pentru aceasta, am creat o funcție show_matad. Apoi declar o matrice 2d patratică: int **mat,
cărieia ulterior îi atribui funcția get_matad, prin care în cazul în care valoarea vârfului inițial va
coincide cu numărul unei linii și valoarea vârfului final cu număru unei coloane, intersecției liniei
și coloanei respective i se atribuia valoarea 1:
while(begin){
lst=begin->bow;
while(lst){
mat[begin->node-1][lst->node-1]=lst->weight;
lst=lst->next; }
begin=begin->next; }
astfel parcurgând întraga matrice.

void show_matadc(t_graph *begin)

{
int n;
int **mat;

submenu("\nAfisarea grafului ca matricea de adiacenta");

if(!begin)
{
ft_error("Graful este vid!");
return;
}
mat=get_matadc(begin, &n);
ft_showmat(mat, n, n, 'X');
ft_freemat(&mat, n);
}

c) Afișarea ca listă de adiacență

Pentru aceasta am creat o funcție show_list, în care se va printa vîrful inițial, iar imediat după
el, vîrfurile în care pleacă vârful initial, separate prin ` `. Atunci când se va ajunge la elementul
nul, 0, se va considera sfârșit de rând și se va printa \n, după care se va lua vîrful următor, și așa
pînă la afișarea tuturor vîrfurilor și conexiunilor dintre ele:

while (begin)
{
SetColor(MAGENTA);
printf("%3d: ",begin->node);
SetColor(WHITE);
t=begin->bow;
while(t) {
ft_putnbr(t->node);
putchar(' ');
t=t->next;
}
ft_putnbr(0);
putchar('\n');
begin=begin->next;
}

Sarcina nr.3
Redacatare grafului:

a)Ștergerea unui arc

b) Adăugarea unui arc
c) Ștergerea unui vârf
d) Adăugarea unui vârf
a) Ștergerea unui arc
Pentru aceasta am creat funcția del_bow. Inițial introduc sursa( vârful inițial):
putstr("Sursa"):
scanf("%d",&k);

apoi destinația( vârful final):

putstr("Destinatia");
scanf("%d",&k);

în cazul dacă astfel de arc există, trecem la funcția list_del(&(t->bow),k):

t=*begin;
if((*begin)->node==node)
{
*begin=(*begin)->next;
free(t);
}
Prin care în cazul în care se va găsi acest arc, el va fi șters.

b) Adaugarea unui arc

Pentru aceasta am creat funcția add_bow. Inițial introduc sursa( vârful inițial), apoi destinația( vârful final):
puts("Sursa: ");
scanf("%d", &k);
putstr("Destinatia:");
scanf("%d",&k);

dacă vârful sursă nu va fi depistat, se va afișa eroarea : ”nod inexistent”, în caz contrar trecem la funcția
list_add:
if(*begin)
{ g=*begin;
while (g->next)
g=g->next;
g->next=t; }
prin care se reverifică ordinea tuturor vârfurilor sursă, și se va readăuga arcul nou introdus.

c)Ștergerea unui vîrf

Pentru aceasta am creat funcția del_node. Introducem vârful ce dorim să fie șters:
putstr("Nr.de varfuri: ");
scanf("%d",&node);
găsim acest vârf cu ajutorul funcție find_node, după ce vîrful va fi găsit, el va fi șters, iar poziția celorlalte
vârfuri se va muta cu o poziție în urmă:
g=t->next;
free_node(begin, &t);
while(g){

(g->node)--;
g=g->next;
}

d) Adăugarea unui vârf

Pentru aceasta, am creat funcția add_node,
while(t){ t=t->next;
i++;}
care va adăuga un nod la sfârșitul grafului.

void add_node(t_graph **begin)

{ int i=1;
t_graph *t;
submenu ("\nAdaugarea varfului:");
t=*begin;
while(t){ t=t->next; i++;}
graph_add(begin,i); SUCCES;}
Concluzii
Această lucrare de laborator are scopul de a înțelege metode de stocare și modificare a informației în
grafuri.
În cadrul primei sarcini am efectuat introducerea de la tastatură a unui graf prin citirea sa în cele trei
forme, și anume: matrice de adiacență, matrice de incidență și listă de adiacență.
În cadrul sarcinii numărul doi, am afișat graful introdus anterior,în cele 3 forme posibile: matrice de
adiacență, matrice de incidență și listă de adiacență, respectiv, am efectual convertirea dintr-o formă în alta.
Sarcina nr 3 constă în editarea grafului. În cadrul ei am șters/adăugat un vârf/muchie.

În urma lucrării la sarcinile lucrăriii de laborator, concluzionez că reprezentarea grafurilor prin

intermediul listelor permite utilizarea mai eficace a memoriei calculatorului, însă aceste forme sunt mai
complicate atât în realizare, cât şi în timpul procesării.

Această lucrare de laborator a avut un rol important în procesul de studiere a materialelor teoretice la
matematica discretă, precum și în studierea aprofundată a limbajului de programare C. Totuși cel mai
semnificativ impact rămâne îmbunătățirea gândirii și a logicii, ce poate fi aplicată ulterior în toate
domeniile posibile.
Anexa
Listingul programului
#define WAIT putstr("Apasati orice tasta pentru a iesi .."); getch(); putchar('\n')
#define UNKNOWN ft_error("Optiune necunoscuta")
#define SUCCES SetColor (GREEN); puts("succes!"); SetColor(WHITE);
#define PARAM t_list**, int, int*
#define RED 12
#define GREEN 10
#define MAGENTA 13
#define CYAN 11
#define WHITE 15
#define MAX 10000000
#define MIN -10000000*/

typedef struct s_list

{
int node;
int weight;
struct s_list *next;

} t_list;

typedef struct s_graph

{
int node;
t_list *bow;
struct s_graph *next;
} t_graph;

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<windows.h>
#include<dos.h>
#include<dir.h>
#include<conio.h>
#include<limits.h>

void SetColor(int ForgC) //functie pentru setarea culorilor

{
WORD wColor;

HANDLE hStdOut= GetStdHandle(STD_OUTPUT_HANDLE);

CONSOLE_SCREEN_BUFFER_INFO csbi;
if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
{
wColor=(csbi.wAttributes & 0xF0)+(ForgC & 0x0F);
SetConsoleTextAttribute(hStdOut, wColor);
}
return;
}

void ft_error(char *str) //afiseaza eroare

{
SetColor (RED);

puts(str);
SetColor (WHITE);
}

int **ft_newmat(int m, int n) //aloca mem dinamica mat

{
int i;
int **mat;

mat=(int**)malloc(sizeof(int*) *m);
if (!mat)
return (NULL);
for (i=0; i<m; i++)
{
mat[i]=(int*)malloc(sizeof(int) *n);

if (!mat[i])
 return(NULL);
}
return(mat);
}

void ft_freemat(int ***mat, int m) //dealoca matricea

{
int i;

if(*mat==NULL)
return;
for(i=0; i<m; i++)
free((*mat)[i]);
free(*mat);

void ft_initmat(int **mat, int m, int n, int value) //initializarea matricei

{
int i;
int j;

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

for(j=0; j<n; j++)
mat[i][j]=value;

}
void ft_putnbr(int n) // introducerea nr de varfuri
{
long k;

k=(n<0)?-n:n;
if(n<0)
putchar('-');
if(k>=0 && k<=9)
putchar('0' + k);
else
{
ft_putnbr(k/10);
putchar(k % 10 + '0');
}
}
void putstr(char*str)
{
while(*str)
putchar(*(str++));
}
int ft_intlen(int k)
{
int i;
i=0;
if(k==0)
return(1);
if(k<0)
i++;
while(k)
{
k/=10;
i++;
}
return(i);
}
int putnchar(char c, int n)
{
while (n-- >0)
putchar(c);
return 0;
}
int ft_maxlen(int **mat, int m, int n)
{
int i;
int j;
int max;

if(!mat)
return(0);
 max = ft_intlen(**mat);
for(i=0; i<m; i++)
for(j=0; j<n; j++)
if(max<ft_intlen(mat[i][j]))
max=ft_intlen(mat[i][j]);
return(max);
}
void ft_showmat(int **mat, int m, int n, char type)
{
int i;
int j;
int k;
int max_len;
int type_len;

max_len=ft_maxlen(mat, m , n)+2;
if ( max_len < ft_intlen(n)+1)
max_len=ft_intlen(n)+1;
type_len=ft_intlen(m)+1;
putnchar(' ', type_len+1);
SetColor(MAGENTA);
for(i=1; i<=n; i++)
{
putnchar(' ', max_len-ft_intlen(i)-1);
putchar('X');
ft_putnbr(i);
}
SetColor(WHITE);
putchar('\n');
for(i=0; i<m; i++)
{
SetColor(MAGENTA);
putnchar(' ', type_len-ft_intlen(i+1));
putchar(type);
ft_putnbr(i+1);
SetColor(WHITE);
for(j=0; j<n; j++)
{

k=mat[i][j];
putnchar(' ', max_len-ft_intlen(k));
if(k!=0)
SetColor(GREEN);
ft_putnbr(mat[i][j]);
SetColor(WHITE);

}
putchar('\n');
}

}
void not_found(int k)
{
SetColor(RED);
putstr("Nu a fost gasit varful");
ft_putnbr(k);
puts("din graf!");
SetColor(WHITE);

}
int check_graph(t_graph *begin)
{

int nodes;
t_graph *t;
t_list *list;

nodes=0;
t= begin;
while(t)
{
t=t->next;
nodes++;
}
while(begin)
{
 list=begin-> bow;
while(list)
{
if(list->node>nodes|| list->node<1)
{
not_found(list->node);
return(1);
}
list=list->next;
}
begin=begin->next;
}
return(0);
}
void free_list(t_list**begin)
{
t_list *t;
while(*begin)
{
t=*begin;
*begin=t->next;
free(t);
}
}
void free_graph(t_graph **begin)
{
t_graph *t;
while(*begin)
{
t=*begin;
*begin=(*begin)->next;
free_list(&(t->bow));
free(t);
}
*begin=NULL;
}
t_list *list_new(int node, int weight)
{

t_list *t;

t=(t_list*)malloc(sizeof(t_list));
if(!t)
{

ft_error("erroare la alocare!");
exit(1);
}
t->node=node;
t->weight=weight;
t->next=NULL;
return(t);
}
void list_add(t_list**begin, int node, int weight)
{

t_list *t;
t_list *g;
t=list_new(node, weight);
if(*begin)
{
g=*begin;
while (g->next)
g=g->next;
g->next=t;

}
else
*begin=t;
}
t_graph *graph_add(t_graph **begin, int node)
{
t_graph *t;
t_graph *g;

t=(t_graph*)malloc(sizeof(t_graph));
 t->bow=NULL;
t-> node=node;
t->next=NULL;
if(*begin)
{
g=*begin;
while(g->next)
g=g->next;
g->next=t;

}
else
*begin=t;
return(t);
}
void submenu(char *str)
{
SetColor(CYAN);
puts(str);
SetColor(WHITE);
}
void menu_list(char *str)
{
SetColor (GREEN);
while(*str!='-'&& *str)
putchar(*(str++));
SetColor(WHITE);
puts(str);
}
void read_glist(t_graph **begin) //citeste mat ca lista de adiacenta
{
int n;
int i;
int k;
t_graph *t;

submenu("\n Citirea grafului ca lista de adiacenta:");

puts("Nr. de varfuri: ");
scanf("%d", &n);
for (i=1; i<=n; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor(WHITE);
k=0;
t=graph_add(begin,i);
scanf("%d", &k);
while(k)
{
list_add(&(t->bow),k,1);
scanf("%d", &k);
}
}
}
t_graph *find_node(t_graph *begin, int node) // cauta nodul in lista
{
while(begin)
{
if(begin->node==node)
return(begin);
begin=begin->next;
}
return(NULL);
}
void read_matinc(t_graph **begin) // citeste mat ca matrice de incidenta
{
int n;
int b;
int i;
int j;
int k;
int node;
t_graph *t;

submenu("\n Citirea grafului ca matrice de incidenta ");

putstr(" Nr. de varfuri:");
 scanf("%d", &n);
putstr("Nr.de muchii : ");
scanf("%d", &b);
for(i=1; i<=n; i++)
graph_add(begin, i);
for(i=1; i<=b; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor (WHITE);
for(j=1; j<=n; j++)
{
t=NULL;
scanf("%d", &k);
if(k==1)
node=j;
else if (k==-1)
t=find_node(*begin,j);
else if(k!=0)
{
node=j;
t=find_node(*begin,j);
}
}
if(!t)
{
SetColor(RED);
printf("Nu a fost gasit varful %d!\n",k);
SetColor(WHITE);
}
else
list_add(&(t->bow), node, 1);
}
}
void read_matadc(t_graph**begin) // citeste mat ca matrice de adiacenta
{
int n;
int i;
int j;
int k;
t_graph*t;

submenu ("\nCitirea grafului ca matricea de adiacenta");

puts("Nr. de varfuri: ");
scanf("%d", &n);
for(i=1; i<=n; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor (WHITE);
t=graph_add(begin, i);
for(j=1; j<=n; j++)
{
scanf("%d", &k);
if(k!=0)
list_add(&(t->bow),j,k);
}
}
}
void read_graph(t_graph**begin) //citirea mat menu
{
char c;

if (*begin)
free_graph(begin);
submenu("\nCitirea grafului");
puts("Cum doriti sa fie citit graful ?");
menu_list("1 - Matricea de incidenta");
menu_list("2 - Matricea de adiacenta");
menu_list("3 - Lista de adiacenta");
menu_list("4 - Inapoi");
c=getch();
c=toupper(c);
if(c=='1')
read_matinc(begin);
else if(c=='2')
 read_matadc(begin);
else if (c=='3')
read_glist(begin);
else if(c=='4')
return;
else
{
UNKNOWN;
read_graph(begin);
return ;

}
WAIT;
}
void get_graphsize(t_graph *t, int *n, int *b)
{
t_list *lst;
*n=0;
*b=0;
while(t)
{
(*n)++;
lst=t->bow;
while(lst)
{
lst=lst->next;
(*b)++;
}
t=t->next;
}
}
void show_matinc(t_graph*begin) //afisarea ca matrice de incidenta
{
int i=0;
int n;
int b;
int **mat;
t_list *lst;
submenu("\nAfisarea Grafului ca matricie de incidenta");
if(!begin)
{
ft_error("Graful este vid");
return;
}
get_graphsize(begin, &n, &b);
mat=ft_newmat(b, n);
ft_initmat(mat, b, n, 0);
while(begin)
{
lst=begin->bow;
while(lst)
{
if (lst->node==begin->node)
mat[i++][lst->node-1]=2;
else
{
mat[i][lst->node-1]=1;
mat[i++][begin->node-1]=-1;
}
lst=lst->next;
}
begin=begin->next;
}
ft_showmat(mat, b, n, 'U');
ft_freemat(&mat, b);

}
int **get_matadc(t_graph *begin, int*n)
{
int i;
int **mat;
t_list *lst;

get_graphsize(begin, n, &i);
mat=ft_newmat(*n,*n);
ft_initmat(mat, *n, *n ,0);
 while(begin)
{
lst=begin->bow;
while(lst)
{
mat[begin->node-1][lst->node-1]=lst->weight;
lst=lst->next;
}
begin=begin->next;
}
return(mat);
}
void show_matadc(t_graph *begin) //afisarea ca mat de adiacenta
{
int n;
int **mat;

submenu("\nAfisarea grafului ca matricea de adiacenta");

if(!begin)
{
ft_error("Graful este vid!");
return;
}
mat=get_matadc(begin, &n);
ft_showmat(mat, n, n, 'X');
ft_freemat(&mat, n);
}
void show_list(t_graph *begin)
{
t_list *t;

submenu("\nAfisarea grafului ca matricea de adiacenta");

if(!begin)
{
ft_error("Graful este vid!");
return;
}
while (begin)
{
SetColor(MAGENTA);
printf("%3d: ",begin->node);
SetColor(WHITE);
t=begin->bow;
while(t)
{
ft_putnbr(t->node);
putchar(' ');
t=t->next;
}
ft_putnbr(0);
putchar('\n');
begin=begin->next;

}
}
void show_graph(t_graph*begin) //afisarea mat menu
{
char c;

submenu("\nAfisarea Grafului");
puts("Cum doriti sa fie graful?");
menu_list("1-Matricea de incidenta");
menu_list("2-Matricea de adiacenta ");
menu_list("3-Lista de adiacenta");
menu_list("4-Inapoi");
c=getch();
c=toupper(c);
if (c=='1')
show_matinc(begin);
else if (c=='2')
show_matadc(begin);
else if(c=='3')
show_list(begin);
else if(c=='4')
return;
else
 {
UNKNOWN;
show_graph(begin);
return;
}
WAIT;
}
void add_bow(t_graph *begin) //adaugare arc
{
int k;
int weight;
t_graph *t;
t_list *lst;

submenu("\n Adaugarea arcului");

puts("Sursa: ");
scanf("%d", &k);
t=find_node(begin, k);
if(!t)
ft_error("nod inexistent");
else
{
putstr("Destinatia:");
scanf("%d",&k);
lst=t->bow;
while(lst&&lst->node!=k)
lst=lst->next;
if(lst)
ft_error("Arcul deja exista");
else
{
do{
putstr("Ponderea:");
scanf("%d", &weight);
if(weight==0)
ft_error("Ponderea trebuie sa fie diferita de 0 !");
}
while(weight==0);
list_add(&(t->bow), k, weight);
SUCCES;
}
}
}
void list_del(t_list **begin, int node)
{
t_list *t;
t_list *g;

if(!*begin)
return;
t=*begin;
if((*begin)->node==node)
{
*begin=(*begin)->next;
free(t);
}
else
{
while (t->node !=node && t->next)
{
g=t;
t=t->next;
}
if(t->node==node)
{
g->next=t->next;
free(t);
}
}
}
void del_bow(t_graph *begin) //stergere arc
{
int k;
t_graph *t;
t_list *lst;
 submenu("\nStergerea arcului:");
putstr("Sursa");
scanf("%d",&k);
t=find_node(begin,k);
if(!t)
ft_error("nod inexistent");
else
{
putstr("Destinatia");
scanf("%d",&k);
lst=t->bow;
while(lst && lst->node!=k)
lst=lst->next;
if(!lst)
ft_error("Arcul dat nu exista");
else
{
list_del(&(t->bow),k);
SUCCES;
}
}
}
void add_node(t_graph **begin) //adaugarea varfurilor
{
int i=1;
//char c;
t_graph *t;

submenu ("\nAdaugarea varfului:");

t=*begin;
while(t)
{
t=t->next;
i++;
}
graph_add(begin,i);
SUCCES;
}
void free_node(t_graph **begin, t_graph **del)
{
t_graph *g;

if(*del==*begin)
{
*begin=(*begin)->next;
(*del)->next=NULL;
free_graph(del);
}
else
{
g=*begin;
while(g->next!=*del)
g=g->next;
g->next=(*del)->next;
(*del)->next=NULL;
free_graph(del);
}
}
void del_node(t_graph **begin) //stergerea varfurilor
{
int node;
t_graph *t;
t_graph *g;
t_list *lst;
submenu("\nStergerea varfului:");
putstr("Nr.de varfuri: ");
scanf("%d",&node);
t=find_node(*begin, node);
if(!t)
{
ft_error("varful dat nu exista!");
return;
}
g=t->next;
free_node(begin, &t);
while(g)
 {
(g->node)--;
g=g->next;
}
t=*begin;
while(t)
{
list_del(&(t->bow),node);
lst=t->bow;
while(lst)
{
if (lst->node>node)
(lst->node)--;
lst=lst->next;
}
t=t->next;
}
SUCCES;
}
void modify_graph(t_graph **begin) //modificarea grafilui menu
{
char c;

submenu("\n Modificarea grafului:");

puts("ce doriti sa modificati in graf ?");
menu_list("1-Adaugarea arcului");
menu_list("2-Eliminarea arcului");
menu_list("3-Adaugarea varfului");
menu_list("4-Eliminarea varfului");
menu_list("5-inapoi");
c=getch();
c=toupper(c);
if(c=='1')
add_bow(*begin);
else if (c=='2')
del_bow(*begin);
else if (c=='3')
add_node(begin);
else if (c=='4')
del_node(begin);
else if (c=='5')
return;
else {
UNKNOWN;
modify_graph(begin);
return;
}
WAIT;
}

void showmenu(t_graph **begin)

{
char c;
submenu("\nMenu");
menu_list("1-Citirea grafului");
menu_list("2-Afisarea grafului");
menu_list("3-Modificarea grafului");
menu_list("4-Parcurgerea grafului");
menu_list("5- Iesire");
c=getch();
c=toupper(c);
if(c=='1')
read_graph(begin);
else if (c=='2')
show_graph(*begin);
else if (c=='3')
modify_graph(begin);

else if (c=='4')
search_graph(begin);
else if (c=='5')
return;
else UNKNOWN;
showmenu(begin);
}
int main()
{
t_graph *begin;

begin=NULL;
showmenu(&begin);
free_graph(&begin);
return 0;
}

Bibliografie
V.Beșliu „Matematica Discretă.Ciclu de prelegeri”, Chișinău,2002

T.Brânzaru Matematici Speciale, București,1981