Sunteți pe pagina 1din 13

#include <stdio.h> #include <malloc.h> #include <string.

h> //liste liniare simplu inlantuite typedef struct NOD { int inf; struct NOD* leg; } *PTNOD; //popularea unei liste simplu inlantuite preluate de la tastatura void main() { PTNOD prim, p, nou; int n, i; int a; //inserare lista printf("primul nod"); scanf("%d", &a); prim = (PTNOD)malloc(sizeof(NOD)); prim->inf = a; prim->leg = NULL; p = prim; printf("nod = "); scanf("%d", &a); while(!feof(stdin)) { nou = (PTNOD)malloc(sizeof(NOD)); nou->inf = a; nou->leg = NULL; p->leg = nou; p = nou; printf("nod = "); scanf("%d", &a); } //afisare continut printf("\n"); p = prim; while(p) { printf("%d", p->inf); p = p->leg; } //stergere lista while(prim) { p = prim; prim = prim->leg; free(p); } } //inserarea unui nod la inceputul unei liste si int inserarelainceput(PTNOD *prim, int info) {

int cod = 0; PTNOD nou; if(nou = (PTNOD)malloc(sizeof(NOD))) { nou->inf = info; nou->leg = *prim; *prim = nou; cod = 1; } return cod; } //inserarea unui nod dupa un nod identificat prin valoarea unui camp intr-o lista si PTNOD inseraredupainformatie(PTNOD prim, int info, int infod) { PTNOD nou, p; nou = (PTNOD)malloc(sizeof(NOD)); nou->inf = info; if (prim==NULL) { nou->leg = NULL; prim = nou; } else { p = prim; while((p->leg != NULL) && (p->inf != infod)) p = p->leg; if(p->inf==infod) { nou->leg = p->leg; p->leg = nou; } else { nou->leg = NULL; p->leg = nou; } } return prim; } //cautarea unui nod indentificat prin valoare a unui camp intr-o lsi PTNOD cauta(PTNOD prim, int info) { PTNOD p; if (prim==NULL) return NULL; else if(prim->inf==info) return prim; else { p = prim; while(p!=NULL) if(p->inf==info)

return p; else p = p->leg; } return NULL; } //stergerea primului nod al unei lsi int eliminaprimulnod(PTNOD *prim, int *info) { int cod=0; if(*prim!=NULL) { PTNOD aux = *prim; *info = aux->inf; *prim = (*prim)->leg; free(aux); cod = 1; } return cod; } //stergerea ultimului nod al unei lsi int eliminaultim(PTNOD *prim, int *info) { PTNOD p; int cod=0; if(*prim) { if((*prim)->leg) { p = *prim; while(p->leg->leg!=NULL) p = p->leg; *info = p->leg->inf; free(p->leg); p->leg = NULL; } else { *info = (*prim)->inf; free(*prim); *prim = NULL; } cod = 1; } return cod; } //stergerea unui nod identificat prin valoare int eliminainfo(PTNOD *prim, int info) { PTNOD aux, p; int cod = 0; if(*prim!=NULL) { p = *prim;

if((*prim)->inf==info) { aux = *prim; *prim = (*prim)->leg; free(aux); cod = 1; } else { while((p->leg!=NULL) && (p->leg>inf!=info)) p = p->leg; if(p->leg!=NULL) { aux = p->leg; p->leg = aux->leg; free(aux); cod = 1; } } } return cod; } //eliminarea tuturor nodurilor care au o anumita valoare int elimina(PTNOD *prim, int info) { int n = 0; while(eliminainfo(prim,info)!=0) n++; return n; } //stergerea unei lsi void eliberare(PTNOD *prim) { PTNOD p; while(*prim) { p = *prim; (*prim) = (*prim)->leg; free(p); } } //ordonarea crescatoare - bubble sort a unei lsi void sortare(PTNOD prim) { int ok = 1, aux; PTNOD p; while(ok==1) { ok = 0; p = prim; while(p->leg) { if(p->inf=p->leg->inf) { aux = p->inf; p->inf=p->leg->inf;

p->leg->inf=aux; ok = 1; } p = p->leg; } } } //functia nerecursiva pentru calcularea sumei informatiilor nodurilor unei lsi int suma(PTNOD prim) { int s = 0; PTNOD p; if(prim) { p = prim; while(p!=NULL) { s = s+p->inf; p = p->leg; } } return s; } //functia recursia pt calc sumei informatiilor unei lsi int suma(PTNOD prim) { int s; if(!prim) s = 0; else s = prim->inf+suma(prim->leg); return s; } //liste liniare simplu inlantuite typedef struct NOD { char nume[20]; int nota; struct NOD*leg; } *PTNOD; //inserarea unui nod la inceputul lsi int inserareinceput(PTNOD *prim, int nota1, char nume1[20]) { PTNOD nou; int cod = 0; if(nou=(PTNOD)malloc(sizeof(NOD)) ) { nou->nota = nota1; strcpy(nou->nume, nume1); nou->leg = *prim; *prim = nou; cod = 1; }

