Documente Academic
Documente Profesional
Documente Cultură
1 6 In figura alaturata:
V={1,2,3,4,5,6} sunt noduri
5 E={[1,2], [1,4], [2,3],[3,4],[3,5]} sunt muchii
2 G=(V, E)=({1,2,3,4,5,6}, {[1,2], [1,4], [2,3],[3,4],[3,5]})
3 4
Grad = Gradul unui nod v, dintr-un graf neorientat, este un numr natural
ce reprezint numrul de noduri adiacente cu acesta (sau numarul de
muchii incidente cu nodul respectiv)
Lan compus= lanul care nu este format numai din muchii distincte
Ciclul este elementar dac este format doar din noduri distincte,
excepie fcnd primul i ultimul. Lungimea unui ciclu nu poate fi 2.
Succesiunea de vrfuri 2, 3, 5, 6
reprezint un lan simplu i
elementar de lungime 3.
Lanul 5 3 4 5 6 este simplu dar nu
este elementar.
Lanul 5 3 4 5 3 2 este compus i
nu este elementar.
Lanul 3 4 5 3 reprezint un ciclu
elementar
Graf partial = Dac dintr-un graf G=(V,E) se suprim cel puin o muchie
atunci noul graf G=(V,E), E E se numete graf parial al lui G (are
aceleasi noduri si o parte din muchii).
1 6 1 6
5 5
2 2
3 4 3 4
5 5
2 2
3 4 3
1 6
5
2
3 4
3 4
graf complet. Nr de muchii: 4x(4-1)/2 = 6
1 6
5
2
3 4
graf conex nu este graf conex
1 6
5
2
3 4
graful nu este conex. Are 2 componente conexe:
1, 2 si 3, 4, 5, 6
Lan hamiltonian = un lan elementar care conine toate nodurile unui
graf
1 6
5
2
3 4
L=[2 ,1, 6, 5, 4, 3] este lant hamiltonian
Ciclu hamiltonian = un ciclu elementar care conine toate nodurile
grafului
1 6
5
2
3 4
C=[1,2,3,4,5,6,1] este ciclu hamiltonian
Daca G este un graf cu n>=3 noduri astfel incat gradul fiecarui nod este
mai mare sau egal decat n/2 atunci G este hamiltonian
Lan eulerian = un lan simplu care conine toate muchiile unui graf
1, daca [i,j]E
a[i,j]=
0, altfel
Observatii:
1 6
0 1 0 1 0 0 nodul 1 are gradul 2
1 0 1 0 0 0 nodul 2 are gradul 2
5
A= 0 1 0 1 1 0 nodul 3 are gradul 3
2 1 0 1 0 0 0 nodul 4 are gradul 2
0 0 1 0 0 0 nodul 5 are gradul 1
3 4
0 0 0 0 0 0 nodul 6 are gradul 0
3-4=> a[3,4]=a[4,3]=1
Reprezentarea in calculator a unui graf se poate face utilizand listele de adiacenta a varfurilor,
adica pentru fiecare varf se alcatuieste lista varfurilor adiacente cu el.
5
2
3 4
5
2
3 4
Nodul 1 : 2 4
Nodul 2 :
1 3
Nodul 3 : 2 4 5
Nodul 4 : 1 3
Nodul 5 : 3
Ordinea nodurilor in cadrul unei liste nu este importanta
nod *L[20];
#include<conio.h>
#include<fstream.h>
struct nod
{int nd;
nod *next;};
nod *L[20];
void main()
{fstream f;int i,j,n;
nod *p,*q;
Observatie : In exemplul anterior adaugarea unui nou element in lista se face inainte
celorlalte din lista corespunzatoare.
Aceste doua moduri de reprezentare (prin matrice de adiacenta si prin liste de vecini) se
folosesc dupa natura problemei. Adica, daca in problema se doreste un acces frecvent la
muchii, atunci se va folosi matricea de adiacenta; daca numarul de muchii care se reprezinta
este mult mai mic dect nxn, este de preferat sa se folosesca listele de adiacenta, pentru a se
face economie de memorie.
Parcurgerea
La explorarea in latime, dupa vizitarea nodului initial, se exploreaza toate nodurile adiacente
lui, se trece apoi la primul nod adiacent si se exploreaza toate nodurile adiacente acestuia si
neparcurse inca, s.a.m.d.
Fiecare nod se parcurge cel mult odata (daca graful nu este conex nu se vor putea parcurge
toate nodurile)
De exemplul pentru garful din figura de mai jos, se va proceda in felul urmator:
1 6
5
2
3 4
5
2
3 4
se obtine 1,2,4
dupa care din 2 se exploreaza nodul adiacent acestuia 3. Nodul 1 nu se mai viziteaza odata
1 6
5
2
3 4
se obtine 1,2,4,3
1 6
5
2
3 4
se obtine 1, 2, 4, 3, 5
Algoritmul
Se va folosi o coada in care se inscriu nodurile in forma in care sunt parcurse: nodul initial
varf (de la care se porneste), apoi nodurile a,b,..., adiacente lui varf, apoi cele adiacente lui a,
cele adiacente lui b,... ,s.a.m.d.
#include<fstream.h>
#include<conio.h>
int a[10][10],c[20],viz[10];
int n,m,prim,ultim,varf;
void main()
{clrscr();
int x,y;
fstream f; //memorare graf in matrice de adiacenta
f.open("muchii.txt",ios::in);
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>x>>y;
a[x][y]=a[y][x]=1;
}
int nd;
prim=ultim=1;
cout<<"nodul de inceput=";
cin>>nd; // nodul de la care se porneste parcurgerea
viz[nd]=1;
c[prim]=nd;
bf_iterativ();
for(i=1;i<=ultim;i++) //afisarea cozii
cout<<c[i]<<" ";
getch();
}
Parcurgerea in latime a grafurilor memorate prin liste este similara cu diferenta ca vecinii unui
nod adaugat in coada se cauta in lista corespunzatoare lui :
#include<conio.h>
#include<fstream.h>
struct nod
{int nd;
nod *next;};
nod *L[20];
int viz[100]; //marchez cu 1 nodurile vizitate
int m,n;
int prim,ultim,C[100];
void bfi_lis()
{int varf,nr;
nod *p;
while(prim<=ultim)
{varf=C[prim];
p=L[varf]; // se parcurge lista elementelor din varful cozii
while(p)
{nr=p->nd;
if(viz[nr]==0) //numai daca nu a fost vizitat
{ultim++; //maresc coada
C[ultim]=nr; //il adaug in coada
viz[nr]=1;}; //il marchez ca fiind vizitat
p=p->next;
}
prim++; //avansez la urmatorul nod din coada
}
}
void main()
{fstream f;
int i,j;
nod *p,*q;
f.open("muchii.txt",ios::in);
clrscr();
f>>n>>m;
while(f>>i>>j)
{p=new nod;
p->nd=j;
p->next=L[i];
L[i]=p;
q=new nod;
q->nd=i;
q->next=L[j];
L[j]=q;
}
f.close();
for(i=1;i<=n;i++)
afisare(i);
int ndr;
cout<<endl<<"nodul de inceput ";
cin>>ndr;
viz[ndr]=1;
prim=ultim=1;
C[prim]=ndr;
cout<<endl<<"parcurgere in latime "<<endl;
bfi_lis();
for(i=1;i<=ultim;i++)
cout<<C[i]<<" ";
getch();
}
Functia recursiva :
void bfr_lis()
{int varf,nr;
nod *p;
if(prim<=ultim)
{varf=C[prim];
p=L[varf];// se parcurge lista elementelor din varful cozii
while(p)
{nr=p->nd;
if(viz[nr]==0)//numai daca nu a fost vizitat
{ultim++;//maresc coada
C[ultim]=nr;//il adaug in coada
viz[nr]=1;};//il marchez ca fiind vizitat
p=p->next;}
prim++; //avansez la urmatorul nod din coada
bfr_lis();
}
}
Parcurgerea unui graf in adancime se face prin utilizarea stivei (alocate implicit
prin subprograme recursive).
Pentru fiecare nod se parcurge primul dintre vecinii lui neparcursi inca
Dupa vizitarea nodului initial x 1, se exploreaza primul nod adiacent lui fie acesta
x2 , se trece apoi la primul nod adiacent cu x 2 si care nu a fost parcurs inca ,
s.a.m.d.
Fiecare nod se parcurge cel mult odata (daca graful nu este conex nu se vor
putea parcurge toate nodurile)
De exemplul pentru garful din figura de mai jos, se va proceda in felul urmator:
5
2
3 4
1 6
5
2
3 4
se obtine 1,2
dupa care din 2 se exploreaza un nod adiacent cu acesta si care nu a fost vizitat :
3.( Nodul 1 nu se mai viziteaza odata)
1 6
5
2
3 4
se obtine 1,2,3
1 6
5
2
3 4
se obtine 1, 2, 3, 4
Pentru nodul 4 ar trebui sa se parcurga primul sau vecin neparcurs (nodul 1 dar
acesta a fost deja parcurs. Si nodul 3 a fost parcurs. Din 4 nu mai avem ce vizita
si se trece la nivelul anterior din stiva, la nodul 3 :
5
2
3 4
SE obtine : 1, 2, 3, 4 , 5.
Nodul 3 nu mai are vecini nevizitati si se trece pe nivelul anterior din stiva, nodul
2 : 1, 2, 3, 4 , 5. Nici acesta nu mai are vecini nevizitati si se trece pe nivelul
anterior la nodul 1 : 1, 2, 3, 4 , 5. Cum nici acesta nu mai are vecini nevizitati se
incheie algoritmul.
Algoritmul
-ca si la parcurgerea in latime vecinii unui nod se cauta pe linia acestui nod :
daca a[nod][k]=1 inseamna ca nodurile nod si k sunt adiacente. Pentru ca nodul
k sa fie fie parcurs trebuie ca nodul sa nu fi fost vizitat : viz[k]=0
#include<fstream.h>
#include<conio.h>
int a[20][20],n,m,viz[100],gasit;
cout<<nod<<" ";
viz[nod]=1;
for(int k=1;k<=n;k++)
if(a[nod][k]==1&&viz[k]==0)
dfmr(k);
}
void main()
{int x,y,j;
fstream f;
clrscr();
f.open("graf.txt",ios::in);
if(f)
cout<<"ok!"<<endl;
else
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>x>>y;
a[x][y]=a[y][x]=1;}
cout<<endl<<"matricea de adiacente"<<endl;
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<a[i][j]<<" ";
cout<<endl;}
dfmr(1)
getch();}
Matricea lanturilor
Fie G=(V, E) un graf neorientat, unde V are n elemente (n noduri) si E are m elemente (m
muchii). Lui G i se asociaza matricea D numita matricea lanturilor, cu n linii si n coloane.
1 0111100
6 7
1011100
5 1101100
2 1110100
3 4 1111000
0000001
0000010
Linia k (sau coloana k) a matricei lanturilor ne arata nodurile j pentru care exista lant de k la j
( si de la j la k). Spre exemplu, pentru nodul 3 .
1 0111100
6 7
1011100
5 1101100
2 1110100
3 4 1111000
0000001
0000010
Problema:
Fiind dat un graf neorientat, memorat prin intermediul matricei de adiacenta, se cere sa se
creeze si sa se tipareasca matricea lanturilor.
Se observa ca parcurgand in adancime (sau in latime) graful pornind de la nodul nod=3 spre
exemplu vectorul de vizitati este:
1 1 1 1 1 0 0. Daca se inlocuieste viz[nod]=viz[3]=0 se obtine: 1 1 0 1 1 0 0 si se poate incarca
linia 3 din matricea lanturilor cu continultul vectorului de vizitati. Prin urmare se parcurge df
graful pornind de la fiecare nod in parte si se incarca de fiecare data continutul vectorului viz
in matricea lanturilor in linia corespunzatoare. Iata o solutie:
#include<fstream.h>
#include<conio.h>
int a[20][20],n,m,viz[100],gasit,drum[20][20];
void main()
{int x,y,j;
fstream f;
clrscr();
f.open("muchii.txt",ios::in); //citire matrice de adiacenta din fisier
if(f)
cout<<"ok!"<<endl;
else
cout<<"eroare la deschidere de fisier!";
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>x>>y;
a[x][y]=a[y][x]=1;}
cout<<endl<<"matricea de adiacente"<<endl;
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<a[i][j]<<" ";
cout<<endl;}
int nod;
for(nod=1;nod<=n;nod++) //parcurgere graf incepand de la fiecare nod
{for(j=1;j<=n;j++)
viz[j]=0; //pentru fiecare nod se face vectorul viz in prealabil 0
dfmr(nod);
viz[nod]=0;
for(j=1;j<=n;j++) //incarcare vector viz in matrice drum
drum[nod][j]=viz[j];
}
cout<<endl<<"matricea drumurilor "<<endl;
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<drum[i][j]<<" ";
cout<<endl;}
getch();}
Componente conexe
Definitie: Un graf G=(V, E)este conex daca pentru orice pereche x,y de noduri
din V exista un lant de la x la y (implicit si de la y la x).
Observatii:
1
6 7
5
2
3 4
Probleme:
viz=[1,1,1,1,2,1,2].
-Numarul de componente conexe este 2.
-Se afiseaza componentele cu numarul componentei conexe egal cu 1: 1,2,3,4,6
-Se afiseaza componentele cu numarul componentei conexe egal cu 2: 5, 7
1
5 7
6
2
3 4
1,1,1,1,0,1,0
#include<fstream.h>
#include<conio.h>
int a[20][20],n,m,viz[100],gasit;
for(int k=1;k<=n;k++)
if(a[nod][k]==1&&viz[k]==0)
dfmr(k);
}
void main()
{int x,y,j;
fstream f;
clrscr();
if(f)
cout<<"ok!"<<endl;
else
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>x>>y;
a[x][y]=a[y][x]=1;}
cout<<endl<<"matricea de adiacente"<<endl;
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<a[i][j]<<" ";
cout<<endl;}
for(int nod=1;nod<=n;nod++)
{nrc++;
dfmr(nod);}
for(i=1;i<=n;i++)
cout<<viz[i]<<" ";
cout<<endl<<"Componentele conexe :"<<endl;
for(i=1;i<=nrc;i++)
{cout<<endl<<"componenta "<<i<<endl;
for(j=1;j<=n;j++)
if(viz[j]==i)
cout<<j<<" ";
getch();}
Matricea ponderilor
Fie G=(V, E) un graf neorientat, unde V are n elemente (n noduri) si E are m elemente (m
muchii). Atasam fiecarei muchii o pondere (sau cost) ci,j. Spre exemplu, ne putem imagina
nodurile unui graf ca fiind niste repere pe o harta si costurile distante intre repere adiacente.
Matricea ponderilor asociata grafului este o matrice simetrica cu nxn elemente
0, daca i=j
p[i,j]= ci,j, daca [i,j]E
altfel
1 025
2 5 206
2
5 6018
8
6 510
3 1 4
80
5
5
122
145
236
341
358
Problema:
Sa se genereze matricea ponderilor pentru un graf citit (n noduri, m muchii si m triplete).
Indicatii:
- pentru infinit se va folosi o valoare mai mare decat oricare dintre valorile posibile
pentru costuri. De obicei intervalul de valori pentru costuri este precizat.
- Initial se incarca in matrice infinit apoi se suprascrie matricea pentru fiecare triplet
citit:
Ex: cin>>x>>y>>cost
p[x][y]=p[y][x]=cost
Astfel:
1
2 10
5
2 8
3
3 1 4
Algoritmul:
1 0 2 pinf 10 pinf
2 10
2 0 3 pinf pinf
5
2 8
3 pinf 3 0 1 8
3 1 4
10 pinf 1 0 pinf
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(a[i][j]>a[i][k]+a[k][j])
a[i][j]=a[i][k]+a[k][j];
Se obtine:
1 0 2 5 6 13
2 10
2 0 3 4 11
5
2 8
3 53018
3 1 4
64109
13 11 8 9 0
Solutie:
-se determina daca exista un lant de la x la y (ar putea sa nu existe un astfel de
lant daca graful nu este conex):
cand a[x,y]
Iata o solutie:
#include<fstream.h>
#include<conio.h>
int a[20][20],n,m;
void citire_cost()
{fstream f;
int i,j,x,y,c;
f.open("roy.in",ios::in);
if(f)
cout<<"deschiderea a reusit";
else
cout<<"eroare la deschidere!";
cout<<endl;
f>>n>>m;
//initializare matrice
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(i==j)
a[i][j]=0;
else
a[i][j]=pinf;
for(i=1;i<=m;i++)
{f>>x>>y>>c;
a[x][y]=a[y][x]=c;}
void afisare_mat()
{for(int i=1;i<=n;i++)
{for(int j=1;j<=n;j++)
if(a[i][j]==pinf)
cout<<"pinf ";
else
cout<<a[i][j]<<" ";
cout<<endl;}
void genarare_matrice_drumuri_optime()
{for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(a[i][j]>a[i][k]+a[k][j])
a[i][j]=a[i][k]+a[k][j];
{int g=0,k=1;
while(k<=n&&!g)
{if(i!=k&&j!=k)
if(a[i][j]==a[i][k]+a[k][j])
{descompun_drum(i,k);
descompun_drum(k,j);
k++;
if(!g)
{if(a[nodini][nodfin]<pinf)
cout<<nodini<<" ";
else
void main()
{clrscr();int x,y;
citire_cost();
afisare_mat();
genarare_matrice_drumuri_optime();
afisare_mat();
cout<<"x=";
cin>>x;
cout<<"y=";
cin>>y;
scriu_drum(x,y);
getch();
Graf hamiltonian
Lan hamiltonian = un lan elementar care conine toate nodurile unui graf
1 6
5
2
3 4
L=[2 ,1, 6, 5, 4, 3] este lant hamiltonian
5
2
3 4
C=[1,2,3,4,5,6,1] este ciclu hamiltonian
Pentru a rezolva problema vom utiliza tehnica backtracking. Vom incarca in stiva
noduri distincte si adiacente, astfel incat pornind de la problema clasica de
backtracking a permutarilor vom testa valoarea de pe nivelul k astfel:
#include<fstream.h>
#include<conio.h>
#include<stdio.h>
int st[100],n,m,k,a[20][20];
int ns;
int e_valid()
{if(k>1)
if(!a[st[k-1]][st[k]])
return 0;
else
if(st[i]==st[k])
return 0;
if(k==n)
if(!a[st[1]][st[k]])
return 0;
return 1;
void afisare()
{for(int i=1;i<=n;i++)
cout<<st[i]<<" ";
cout<<st[1];
ns++;
}void back()
if(st[k]<n)
{st[k]++;
afisare();
else //daca nu am solutia completa urc in stiva (maresc vectorul,
adica pe k)
{k++;
st[k]=0;}
else
k--;
void main()
{clrscr();
fstream f;
f.open("ham.in",ios::in);
int u,v;
if(f)
cout<<"ok!";
else
cout<<"eroare";
cout<<endl;
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>u>>v;
a[u][v]=a[v][u]=1;
}
for( i=1;i<=n;i++)
{for(int j=1;j<=n;j++)
cout<<a[i][j]<<" ";
cout<<endl;
back();
if(ns==0)
getch();
Grafuri euleriene
Lan eulerian = un lan simplu care conine toate muchiile unui graf
Problema: fiind dat un graf fara noduri izolate sa se determine daca este
eulerian. In caz afirmativ se vor afisa toate ciclurile euleriene care incep cu
un nod nd citit.
- vom determina daca graful este conex
- vom determina daca fiecare nod are grad par
- vom genera toate ciclurile euleriene utilizand tehnica backtracking.
Astfel:
o primul nod va trebui sa fie nd
o un nou x=st[k], adaugat in stiva trebuie sa fie adiacent cu
anteriorul (y=st[k-1])
o muchia x-y nu trebuie sa mai fi fost adaugata inca odata
o ultimul nod, care incheie ciclul, trebuie sa fie incident cu
primul
O solutie:
#include<fstream.h>
#include<conio.h>
int st[100];
int k,nd;
int a[10][10],viz[10],n,m;
int e_valid()
{int x,y;
if(k==1)
if(st[k]!=nd)
return 0;
if(k>1) //sa existe muchie cu precedentul
{x=st[k];
y=st[k-1];
if(a[x][y]==0)
return 0;
}
for(int i=1;i<=k-2;i++)
if((st[i]==x && st[i+1]==y) || (st[i]==y && st[i+1]==x))
return 0; //muchia a mai fost luata odata
void back()
{ k=1;
while(k>0)
{if(st[k]<n)
{st[k]++;
if(e_valid())
if(k==m)
tipar();
else{k++;
st[k]=0;
}
}
else
k--;}
}
void main()
{clrscr();int x,y;
fstream f;//int a[10][10];// citire matrice din fisier
f.open("matsim.txt",ios::in);
if(f)
cout<<"ok";
else
cout<<"error";
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>x>>y;
a[x][y]=a[y][x]=1;
}
cout<<"matricea de adiac "<<endl; // afisare matrice
for( i=1;i<=n;i++)
{for(int j=1;j<=m;j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
if(s!=n)
cout<<"graful nu e conex ";
else
{int gasit=0;
cout<<endl<<"graful e conex!"<<endl;
for(i=1;i<=n;i++) //determin daca toate nodurile au gradele pare
{s=0;
for (int j=1;j<=n;j++)
s+=a[i][j];
if(s%2!=0)
gasit=1;}
if(gasit)
cout<<"am noduri fara grade pare";
else
cout<<"toate nodurile au gradele pare deci graful e eulerian";
}
back();
getch();
}
-se determina daca graful contine un ciclu eulerian (toate nodurile au grad
par si este conex)
-se retin gradele tuturor nodurilor in vectorul g. Acesta va retine:
g=[2,4,4,4,4,2]
-ciclul se genereaza pas cu pas retinand nodurile intr-o lista gestionata de
variabilele p si u (prima si ultima componenta)
-se genereaza un ciclu pornind de la nodul 1 care se adauga in lista p
(acesta va fi si u la inceput). In continuare se adauga noduri adiacente cu
informatia retinuta de u si se continua astfel pana se ajunge iar la nodul 1.
De fiecare data cand se adauga o muchie (u->info, i) la ciclu se
micsoreaza gradul lui u->info si lui i iar muchiile (u->info, i) si (i,u->info)
se elimina.
-acest prim ciclu se poate genera parcurgand nodurile grafului
-dupa prima secventa se determina ciclul :
#include<fstream.h>
#include<conio.h>
struct nod{int info;
nod *next;};
int a[20][20],viz[20];
int g[20];
int n,m,k;
void citire()
{ int x,y;
fstream f; //memorare graf in matrice de adiacenta
f.open("euler.txt",ios::in);
if(f)
cout<<"ok";
else
cout<<"eroare";
cout<<endl;
f>>n>>m;
for(int i=1;i<=m;i++)
{f>>x>>y;
g[x]++; g[y]++;
a[x][y]=a[y][x]=1;
}
}
int verific()
{ for(int i=1;i<=n;i++)
if(g[i]%2==1)
return 0;
df(1);
for(i=1;i<=n;i++)
if(viz[i]==0)
return 0;
return 1;
}
void generezc1(nod*&p,nod*&u,int x)
{nod *q;
q=new nod;
q->info=x;
p=u=q;
do
{ int gas=0;
for(int i=1;i<=n&&!gas;i++)
if(a[i][u->info]==1)
{g[u->info]--;
g[i]--;
k++;
a[i][u->info]=a[u->info][i]=0;
q=new nod;
q->info=i;
u->next=q;
u=q;
gas=1;}
}
while(p->info!=u->info);
u->next=0;
}
void afisare(nod *q)
{while(q)
{cout<<q->info<<" ";
q=q->next;}
}
void main()
{clrscr();
citire();
if(verific()==0)
cout<<"gf nu este eulerian!";
else
{ cout<<"este eulerian!";
nod *p=0,*u;
cout<<endl;
generezc1(p,u,1);
cout<<endl;
nod *p1=0,*u1;
while(k<m)
{nod *q=p;
int x=cauta(q);
generezc1(p1,u1,x);
u1->next=q->next;
q->next=p1->next;
}
afisare(p); }
getch();
}