PNOD arboreDinVector(int *v, int dim){ PNOD rad = new NOD, temp, radTemp; if(!

rad){cout << "Nu mai este loc liber in memorie"; return rad;}rad->informatie = v[0]; rad->ss = NULL;rad->sd = NULL; for(int i = 1; i < dim; i++){ temp = new NOD;if(!temp){ cout << "Nu mai este loc liber in memorie"; return rad;}temp->informatie = v[i]; temp->ss = NULL;temp->sd = NULL; radTemp = rad;while(radTemp){ if(radTemp->informatie > v[i]) if(radTemp->ss == NULL){ radTemp->ss = temp;break;} else radTemp = radTemp->ss; else if(radTemp->sd == NULL){ radTemp->sd = temp;break;} else radTemp = radTemp->sd;}} return rad;}

void stergeArbore(PNOD rad){ if(rad->ss) stergeArbore(rad->ss);

if(rad->sd) stergeArbore(rad->sd); delete rad;}

int nrNoduri(PNOD rad){ if ( rad == NULL ) return 0; return (1 + nrNoduri(rad->ss) + nrNoduri(rad->sd));}

int inaltime(PNOD rad){ if ( rad == NULL ) return 0; int inaltimeSS, inaltimeSD; inaltimeSS = inaltime(rad->ss);inaltimeSD = inaltime(rad->sd); return (inaltimeSS>inaltimeSD)?(inaltimeSS+1):(inaltimeSD+1); } void calculEchilibru(PNODAVL rad){ rad->echilibru = inaltimeAVL(rad->sd) - inaltimeAVL(rad->ss);

PNODAVL echilibrare(PNODAVL rad){ PNODAVL temp;calculEchilibru(rad); if(rad->echilibru == -2){temp = rad->ss; if (temp->echilibru == 1) rad = dRotireDreapta(rad); else rad = sRotireDreapta(rad);} else if(rad->echilibru == 2){temp = rad->sd; if (temp->echilibru == -1) rad = dRotireStanga(rad); else rad = sRotireStanga(rad);} return rad;}

PNODAVL insereazaAVL(PNODAVL rad, int nr){ if(!rad){ rad = new NODAVL; rad->informatie = nr; rad->echilibru = 0; rad->sd = NULL;rad->ss = NULL;return rad;} else if (nr < rad->informatie) rad->ss = insereazaAVL(rad->ss, nr); else if (nr > rad->informatie) rad->sd = insereazaAVL(rad->sd, nr); else printf("Nodul exista deja");rad = echilibrare(rad);return rad;}

PNODAVL removeMin(PNODAVL rad){ PNODAVL temp = rad;if (!rad) cout << "arbore gol" << endl; else if (rad->ss) rad->ss = removeMin(rad->ss); else{ rad = rad->sd;//leg sd si eliberez radacina delete temp;} return rad;}

Backtracking int S[NMAX];int nrSolutii; void initializareSolutie(int row){S[row] = 0;} bool potCompletaSolutia(int row, int N){ bool rez = false;while((!rez)&&(S[row]<N)){ S[row]++; rez = true;for (int i = 1; i<row; i++) if((S[row]==S[i])||(abs(S[row]-S[i]) == (abs(row-i)))) rez = false;} return rez;}bool solutieFinala(int row, int N){

return (row==N);}void tiparesteSolutia(int N){ for(int i = 1; i<=N; i++) cout << S[i] << "\t"; cout << endl;}void backtrackingInterativ(int N){ int row = 1;initializareSolutie(row); while (row > 0){if(potCompletaSolutia(row, N)) if(solutieFinala(row, N)){tiparesteSolutia(N); nrSolutii++;}else{row++;initializareSolutie(row);} else row--;}} void backtrackingRecursiv(int N, int row){ if(row == N+1) tiparesteSolutia(N); else{int i, j; bool rez; for(i = 1; i <= N; i++){S[row] = i; rez = true;for(j = 1; j < row; j++) if((S[row]==S[j])||(abs(S[row]-S[j]) == (abs(row-j)))) rez = false; if(rez) backtrackingRecursiv(N, row + 1);}} S[row] = 0;}

PNODAVL stergeNodAVLechil(int nr, PNODAVL rad){ if((rad->ss == NULL)&&(rad->sd == NULL)) {delete rad; return NULL;} PNODAVL curent = rad, anterior = NULL;while(curent){ if(nr < curent->informatie) {anterior = curent; curent = curent->ss;} else if(nr > curent->informatie) {anterior = curent; curent = curent->sd;} else if(curent->ss != NULL && curent->sd != NULL){ PNODAVL temp = curent->sd, anteriorTemp = NULL; while(temp->ss){ anteriorTemp = temp; temp = temp->ss;} curent->informatie removeMin(curent->sd); if(anteriorTemp) >informatie);break;} else{ PNODAVL temp;temp = (curent->ss != NULL) ? curent->ss : curent>sd; if(anterior == NULL) return temp;if(anterior->ss->informatie == nr) anterior->ss = temp; else anterior->sd = temp;rad = reechilibrare(rad, anterior->informatie); delete curent;break;}}if (!curent) cout << "nu exista acest nr in arbore" << endl; return rad;} rad = reechilibrare(rad, anteriorTemp= temp->informatie;curent->sd =

typedef int info;typedef struct varf{

info informatie; varf *varfUrmator; struct arc *capListaArce;} VARF, *PVARF; typedef struct arc{PVARF varfDestinatie; int pondereLegatura;arc *arculUrmator;} ARC, *PARC; typedef struct stiva{PVARF varf; stiva *urmatorulDinStiva;} STIVA, *PSTIVA; typedef struct lista{PVARF varf; lista *urmatorulDinCoada;} LISTA, *PLISTA; typedef struct{PLISTA inceput;PLISTA sfarsit; } COADA;

PVARF grafDinMatriceAdiacenta(int matrice[nrVarfuri][nrVarfuri], int nr){ if(nr <= 0) return NULL;PVARF primulVarf = NULL, temp; for(int i = 0; i< nr; i++) primulVarf = inserareVarfNou(primulVarf, i+1); temp = primulVarf;for(int i = 0; i < nr; i++) for(int j = 0; j < nr; j++) if(matrice[i][j])inserareArcNou(primulVarf, i+1, j+1, matrice[i][j]); return primulVarf;}

PVARF inserareVarfNou(PVARF primulVarf, int informatie){ PVARF varfNou = new VARF;varfNou->informatie = informatie; varfNou->varfUrmator = NULL;varfNou->capListaArce = NULL;

if(!primulVarf) return varfNou;PVARF temp = primulVarf; while(temp->varfUrmator) temp = temp->varfUrmator; temp->varfUrmator = varfNou;return primulVarf;}

PVARF cautVarf(PVARF primulVarf, int informatie){ while(primulVarf) if((primulVarf->informatie) != informatie) primulVarf = primulVarf->varfUrmator ; else break;return primulVarf;}

void inserareArcNou(PVARF primulVarf, int sursa, int destinatie, int pondere){ PVARF varfSursa = NULL, varfDestinatie = NULL, tempVarf = primulVarf, ultimulVarf = primulVarf; varfSursa = cautVarf(primulVarf, sursa);varfDestinatie =

cautVarf(primulVarf, destinatie); while(ultimulVarf->varfUrmator) >varfUrmator; if(!varfSursa){primulVarf = inserareVarfNou(primulVarf, sursa); ultimulVarf = ultimulVarf->varfUrmator;varfSursa = ultimulVarf;} ultimulVarf = ultimulVarf-

if(!varfDestinatie){primulVarf destinatie);

inserareVarfNou(primulVarf,

ultimulVarf = ultimulVarf->varfUrmator;varfDestinatie = ultimulVarf;} PARC tempArc, arcNou;tempArc = varfSursa->capListaArce; if(!tempArc){arcNou = new ARC;arcNou->arculUrmator = NULL; arcNou->varfDestinatie = varfDestinatie; varfSursa->capListaArce = arcNou;return;} while(tempArc->arculUrmator){ if(tempArc->varfDestinatie->informatie tempArc->arculUrmator; else break;}if(tempArc->varfDestinatie->informatie != destinatie){ arcNou = new ARC;arcNou->arculUrmator = NULL; arcNou->varfDestinatie = varfDestinatie;tempArc->arculUrmator arcNou;} } = != destinatie) tempArc =

void vizitareVarf(PVARF varf, bool vizitat[]){ vizitat[varf->informatie-1] = true;}

void parcurgereGrafInAdancime(PVARF primulVarf){ if(!primulVarf) return;bool vizitat[10];int nr_noduri = 0; PVARF varfCurent = primulVarf;while(varfCurent){ vizitat[nr_noduri] = false;nr_noduri++;

varfCurent = varfCurent->varfUrmator;} PVARF varfPop;PARC tempArc; PSTIVA varfStiva = NULL; varfStiva = push(varfStiva, primulVarf); vizitareVarf(varfStiva->varf, vizitat); cout << varfStiva->varf->informatie; do{varfStiva = pop(varfStiva, &varfPop); varfCurent = varfPop; tempArc = varfCurent->capListaArce; while(tempArc){ if(!vizitat[tempArc->varfDestinatie->informatie-1]){ varfStiva = push(varfStiva, tempArc->varfDestinatie); vizitareVarf(varfStiva->varf, vizitat);cout << varfStiva->varf->informatie;} tempArc = tempArc->arculUrmator; }}while(varfStiva); void parcurgereGrafInLatime(PVARF primulVarf){ if(!primulVarf) return;bool vizitat[10]; int nr_noduri = 0;PVARF varfCurent = primulVarf; while(varfCurent){vizitat[nr_noduri] = false; nr_noduri++;varfCurent = varfCurent->varfUrmator;} PVARF varfExtras;PARC tempArc; COADA coada = {NULL, NULL}; coada = introduceCoada(coada, primulVarf);

vizitareVarf(coada.sfarsit->varf, vizitat); cout << coada.sfarsit->varf->informatie; do{coada = extrageCoada(coada, &varfExtras); varfCurent = varfExtras;tempArc = varfCurent->capListaArce; while(tempArc){if(!vizitat[tempArc->varfDestinatie->informatie-1]){ coada = introduceCoada(coada, tempArc->varfDestinatie); vizitareVarf(coada.sfarsit->varf, vizitat);cout << coada.sfarsit->varf>informatie;} tempArc = tempArc->arculUrmator;}}while(coada.inceput);}

void stergeGraf(PVARF primulVarf){ if(!primulVarf) return;stergeGraf(primulVarf->varfUrmator); PARC temp;while(primulVarf->capListaArce){ temp = primulVarf->capListaArce; primulVarf->capListaArce = primulVarf->capListaArce->arculUrmator; delete temp;}delete primulVarf;}

void bubbleSort1(){ bool sortat;int i, temp;do{sortat = true; for(i=0; i < N-1; i++) if(v[i] > v[i+1]){ temp = v[i];v[i] = v[i+1];v[i+1] = temp;sortat = false;} } while(!sortat);}void

bubbleSort(){bool sortat; int i, temp, n = N;do{sortat = true; for(i=0; i < n-1; i++) if(v[i] > v[i+1]){ temp = v[i];v[i] = v[i+1];v[i+1] = temp; sortat = false;}n--;} while(!sortat);} int main(){int i; for(i=0; i< N; i++) cout << vInitial[i] << "\t"; cout << endl; for(i=0; i< N; i++) v[i] = vInitial[i];bubbleSort1(); for(i=0; i< N; i++) cout << v[i] << "\t"; cout << endl; for(i=0; i< N; i++) v[i] = vInitial[i];bubbleSort(); for(i=0; i< N; i++) cout << v[i] << "\t"; cout << endl; system("PAUSE");return 0;}

Programare dinamica int fibonacci_rec(int n){ if(n==0) return 0;if(n==1) return 1; return fibonacci_rec(n-2) + fibonacci_rec(n-1);} int fibonacci_pd1(int n){if(n==0) return 0; if(n==1) return 1;if (memo[n-2]) return memo[n-2]; memo[n-2] = fibonacci_pd1(n-2) + fibonacci_pd1(n-1);

return memo[n-2];} int fibonacci_pd2(int n){if(n==0) return 0; if(n==1) return 1;static int memo_local[N]; if (memo_local[n-2]) return memo_local[n-2]; memo_local[n-2] = fibonacci_pd2(n-2) + fibonacci_pd2(n-1); return memo[n-2];} int combinari_rec(int n, int k){ if (k == 0) return 1; if (n == 0) return 0; return combinari_rec(n-1, k) + combinari_rec(n-1, k-1);} int combinari_pd(int n, int k){ static int comb[N+1][N+1]; for (int k_index = 1; k_index <= k; k_index++) comb[0][k_index] = 0; for (int n_index = 0; n_index <= N; n_index++) comb[n_index][0] = 1; for (int n_index = 1; n_index <= n; n_index++) for (int k_index = 1; k_index <= k; k_index++) comb[n_index][k_index] comb[n_index-1][k_index]; return comb[n][k];} DAME int S[NMAX]; int nrSolutii;void tiparesteSolutia(int N){ for(int i=1; i<=N; i++) cout<<S[i]<<"\t"; cout<<endl;}void initializareSolutie(int row){ S[row]=0;}bool potCompletaSolutia(int row, int N){ = comb[n_index-1][k_index-1] +

bool rez=false;while((!rez)&&(S[row]<N)){ S[row]++;rez=true; for(int i=1; i<row; i++) if((S[row]==S[i])||(abs(S[row]-S[i])==abs(row-i)))rez=false; } return rez;}bool solutiaFinala(int row, int N){return(row==N);} void backtrackingIterativ(int N){ int row=1; initializareSolutie(row);while(row>0){ if(potCompletaSolutia(row,N)) if(solutiaFinala(row,N)){ tiparesteSolutia(N); nrSolutii++;}else{ row++;initializareSolutie(row);} else row--;}} void backtrackingRecursiv(int N, int row){ if(row==N+1)tiparesteSolutia(N); else{ int i,j; bool rez; for(i=1; i<=N; i++){S[row]=i; rez=true; for(j=1; j<row; j++) if((S[row]==S[j])||(abs(S[row]-S[j])==abs(row-j)))rez=false; if(rez)backtrackingRecursiv(N,row+1);}} S[row]=0;}

Harti int S[10],n,mat[10][10]; void initializareSolutie(int k){ S[k]=0;} bool succesor(int k){bool rez=false; if(S[k]<4){S[k]=S[k]+1; rez=true; } return rez;} bool potCompletaSolutia(int k){

bool rez=true; for(int i=1; i<=k; i++) if((mat[i][k]==1)&&(S[i]==S[k]))rez=false; return rez;} bool solutieFinala(int k){ return(k==n);} void tiparesteSolutia(){cout<<"Solutie:"<<endl; for(int i=1; i<=n; i++) cout<<"Tara "<<i<<" este colorata cu culoarea "<<S[i]<<"."<<endl; cout<<endl;} void backtrackingIterativ(){ int k=1;initializareSolutie(k);while(k>0){ while(succesor(k)){if(potCompletaSolutia(k)) if(solutieFinala(k)) tiparesteSolutia();else{k++; int itializareSolutie(k);}}k--; }

void quickSort(int inceput, int sfarsit) int i = inceput, j = sfarsit, pivot, temp; pivot = v[(inceput+sfarsit)/2];do{ while(v[i] < pivot) i++;while(v[j] > pivot) j--; if(i <= j){temp = v[i];v[i] = v[j]; v[j] = temp; i++; j--;}while(i<j);if(inceput < j) quickSort(inceput,j); if(i < sfarsit) quickSort(i,sfarsit); }

int cautareBinara(int inceput, int sfarsit, int n){ int pozitie = -1, mijloc;mijloc = (inceput + sfarsit)/2; if(v[mijloc] == n) return mijloc; if((inceput == sfarsit)&&(pozitie < 0)) return -1; if(v[mijloc] < n) pozitie = cautareBinara(mijloc + 1, sfarsit, n); if(v[mijloc] > n) pozitie = cautareBinara(inceput, mijloc - 1, n); else return pozitie;}

void interclasare(int inceput1, int sfarsit1, int inceput2, int sfarsit2){ int vTemp[N], dim_vTemp, i = inceput1, j = inceput2, k = 0; dim_vTemp = sfarsit1 - inceput1 + 1 + sfarsit2 - inceput2 + 1; while((i <= sfarsit1) && (j <= sfarsit2)){if(v[i] < v[j]){ vTemp[k] = v[i];i++;}else{vTemp[k] = v[j];j++;}k++;} while(i <= sfarsit1){vTemp[k] = v[i];i++;k++;}

//sau while(j <= sfarsit2){vTemp[k] = v[j];j++;k++;} for(k = 0; k <= sfarsit1 - inceput1; k++) v[inceput1+k] = vTemp[k]; for(k = sfarsit1-inceput1 +1; k <= (sfarsit1 - inceput1 + 1) + (sfarsit2 inceput2); k++) v[inceput2+(k-sfarsit1+inceput1-1)] = vTemp[k];}

1) Introducere stiva PSTIVA push(PSTIVA varfStiva, PVARF varf){ PSTIVA temp = new STIVA;//noul element din stiva if(temp){ temp->urmatorulDinStiva = varfStiva; temp->varf = varf; } return temp; } 2) Stergere stiva PSTIVA pop(PSTIVA varfStiva, PVARF *pPVarf){ if(!varfStiva) return NULL; PSTIVA varfSters; varfSters = varfStiva; varfStiva = varfStiva->urmatorulDinStiva; *pPVarf = varfSters->varf; delete varfSters; return varfStiva;

3) Introducere coada COADA push(COADA coada, PVARF varf){ PLISTA nou = new LISTA; nou->varf= varf; nou->urmatorulDinCoada = NULL; if(!coada.inceput) coada.sfarsit = coada.inceput = nou; else{ coada.sfarsit->urmatorulDinCoada = nou; coada.sfarsit = nou; } return coada; }

Scoatere coada COADA pop(COADA coada, PVARF *pPVarf){ if(!coada.inceput) return coada; *pPVarf = coada.inceput->varf; PLISTA temp; temp = coada.inceput;

coada.inceput = coada.inceput->urmatorulDinCoada; delete temp; if(!coada.inceput) coada.sfarsit = NULL; return coada; }

4) Parcurgere graf in lungime void parcurgereGrafInAdancimeRecursiv(PVARF primulVarf){/ if(!primulVarf) return; static bool vizitat[nrVarfuri];//avem un graf, pe care il parcurgem in adancime vizitat[primulVarf->informatie-1] = true; cout << primulVarf->informatie; PARC tempArc = primulVarf->capListaArce; while(tempArc) if(!vizitat[tempArc->varfDestinatie->informatie-1]) parcurgereGrafInAdancimeRecursiv(tempArc->varfDestinatie); tempArc = tempArc->arculUrmator;}}

5) Rotire simpla la dreapta PNODAVL sRotireDreapta(PNODAVL rad){//rotire simpla dreapta PNODAVL temp; temp = rad->ss; rad->ss = temp->sd; temp->sd = rad;

calculEchilibru(rad); calculEchilibru(temp); rad = temp; return rad;} 6) Rotire dubla dreapta PNODAVL dRotireDreapta(PNODAVL rad){//rotire dubla left-right rad->ss = sRotireStanga(rad->ss); rad = sRotireDreapta(rad); return rad;}

7) Rotire stanga PNODAVL sRotireStanga(PNODAVL rad){//rotire simpla stanga PNODAVL temp; temp = rad->sd; rad->sd = temp->ss; temp->ss = rad; calculEchilibru(rad); calculEchilibru(temp); rad = temp; return rad;}

8) Rotire dubla stanga PNODAVL dRotireStanga(PNODAVL rad){//rotire dubla right-left rad->sd = sRotireDreapta(rad->sd); rad = sRotireStanga(rad); return rad;}

9) Afisare element in arbore void arboreAfisareAVL(PNODAVL rad){ if(rad){ cout << rad->informatie; if((rad->ss!=NULL)||(rad->sd!=NULL)){ cout << "("; arboreAfisareAVL(rad->ss); cout << ","; arboreAfisareAVL(rad->sd); cout << ")"; }}else cout << "-";}

10) Cautare element in arbore bool cautaInformatieAVL(PNODAVL rad, int informatie){ bool temp = false; if(!rad) return temp; // else cout << rad->informatie; if(rad->informatie == informatie) temp = true; if(!temp) temp = cautaInformatieAVL(rad->ss, informatie); if(!temp) temp = cautaInformatieAVL(rad->sd, informatie); return temp;} 11) Stergerea elementelor arborelui void stergeArbore(PNOD rad){ if(rad->ss) stergeArbore(rad->ss); if(rad->sd) stergeArbore(rad->sd);

delete rad;}

12) Quicksort crescator void quick(int in,int sf){ int i,j,pivot,aux; if(in>=sf) return ; i=in; j=sf; pivot=v[(i+j)/2]; do { while(v[i]<pivot) i++; while(v[j]>pivot) j--; if(i<=j) { aux=v[i]; v[i++]=v[j]; v[j--]=aux; } } while (i<j); if(in<j) quick(in,j); if(i<sf) quick(i,sf); }

13) Quicksort descrescator void quick(int in,int sf){ int i,j,pivot,aux; if(in>=sf) return ; i=in; j=sf; pivot=v[(i+j)/2];

do { while(v[i]>pivot) i++; while(v[j]<pivot) j--; if(i<=j) { aux=v[i]; v[i++]=v[j]; v[j--]=aux; } } while (i<j); if(in<j) quick(in,j); if(i<sf) quick(i,sf); }