return cod; } //parcurgerea unei lsi void parcurgere (PTNOD prim) { while(prim) { printf("%s\t", prim->nume); printf("%d\n", prim->nota); prim = prim->leg; } } //inserarea unui nod dupa un nod identificat prin valoarea campului nume int inseraredupainfo(PTNOD *prim, int nota1, char *nume1, char nume2[20]) { PTNOD p, nou; int cod = 0; if(nou=(PTNOD)malloc(sizeof(NOD)) ) { nou->nota = nota1; strcpy(nou->nume, nume1); if(*prim==NULL) { nou->leg = NULL; *prim = nou; } else { p = *prim; while((p->leg!=NULL) && strcmp(p>nume, nume2)!=0) p = p->leg; if(p->leg == NULL) { nou->leg = NULL; p->leg = nou; } else { nou->leg = p->leg; p->leg = nou; } } cod = 1; } return cod; } //inserarea unui nod dupa o pozitie citita de la tastatura in lsi int inseraretast(PTNOD *prim, int nota1, char nume1[20], int poz) { PTNOD nou, p; int i, cod = 0;

if(nou=(PTNOD)malloc(sizeof(NOD)) ) { nou->nota = nota1; strcpy(nou->nume, nume1); if(*prim==NULL) { nou->leg = NULL; *prim = nou; } else { p = *prim; i = 1; while((p->leg!=NULL) && (i!=poz)) { p = p->leg; i++; } if(p->leg == NULL) { nou->leg = NULL; p->leg = nou; } else { nou->leg = p->leg; p->leg = nou; } } cod = 1; } return cod; } //afisare note peste 5 void afisare(PTNOD prim) { if(prim) { if(prim->nota>=5) { printf("%s\t", prim->nume); printf("%d\n", prim->nota); } afisare(prim->leg); } } //stergerea unui nod care succede un nod identificat prin valoarea nume int eliminadupainfo(PTNOD *prim, char nume1[20], char nume2[20]) { PTNOD aux, p, q; int cod = 0; p = *prim; if(*prim!=NULL) { if(strcmp((*prim)->nume, nume2)==0) {

strcpy(nume1, (*prim)->leg>nume); aux = (*prim)->leg; p->leg = aux->leg; free(aux); return 1; } else { while((p->leg!=NULL) && (strcmp(p->nume, nume2)!=0)) p = p->leg; if((strcmp(p->nume, nume2)==0) && (p->leg!=NULL)) { strcpy(nume1, p->leg->nume); q = p->leg; p->leg = q->leg; free(q); cod = 1; } } } return cod; } //COADA typedef struct NOD { int inf; struct NOD* leg; } *PTNOD; //adaugarea unui nod intr-o coada int adaugarecoada(PTNOD *prim, int info) { PTNOD p, nou; int cod; if(nou=(PTNOD)malloc(sizeof(NOD)) ) { if(*prim==NULL) { nou->inf = info; nou->leg = NULL; *prim = nou; } else { p = *prim; while(p->leg!=NULL) p = p->leg; nou->inf = info; nou->leg = NULL; p->leg = nou; } cod = 1; } else cod = 0; return cod; }

//extragerea unui element dintr-o coada int eliminacoada(PTNOD *prim, int *info) { int cod = 0; if(*prim!=NULL) { PTNOD aux = *prim; *info = aux->inf; *prim = (*prim)->leg; free(aux); cod = 1; } return cod; } // STIVA //adaugare nod in stiva int PUSH(PTNOD *prim, int info) { int cod = 0; PTNOD nou; if(nou=(PTNOD)malloc(sizeof(NOD)) ) { nou->inf = info; nou->leg = *prim; *prim = nou; cod = 1; } return cod; } //extragerea unui element din stiva int POP(PTNOD *prim, int *info) { int cod = 0; if(*prim!=NULL) { PTNOD aux = *prim; *info = aux->inf; *prim = (*prim)->leg; free(aux); cod = 1; } return cod; } //LISTE CIRCULARE SIMPLU INLANTUITE //popularea unei liste simplu inlantuite circulare cu data de la tastatura typedef struct NOD { int inf; struct NOD* leg; } *PTNOD;

