Programma C++: Grafo

#include <iostream.h>

typedef struct adiacenti

{ int x;

adiacenti *right;

}adiacenti;

typedef struct nodo

{ int x;

nodo *down;

adiacenti *right;

}nodo;

class grafo

{ nodo *first;

void distr_nodi(nodo* &p);

void distr_adiacenti(adiacenti* &p);

void print_nodi(nodo* & p);

void print_adiacenti(adiacenti* &p);

void ins_nodo(nodo* &p);

void copy_nodo (nodo *v,nodo * &n);

void copy_adiac (adiacenti *v,adiacenti* &n);

void ins_arc(adiacenti* &p,int a);

void trova_nodo(nodo* &p,int n);

void canc_arc(adiacenti* &p,int a);

void dept_ferst1(int start,int *mark);

static void somma_adiac(int y,adiacenti * &p);

static void somma_nodo (int y,nodo* &p);

public:

grafo operator +(int n);

grafo();

int numnodi;

~grafo();

void stampa();

void insnodo();

void insarc(int n,int a);

void cancarc(int n,int a);

grafo operator = (grafo op);

grafo (grafo & op);

void dept_ferst(int start);

void visita(adiacenti* &p,int *mark);

};

//deptfirst

void grafo::visita(adiacenti* &p,int *mark)

{if(p!=NULL)

{if(mark[p->x-1]==0)

{dept_ferst1(p->x,mark);

visita(p->right,mark);

}

}

}

void grafo::dept_ferst(int start)

{int *mark=new int[numnodi];

for(int i=1;i<=numnodi;i++)

mark[i]=0;

dept_ferst1(start,mark);

}

void grafo::dept_ferst1(int start,int *mark)

{if(mark[start-1]==0)

{mark[start-1]=1;

nodo* tmp=first;

trova_nodo(tmp,start);

visita(tmp->right,mark);

}

}

//metodo privato per la copia degli adiacenti

void grafo::copy_adiac(adiacenti *v,adiacenti * &n)

{if (v!=NULL)

{n=new adiacenti;

n->x=v->x;

copy_adiac(v->right,n->right);

}

else n=v;

}

//metodo privato per la copia dei nodi

void grafo::copy_nodo(nodo * v,nodo* &n)

{if(v!=NULL)

{n=new nodo;

n->x=v->x;

copy_adiac(v->right,n->right);

copy_nodo(v->down,n->down);

}

else n=v;

}

//procedura privata per la somma di y con adiacenti

void grafo:: somma_adiac(int y,adiacenti* &p)

{if(p!=NULL)

{p->x=p->x+y;

somma_adiac(y,p->right);

}

}

//procedura privata per la somma di y con i nodi

void grafo::somma_nodo(int y,nodo* &p)

{if(p!=NULL)

{p->x=p->x+y;

somma_adiac(y,p->right);

somma_nodo(y,p->down);

}

}

//overloading dell'operatore +:somma l'intero passato con tutti gli elementi del

grafo

grafo grafo ::operator +(int n)

{if (first!=NULL)

{grafo tmp=*this;

somma_nodo(n,tmp.first);

return tmp;

}

}

void grafo::cancarc(int n,int a)

{ nodo *tmp=first;

trova_nodo(tmp,n);

canc_arc(tmp->right,a);

};

void grafo::canc_arc(adiacenti* &p,int a)

{ if(p!=NULL)

{ canc_arc(p->right,a);

if(p->x==a)

{ adiacenti *tmp=p->right;

delete p;

p=tmp;

}

}

};

grafo::grafo()

{ first=NULL;

numnodi=0;

};

grafo::~grafo()

{ distr_nodi(first);

};

void grafo::distr_nodi(nodo* &p)

{ if (p!=NULL)

{ distr_nodi(p->down);

distr_adiacenti(p->right);

delete p;

}

};

void grafo::distr_adiacenti(adiacenti* &p)

{ if(p!=NULL)

{ distr_adiacenti(p->right);

delete p;

}

};

//Procedure per stampare un grafo

void grafo::stampa()

{ if (first!=NULL) print_nodi(first);

else cout<<"Grafo vuoto!";

};

void grafo::print_nodi(nodo* &p)

{

if(p!=NULL)

{

cout<<"Nodo "<<p->x<<endl;

print_adiacenti(p->right);

print_nodi(p->down);

}

};

void grafo::print_adiacenti(adiacenti* &p)

{

if(p!=NULL)

{

cout<<"adiacente a "<<p->x<<endl;

print_adiacenti(p->right);

}

};

//overloading dell'operatore =

grafo grafo:: operator = (grafo op)

{if(op.first!=NULL)

{distr_nodi(first);

copy_nodo(op.first,first);

return *this;

}

else {first=NULL;

return *this;

}

}

//costruttore copy

grafo::grafo(grafo & op)

{if(op.first!=NULL)

{copy_nodo(op.first,first);

}

else {first=NULL;

cout<<"\n grafo vuota(vista dal costruttore copy)";

}

}

//Procedure per l'inserimento di un nodo

void grafo::insnodo()

{

ins_nodo(first);

};

void grafo::ins_nodo(nodo* &p)

{

if(p!=NULL) ins_nodo(p->down);

else

{ p=new nodo;

numnodi++;

p->x=numnodi;

p->right=NULL;

p->down=NULL;

}

};

void grafo::ins_arc(adiacenti* &p,int a)

{ if(p!=NULL)

ins_arc(p->right,a);

else

{ p=new adiacenti;

p->x=a;

p->right=NULL;

}

};

void grafo::insarc(int n,int a)

{

nodo* tmp=first;

trova_nodo(tmp,n);

ins_arc(tmp->right,a);

};