14) Aranjamente de n luate cate k void tipar(int k){ for(int i=0;i<k;i++) cout<<st[i]<<" "; cout<<endl; } int valid(int k) { for(int i=0;i<k;i++) if(st[k]==st[i]) return 0; return 1; } void gen(int k) { if(k == m) tipar(k); else for(int i=1;i<=n;i++) { st[k]=i; if(valid(k)) gen(k+1); } }

15) Permutari de n luate cate k void tipar(int k){ for(int i=1;i<k;i++) cout<<st[i]<<" "; cout<<endl; } int valid(int k) { for(int i=1;i<k;i++) if(st[k]==st[i]) return 0; return 1; }

void gen(int k) { if(k == n+1) tipar(k); else for(int i=1;i<=n;i++) { st[k]=i; if(valid(k)) gen(k+1); } } 16) Combinari de n luate cate k void sub(int poz) { if (poz == N + 1) { int cate = 0; for (int i = 1; i <= N; i ++) if (v[i] == 1) cate ++; if (cate == K){ for (int i = 1; i <= N; i ++) if (v[i] == 1) cout << i << ' '; cout << '\n'; }} else {v[poz] = 0;sub(poz + 1); v[poz] = 1; sub(poz + 1); }}int main() { cin >> N >> K; sub(1); return 0;}

void mergeSort(int inceput, int sfarsit){ //sortare cu interclasare if(inceput >= sfarsit) return; int mijloc = (inceput+sfarsit)/2;

mergeSort(inceput, mijloc); mergeSort(mijloc+1, sfarsit); interclasare(inceput, mijloc, mijloc+1, sfarsit);}

void mergeSort(int inceput, int sfarsit){ //sortare cu interclasare if(inceput >= sfarsit) return; int mijloc = (inceput+sfarsit)/2; mergeSort(inceput, mijloc); mergeSort(mijloc+1, sfarsit); interclasare(inceput, mijloc, mijloc+1, sfarsit);}