void main() { PTNOD prim, p, q, nou; int n, i,a ; //inserare lista printf("primul nod="); scanf("%d", &a); prim = (PTNOD)malloc(sizeof(NOD)); prim->inf = a; prim->leg = prim; p = prim; printf("nod ="); scanf("%d", &a); while(!feof(stdin)) { nou = (PTNOD)malloc(sizeof(NOD)); nou->inf = a; nou->leg = prim; p->leg = nou; p = nou; printf("nod ="); scanf("%d", &a); } //afisare continut printf("\n"); if(prim!=NULL) { printf("\t%d", prim->inf); p = prim->leg; while(p!=prim) { printf("\t%d", p->inf); p = p->leg; } } else printf("\n Lista vida"); //stergere lista p = prim; while(prim!=p) { q = prim; prim = prim->leg; free(q); } prim = NULL; }

nou->inf = info; if(*prim==NULL) { nou->leg = nou; *prim = nou; } else { p = *prim; while(p->leg!=*prim) p = p->leg; p->leg = nou; nou->leg = *prim; *prim = nou; } cod = 1; } return cod; } //inserare nod in lsic dupa un nod identificat prin valoarea unui camp PTNOD inseraredupainfo(PTNOD prim, int info, int infod) { PTNOD p, nou; nou = (PTNOD)malloc(sizeof(NOD)); nou->inf = info; if(prim == NULL) { nou->leg = nou; prim = nou; } else { p = prim; while((p->leg!=prim) && (p>inf=infod)) p = p->leg; if(p->inf==infod) { nou->leg = p->leg; p->leg = nou; } else { nou->leg = prim; p->leg = nou; } } return prim; } //inserarea unui nod intr-o lsic inainte unei poz citite de la tastatura int inserareinaintetast(PTNOD *prim, int info, int poz) { PTNOD nou, p; int cod = 0, i = 0; if(nou = (PTNOD)malloc(sizeof(NOD)))

{ nou->inf = info; if(*prim==NULL) { nou->inf = info; nou->leg = nou; *prim = nou; } else { p = *prim; if(poz == 1) { while(p->leg!=*prim) p = p->leg; p->leg = nou; nou->leg = *prim; *prim = nou; } else { i = 1; while((p->leg!=*prim) && (i<poz1)) { p = p->leg; i = i+1; } if(p->leg==*prim) { p->leg = nou; nou->leg = (*prim); (*prim) = nou; } else { nou->leg = p->leg; p->leg = nou; } } } cod = 1; } return cod; } //cautarea unui nod intr-o lsic PTNOD cauta(PTNOD prim, int info) { PTNOD p; if(prim==NULL) return NULL; else if(prim->inf==info) return prim; else { p = prim->leg; while(p!=prim) if(p->inf == info) return p; else p = p->leg; } return NULL;

typedef struct NOD { int inf; struct NOD* leg; } *PTNOD; //inserare nod la inceputul unei lsic int inserare(PTNOD *prim, int info) { int cod = 0; PTNOD nou, p; if(nou = (PTNOD)malloc(sizeof(NOD))) {

} //stergerea primului nod al unei lsic int eliminainceput(PTNOD *prim, int *info) { int cod = 0; if(*prim!=NULL) { PTNOD aux = *prim, p; *info = aux->inf; if(aux->leg==*prim) { free(aux); *prim = NULL; } else { p = *prim; while(p->leg!=*prim) p = p->leg; *prim = (*prim)->leg; p->leg = *prim; free(aux); } cod = 1; } return cod; } //stergerea ultimului nod din lsic int eleimaultim(PTNOD *prim, int *info) { PTNOD p; int cod = 0; if(*prim) { if((*prim)->leg!=*prim) { p = *prim; while(p->leg->leg!=*prim) p = p->leg; *info = p->leg->inf; free(p->leg); p->leg = *prim; } else { *info = (*prim)->inf; free(*prim); *prim = NULL; } cod = 1; } return cod; } //stergere nod identificat prin valoarea unui camp

int eliminainfo(PTNOD *prim, int info) { PTNOD aux, p; int cod = 0; if(*prim!=NULL) { p = *prim; if((*prim)->inf==info) { aux = *prim; while(p->leg!=*prim) p = p->leg; *prim = (*prim)->leg; p->leg = *prim; free(aux); cod = 1; } else { while((p->leg!=*prim) && (p->leg>inf!=info)) p = p->leg; if(p->leg->inf == info) { aux = p->leg; p->leg = aux->leg; free(aux); cod = 1; } } } return cod; } // steregerea unei lsic void eliberare(PTNOD *prim, int *er) { PTNOD p, q; p = *prim; if(p!=NULL) { p = *prim; while(*prim!=p) { q = *prim; (*prim) = (*prim)->leg; free(q); } prim = NULL; *er = 1; } else *er = 0; }

//popularea unei ldi cu date de la tastatura //varianta 1 void main() { PTNOD prim, p, nou; int n, i, a; //inserare lista printf("primul nod="); scanf("%d", &a); prim = (PTNOD)malloc(sizeof(NOD)); prim->inf = a; prim->ld = prim->ls = NULL; p = prim; printf("nod = "); scanf("%d", &a); while(!feof(stdin)) { nou = (PTNOD)malloc(sizeof(NOD)); nou->inf = a; nou->ld = NULL; nou->ls = p; p->ld = nou; p = nou; printf("nod = "); scanf("%d", &a); } //afisare continut de la inceput la sf printf("Afisare inceput -> sfarsit! \n"); p = prim; while(p) { printf("\t%d", p->inf); p = p->ld; } printf("\nAfisare sfarsit -> inceput! \n"); p = prim; if(p!=NULL) { while(p->ld) p = p->ld; while(p) { printf("\t%d", p->inf); p = p->ls; } } //stergere lista while(prim) { p = prim; prim = prim->ld; if(prim) prim->ls = NULL; free(p); } } //varianta 2

//LISTE LINIARE DUBLU INLANTUITE typedef struct NOD { int inf; struct NOD *ls, *ld; } *PTNOD;

int adaugarelista(PTNOD *prim, int info) { PTNOD p, nou; int cod; if(nou = (PTNOD)malloc(sizeof(NOD))) { if(*prim==NULL) { nou->inf = info; nou->ls = nou->ld = NULL; *prim = nou; } else { p = *prim; while(p->ld!=NULL) p = p->ld; nou->inf = info; nou->ld = NULL; nou->ls = p; p->ld = nou; } cod = 1; } else cod = 0; return cod; } void afisare1(PTNOD prim) { PTNOD p; p = prim; while(p) { printf("\t%d", p->inf); p = p->ls; } } void afisare2(PTNOD prim) { PTNOD p; p = prim; if(p!=NULL) { while(p->ld) p = p->ld; while(p) { printf("\t%d", p->inf); p = p->ls; } } } void eliberare(PTNOD *prim) { PTNOD p; while(*prim) { p = *prim; (*prim) = (*prim)->ld; if(*prim)

(*prim)->ls = NULL; free(p); } } void main() { PTNOD prim; int a; //lista prim = NULL; printf("nod = "); scanf("%d", &a); while(!feof(stdin)) { if(adaugarelista(&prim, a)!=0) { printf("nod = "); scanf("%d", &a); } else printf("Nu se mai poate inserare elem!"); } //afisare continut afisare1(prim); afisare2(prim); //stergere lista eliberare(&prim); } //inserarea unui nod la inceputul unei ldi int inserareinceput(PTNOD *prim, int info) { int cod = 0; PTNOD nou; if(nou = (PTNOD)malloc(sizeof(NOD))) { if(*prim == NULL) { nou->inf = info; nou->ld = nou->ls = NULL: *prim = nou; } else { nou->inf = info; nou->ld = *prim; nou->ls = NULL; *prim = nou; } cod = 1; } return cod; } //adaugarea unui nod identificat prin valoarea unui camp in ldi PTNOD cauta(PTNOD prim, int info) { PTNOD p;

if(prim==NULL) return NULL; else if(prim->inf == info) return prim; else { p = prim; while(p!=NULL) if(p->inf == NULL) return; else p = p->ld; } return NULL; } //stergerea primului nod al unei ldi int eliminadelainceput(PTNOD *prim, int *info) { int cod = 0; if(*prim!=NULL) if((*prim)->ld) { PTNOD aux = *prim; *info = aux->inf; *prim = (*prim)->ld; (*prim)->ls = NULL; free(aux); cod = 1; } else { *info = (*prim)->inf; free(*prim); *prim = NULL; cod = 1; } return cod; } //stergerea ultimului nod din ldi int eliminaultim(PTNOD *prim, int *info) { PTNOD p; int cod = 0; if (*prim) { if((*prim)->ld) { p = *prim; while(p->ld->ld!=NULL) p = p->ld; *info = p->ld->inf; free(p->ld); p->ld = NULL; } else { *info = (*prim)->inf; free(*prim);

*prim = NULL; } cod = 1; } return cod; } //stergerea unei ldi void eliberare(PTNOD *prim) { PTNOD p; while(*prim) { p = *prim; (*prim) = (*prim)->ld; if(*prim) (*prim)->ls = NULL; free(p); } } typedef struct NOD { char nume[20]; int nota; struct NOD *ls, *ld; } *PTNOD; //inserarea unui nod la inceputul unei ldi int inserareldi(PTNOD *prim, int nota1, char nume1[20]) { int cod = 0; PTNOD nou; if(nou = (PTNOD)malloc(sizeof(NOD))) { nou->nota = nota1; strcpy(nou->nume, nume1); if(*prim==NULL) { nou->ld = nou->ls = NULL; *prim = nou; } else { nou->ld = *prim; nou->ls = NULL; (*prim)->ls = nou; *prim = nou; } cod = 1; } return cod; } //parcuregerea unei ldi (parcurgerea de la stanga la dreapta sau directa) void parcuregere(PTNOD prim) { PTNOD p;

p = prim; while(p) { printf("%s\t", prim->nume); printf("%d\n", prim->nota); p = p->ld; } } //LISTE CIRCULARE DUBLU INLANTUITE typedef struct NOD { int inf; struct NOD *ls, *ld; } *PTNOD; //popularea unei lcdi de la tastatura void main() { PTNOD p, prim, nou; int a; printf("Primul nod = "); scanf("%d", &a); prim = (PTNOD)malloc(sizeof(NOD)); prim->inf = a; prim->ld = prim->ls = prim; p = prim; printf("nod = "); scanf("%d", &a); while(!feof(stdin)) { nou = (PTNOD)malloc(sizeof(NOD)); nou->inf = a; nou->ld = prim; prim->ls = nou; nou->ls = p; p->ld = nou; p = nou; printf("nod = "); scanf("%d", &a); } //afisare inceput sfarsit printf("\n"); if(prim!=NULL) { printf("\t%d", prim->inf); p = prim->ld; while(p!=prim) { printf("\t%d", p->inf); p = p->ld; } } else printf("lista vida"); //afisare sfarsit inceput printf("\n"); if(prim!=NULL) { p = prim; while(p->ld!=prim)

p = p->ld; while(p!=prim) { printf("\t%d", p->inf); p = p->ls; } printf("\t%d", prim->inf); } else printf("lista vida"); //stergere lista p = prim; while(prim!=p) { p = prim; prim = prim->ld; if(prim) prim->ls = NULL; free(p); } prim = NULL; } //inserarea unui nod dupa un nod identificat in ldic int inseraredupainfo(PTNOD *prim, int info, int infod) { PTNOD nou, p; int cod = 0; if(nou = (PTNOD)malloc(sizeof(NOD))) { nou->inf = info; if(*prim==NULL) { nou->ld = nou; nou->ls = nou; *prim = nou; } else { p = *prim; while((p->ld!=*prim) && (p>inf!=infod)) p = p->ld; if(p->inf == infod) { nou->ld = p->ld; p->ld->ls = nou; nou->ls = p; p->ld = nou; } else { p->ld = nou; nou->ld = *prim; (*prim)->ls = nou; nou->ls = p; } } cod = 1; } return cod; }

//cautarea unui nod intr-o ldic PTNOD cauta(PTNOD prim, int info) { PTNOD p; if(prim==NULL) return NULL; else if(prim->inf == info) return prim; else { p = prim->ld; while(p!=prim) if(p->inf == info) return p; else p = p->ld; } return NULL; } //stergerea unei ldic void eliberare(PTNOD *prim, int *er) { PTNOD p; if(*prim!=NULL) { p = *prim; while(*prim!=p) { p = *prim; *prim = (*prim)->ld; if(*prim) (*prim)->ls = NULL; free(p); } *prim = NULL; *er = 1; } else *er = 0; }

(*g)[i] = (int*)malloc(2*sizeof(int)); for(i=0; i<*nrm; i++) fscanf(f, "%d %d", &(*g)[i][0], &(*g)[i][1]); fclose(f); } return er; } //exemplu apel char numefis[31]; int n, m, **tabel, er; er = citire_graf_n(numefis, &n, &m, &tabel); //converteste reprezentarea tabelara a unui graf in reprezentare matriceala int** conversie_n(int nrv, int nrm, int **tabel, int *dim) { int i,j; int** mat; *dim = nrv; mat = (int**)malloc(*dim*sizeof(int*)); for(i=0; i<*dim; i++) mat[i] = (int*)malloc(*dim*sizeof(int)); for(i=0; i<*dim; i++) for(j=0; j<*dim; j++) mat[i][j] = 0; for(i=0; i<nrm; i++) { mat[tabel[i][0]-1][tabel[i][1]-1] = 1; mat[tabel[1][1]-1][tabel[i][0]-1] = 1; } return mat; } //exemplu de apel int n, m, **tabel, **a, dim; a = conversie_n(n, m, tabel, &dim); //parcurgerea in latima a unui graf neponderat de la un varf dat typedef struct nod { int inf; struct nod *next; } TNOD; //adaugare informatie in coada int ins_c(TNOD** prim, TNOD** ultim, int info) { TNOD* p; int ok;

if(p = (TNOD*)malloc(sizeof(TNOD))) { p->inf = info; p->next = NULL; if(*prim == NULL) *prim = p; else (*ultim)->next = p; *ultim = p; ok = 1; } else ok = 0; return ok; } //extragere informatie din coada int extrage_c(TNOD** prim, TNOD** ultim, int *info) { TNOD* p; int ok; if(*prim) { p = *prim; *info = (*prim)->inf; (*prim) = (*prim)->next; free(p); if(*prim == NULL) *ultim = NULL; ok = 1; } else ok = 0; return ok; } //parcurgere graf in latime BF void BF(int vi, int **a, int n, int **rez, int *nr) { int i, j, *c, ok; TNOD *p, *u; p = u = NULL; c = (int*)malloc(n*sizeof(int)); *rez = (int*)malloc(n*sizeof(int)); for(i=0; i<n; i++) c[i] = 0; ok = ins_c(&p, &u, vi-1); c[vi-1] = 1; *nr = 0; while(p) { ok = extrage_c(&p, &u, &i); (*rez)[(*nr)++] = i+1; for(j=0; j<n; j++) if((a[i][j] == 1) && (c[j] == 0)) { ok = ins_c(&p, &u, j); c[j] = 1; } } free(c); }

//GRAFURI int citire_graf_n(char* numef, int *nrv, int *nrm, int ***g) { FILE *f; int i, er; fopen_s(&f, numef, "r"); if(!f) er = 1; else { er = 0; fscanf_s(f, "%d %d", nrv, nrm); *g = (int**)malloc(*nrm*sizeof(int*)); for (i=0; i<*nrm; i++)

//exemplu de utilizare int i, **a, dim, vi, *parc, cite; BF(vi, a, dim, &parc, &cite); printf("\Incepand cu %d se parcurg in latime: ", vi); for(i=0; i<cite; i++) printf("%d ", parc[i]); free(parc);

(*rez)[(*nr)++] = i+1; for(j=0; j<n; j++) if((a[i][j]==1)&&(c[j]==0)) { ok = ins_s(&p, j); c[j] = 1; } } free(p); } //exemplu de utilizare void main() { int i, **a, dim, vi, *parc, cate; DF(vi, a, dim, &parc, &cate); printf("Incepand cu %d se parcurg in adancime: "); for(i=0; i<cate; i++) printf("%d ", parc[i]); free(parc); }

} //scrie cate un subprogram care verifica daca un graf este conex prin: //1 folosind parcurgerea in adancime int graf_conex_parc(int **a, int n) { int *parc, cate, este; BF(1, a, n, &parc, &cate); //DF(1, a, n, &parc, &cate); este = (cate==n)?1:0; return este; } int **a, dim; printf("\nGraful este conex: %s", graf_conex_pac(a,n)?"da":"nu"); int graf_conex_drum(int **a, int n) { int este, **md, d, i, j; md = roy_warshall(a, n, &d); este = 1; for(i=0; (i<d)&&este; i++) for(j=0; (j<d)&&este; j++) if(!md[i][j]) este = 0; md = dezalocare(md, d); return este; } //verifica daca un graf neponderat este graf arbore int graf_arbore(int **t, int n, int m) { int este, **a, d; a = conversie(n, m, t, &d); este = graf_conex_parc(a,d); a = dezalocare(a,d); este = este && (n==m+1)?1:0; return este; } //exemplu apel int n, m, **tabel; printf("\nGraful este arbore: %s", graf_arbore(tabel, n, m)?"da":"nu"); //graf complet int graf_complet(int n, int m, int **t) { int este, **a, dim, i, j; a = conversie(n, m, t, &dim); este = 1; for(i=0; (i<dim)&&este; i++) for(j=0; (j<dim)&&este; j++) if((i!=j)&&(a[i][j]==0))

//adaugare informatie in coada int ins_s(TNOD** prim, int info) { TNOD* p; int ok; if(p=(TNOD*)malloc(sizeof(TNOD))) { p->inf = info; p->next = *prim; *prim = p; ok = 1; } else ok = 0; return ok; } int extrage_s(TNOD** prim, int *info) { TNOD *p; int ok; if(*prim) { p = *prim; *info = (*prim)->inf; (*prim) = (*prim)->next; free(p); ok = 1; } else ok = 0; return ok; } //parcurgere graf in adancime void DF(int vi, int **a, int n, int **rez, int *nr) { int i, j, *c, ok; TNOD* p; p = NULL; c = (int*)malloc(n*sizeof(int)); *rez = (int*)malloc(n*sizeof(int)); for(i=0; i<n; i++) c[i] = 0; ok = ins_s(&p, vi-1); c[vi-1] = 1; *nr = 0; while(p) { ok = extrage_s(&p, &i);

//parcurgerea in adancime a unui graf neponderat, pornind de la un varf dat typedef struct nod { int inf; struct nod *next; } TNOD; //graf neponderat - matricea existentei drumurilor algoritmul Roy-Warshall int** roy_warshall(int** a, int n, int *dim) { int i, j, k; int **m; *dim = n; m = (int**)malloc(n*sizeof(int*)); for(i=0; i<n; i++) m[i] = (int*)malloc(n*sizeof(int)); for(i=0; i<n; i++) for(j=0; j<n; j++) m[i][j] = a[i][j]; for(i=0; i<n; i++) for(j=0; j<n; j++) if(m[i][j]==1) for(k=0; k<n; k++) if(m[j][k]==1) m[i][k] = m[k][i] = 1; return m; } void main() { int **a, dim, **m_dr, l; m_dr = roy_warshall(a, dim, &l);

este = 0; a = dezalocare(a, dim); return este; } //apelare int n, m, **tabel; printf("\nGraful este arbore: %s", graf_arbore(n, m, tabel)?"da":"nu"); //noduri izolate int izolate(int **a, int n, int** rez) { int l, i, j, c; *rez = (int*)malloc(sizeof(int)); l = 0; for(i=0; i<n; i++) { c = 1; for(j=0; j<n && c; j++) if(a[i][j] || a[j][i]) c = 0; if(c) (*rez)[l++] = i+1; } return l; } //determina componentele conexe folosind matricea existentei drumurilor int comp_conex(int **t, int n, int m, int **vc, int ***tc) { int nrc, vi, *rez, **a, d, i, nr, **mr, l; a = conversie(n,m,t,&d); *vc = (int*)malloc(n*sizeof(int)); for(i=0;i<n;i++) (*vc)[i] = 0; *tc = (int**)malloc(m*sizeof(int*)); for(i=0;i<m;i++) { (*tc)[i] = (int*)malloc(3*sizeof(int)); (*tc)[i][0] = t[i][0]; (*tc)[i][1] = t[i][1]; } mr = roy_warshall(a,d,&l); nrc = 0; vi = 1; do { nrc++; (*vc)[vi-1] = nrc; for(i=0;i<n;i++) if(mr[vi-1][i]) (*vc)[i] = nrc; for(i=0;i<n && (*vc)[i];i++) if(i<n) vi = i+1;

else vi = 0; } while(vi); for(i=0;i<m;i++) (*tc)[i][2] = (*vc)[(*tc)[i][0]1]; a = dezalocare(a,d); return nrc; }

//operatiunea de travesare pe niveluri void parcnivel(int fiu[], int frate[], int c[], int r, int n) { int k, f, i, j; k = 0; f = r; c[k] = f; i = 0; for(j=i; j<k+1; j++) { i = i+1; f = fiu[c[j]-1]; if(f) { k = k+1; c[k] = f; int fr = frate[f-1]; while(fr) { k = k+1; c[k] = fr; fr = frate[fr-1]; } } } } //apelare #define NMAX 25 void main2() { int q[NMAX], i; for(i=0;i<NMAX;i++) q[i] = 0; parcnivel(fiu, frate, q, rad, n); printf("arbore pe niveluri"); for(i=0; i<n; i++) printf(" %d", q[i]); } //vizitarea nodurilor plasate pe drumul de la un nod din arbore la radacina void drumnodrad(int fiu[], int frate[], int r, int n, int nodc) { int t = nodc; viziteaza(t); while(t!=r) { int vb = 0; for(int i=0; i<n; i++) if(fiu[i]==t) { viziteaza(i+1); t = i+1; vb = 1; } if(!vb) { for(int i=0; i<n; i++) if(frate[i]==t)

//ARBORI void viziteaza(int r) { printf("%d", r); } void postfiufrate(int fiu[], int frate[], int r) { if(r) { postfiufrate(fiu, frate, fiu[r1]); postfiufrate(fiu, frate, frate[r1]); viziteaza(r); } } void prefiufrate(int fiu[], int frate[], int r) { if(r) { viziteaza(r); prefiufrate(fiu, frate, fiu[r1]); prefiufrate(fiu, frate, frate[r1]); } } void lamijloc(int fiu[], int frate[], int r) { if(r) { lamijloc(fiu, frate, fiu[r-1]); viziteaza(r); lamijloc(fiu, frate, frate[r-1]); } } void main() { printf("Arbore in postordine"); postfiufrate; printf("Arbore in preordine"); prefiufrate; printf("Arbore la mijloc"); lamijloc; }

{ viziteaza(i+1); t = i+1; vb = 1; } } if(!vb) { printf("Nodul %d nu exista in arbore", nodc); return; } } } //apelare void main3() { int search; printf("Introdu nodul cautat"); scanf("%d", &search); drumnodrad(fiu, frate, rad, n, search); } //calcularea inaltimii unui arbore struct arbfiufrate { int id, val; arbfiufrate *fiu, *frate; }; arbfiufrate* creazanod(int n, int v) { arbfiufrate *nou; nou = (arbfiufrate*)malloc(sizeof(arbfi ufrate)); nou->id = n; nou->val = v; nou->fiu = nou->frate = NULL; return nou; } int max(int a, int b) { if(a>b) return a; else return b; } int nrnivel(arbfiufrate *r) { if(r) { int m, n; arbfiufrate *p, *q=NULL; p = r->fiu; if(p) q = p->frate; n = max(nrnivel(p), nrnivel(q)); if(q) { q = q->frate; while(q) {

n = max(nrnivel(p), nrnivel(q)); if(m>n) n = m; q = q->frate; } } return 1+n; } return 0; } //apel void mainee() { int h = nrnivel(rad); printf("%d", h); } //determinarea nr de noduri void frec(arbfiufrate *r, int *p, int i) { if(r) { *(p+1) = *(p+i)+1; frec(r->fiu, p, i+1); frec(r->frate, p, i); } } //apel void mains() { int *pf = (int*)malloc(h*sizeof(int)); for(int i=0; i<h; i++) *(pf+i) = 0; frec(rad, pf, 0); for(int i=0; i<h; i++) printf("%d", *(pf+i)); } //stergerea intregului arbore arbfiufrate* stergerearb(arbfiufrate *r) { if(r) { r->fiu = stergerearb(r->fiu); if(!r->fiu && !r->frate) { pritnf("dezalocare nod: %d", r>id); free(r); } else { r->frate = stergerearb(r->frate); if(!r->fiu && !r->frate) { printf("dezalocare nou: %d", r>id); free(r); } } }

return NULL; }

//traversarea uzuala a unui arbore dinamic struct arbdin { float val; int n; arbdin **fii; }; void cautanod(arbdin *r, float p, arbdin **t) { if(r) { if(r->val == p) *t = r; else for(int i=0; i<r->n; i++) cautanod(r->fii[i], p, t); } } int inserarenod(arbdin *p, float v, int nr) { if(p) { char vb = 0; int j; for(int i=0; i<p->n && !vb; i++) { j = i; vb = 1; } if(vb) { arbdin *nou = (arbdin*)malloc(sizeof(arbdin)); nou->val = v; nou->n = nr; nou->fii = (arbdin**)malloc(nr*sizeof(arbdin )); for(int i=0; i<nr; i++) nou->fii[i] = NULL; p->fii[j] = nou; return 1; } } return 0; } void prearbore(arbdin *r) { if(r) { printf(" %f", r->val); for(int i=0; i<r->n; i++) prearbore(r->fii[i]); } }

void postarbore(arbdin *r) { if(r) { for(int i=0; i<r->n; i++) prearbore(r->fii[i]); printf(" %f", r->val); } } struct nod { float inf; nod* next; }; nod* put(nod *c, float v) { nod* nou = (nod*)malloc(sizeof(nod)); nou->inf = v; nou->next = NULL; if(!c) return nou; else { nod *tmp = c; while(tmp->next) tmp = tmp->next; tmp->next = nou; return c; } } nod* get(nod *c, float *v) { if(c) { *v = c->inf; nod* tmp = c; c = c->next; free(tmp); } return c; } //determinarea nr de noduri si frunze void nrfrunze(arbdin *r, int *nr) { if(r) { char vb = 0; for(int i=0; i<r->n; i++) if(r->fii[i]) vb = 1; if(!vb) *nr = *nr+1; else for(int i=0; i<r->n; i++) nrfrunze(r->fii[i], nr); } }

void valorifrunze(arbdin *r) { if(r) { char vb=0; for(int i=0; i<r->n; i++) if(r->fii[i]) vb = 1; if(!vb) printf(" %f", r->val); else for(int i=0; i<r->n; i++) valorifrunze(r->fii[i]); } } //apel void apel() { int nf=0; nrfrunze(rad, &nf); printf("nr de frunze este: %d", nf); valorifrunze(rad); } //ARBORI BINARI struct produs { int id; char *den; int q; float p; }; struct arbin { produs *pr; arbin *st, *dr; }; //creare arbore binar - inserare arbin* inserarenod(arbin *r, produs *prod, int *er) { if(r) { if(prod->id<r->pr->id) r->st = inserarenod(r->st, prod, er); else if(prod->id>r->pr->id) r->dr = inserarenod(r->dr, prod, er); else *er = 1; return r; } else { arbin *nou = (arbin*)malloc(sizeof(arbin)); nou->st = nou->dr = NULL; nou->pr = prod; return nou;

} } void RSD(arbin *r) { if(r) { printf("ID: %d Denumire: %s Cantitate: %d Pret: %f", r->pr>id, r->pr->den, r->pr->q, r->pr>p); RSD(r->st); RSD(r->dr); } } void SDR(arbin *r) { if(r) { SDR(r->st); SDR(r->dr); printf("ID: %d Denumire: %s Cantitate: %d Pret: %f", r->pr>id, r->pr->den, r->pr->q, r->pr>p); } } void SRD(arbin *r) { SRD(r->st); printf("ID: %d Denumire: %s Cantitate: %d Pret: %f", r->pr>id, r->pr->den, r->pr->q, r->pr>p); SRD(r->dr); } void main() { arbin *rad = NULL; produs *prod = NULL; char vb; char buf[200]; RSD(rad); SRD(rad); SDR(rad); } // arbore binar in care determinam inaltimea si numarul de noduri int h(arbin *r) { if(r) return 11+max(h(r->st), h(r>dr)); return 0; } int max(int x, int y) { return x>y?x:y; }

int nrnod(arbin *r) { if(r) return 1+nrnod(r->st) + nrnod(r>dr); else return 0; } //dezalocare arbire binar void stergere(arbin **r) { if(*r) { stergere(&(*r)->st); stergere(&(*r)->dr); free((*r)->pr->den); free((*r)->pr); free(*r); *r = NULL; } }