+

Algoritmi și tehnici de
programare

Cursul 1
+
Cuprins

◼ Introducere
◼ Evaluare
◼ Prezentare curs
◼ Bibliografie

◼ Alocarea dinamică a memoriei

+
Evaluare

◼ Examen 70 de puncte

◼ Proba practică pe calculator 20 puncte

◼ Teme rezolvate la seminar 10 puncte

+
Prezentare curs
◼ Curs introductiv. Cunoaștere, prezentarea obiectivelor și
competențelor urmărite, a metodelor de lucru, surselor de
documentare și a cerințelor de evaluare. Recapitulare: pointeri,
alocare dinamică. Pointeri la funcții.

◼ Organizarea datelor în fișiere. Fișiere text.

◼ Fișiere binare de date organizate secvențial.

◼ Fișiere binare organizate relative. Fișiere binare organizate indexat

◼ Recursivitate. Metoda Divide et Impera. Aplicații (probleme clasice,

parcurgere, căutare, interclasare, sortare) Analiza complexității
algoritmilor.

◼ Metode de sortare: sortarea rapida, sortarea rapidă cu factor

aleator, Shell, sortarea heap, sortare prin numărare, sortare de tip
rădăcină (radix sort) și pe baza cupelor (bucket sort).
+
Prezentare curs
◼ Căutare in spațiul soluțiilor. Metoda Greedy.

◼ Metoda backtracking

◼ Grafuri. Definiții, reprezentări și metode de parcurgere

◼ Conectivitate. Drumuri în grafuri. Grafuri ponderate. Drumuri de

cost minim.

◼ Grafuri de tip arbore. Arbore parțial de cost minim. Algoritmii

Kruskal și Prim

◼ Aplicații ale parcurgerii grafurilor: clasificarea muchiilor,

determinarea nodurilor articulație. Sortarea topologică

◼ Recapitulare.
+
Bibliografie
1. C. Uscatu, C. Cocianu, M. Mircea, L. Pocatilu, Algoritmi si tehnici de
programare. Aplicații, Editura ASE București 2015

2. I. Gh. Roşca, B. Ghilic-Micu, C. Cocianu, M. Stoica, C. Uscatu, M.

Mircea, Programarea calculatoarelor. Algoritmi în programare,
Editura ASE Bucureşti, 2007

3. C. Uscatu, M. Popa, L. Bătăgan, C. Silvestru, Programarea

calculatoarelor. Aplicații, Editura ASE București 2012

4. Thomas H. Cormen, Charles E. Leiserson, Ronald R. Rivest,

Introducere în algoritmi, Computer Libris Agora, 2000

5. D. Knuth, Arta programării calculatoarelor, vol. 1-3, Ed. Teora,

1999, 2000, 2001
+
Elemente ale limbajului C

Tipuri de date Specificatori:

◼ char ◼ short
long
◼ int
◼

◼ float
◼ double ◼ signed
◼ unsigned

long signed int a; - este corectă

unsigned short int b; - este corectă

short long int c; - nu este corectă.

+
Elemente ale limbajului C

◼ După numărul de valori memorate

◼ Simple
◼ Structurate

◼ După modul de alocare a memoriei

◼ Statice
◼ Dinamice
+
Elemente ale limbajului C
Operator Semnificaţie operaţie
- Schimbare semn
+ Păstrare semn (nici un efect, nu este folosit)
-- Decrementare (post sau pre)
++ Incrementare (post sau pre)
+ Adunare
- Scădere
* Înmulţire
/ Împărţire
/ Împărţire întreagă (câtul)
% Împărţire întreagă (restul)
+
Elemente ale limbajului C

Operator Semnificaţie operaţie

! Negare
&& Şi logic
|| Sau logic
> Mai mare
>= Mai mare sau egal
< Mai mic
<= Mai mic sau egal
== Egal
!= Diferit
+
Elemente ale limbajului C

◼ Instrucţiuni :

◼ if
◼ switch
◼ while
◼ do-while
◼ for
+
Pointeri

◼ Variabile care au ca valori adrese

◼ Rol important în:

◼ subprograme – transmiterea parametrilor;

◼ alocarea dinamica a memoriei;

◼ lucrul cu masive.
+
Pointeri

Operatori specifici pointerilor

Nume Simbol Rol Utilizare

Operator de * Definirea de tipuri de dată int*
indirectare pointer float* int**
Operator de & “Extrage” adresa unei &a
referenţiere variabile
Operator de * Accesează zona de *p
dereferenţiere memorie indicată de un
pointer
+
Pointeri

◼ int* vPtr, v;

◼ v= 10;

◼ vPtr = &v; vPtr are ca valoare adresa lui v

◼ * vPtr = v; *vPtr reprezintă valoarea lui v

#include<stdio.h>
void main()
{
int v = 10;
int* vPtr;
vPtr = &v;
printf(“v = % d, *vPtr = % d\n", v, *vPtr);
}
+
Pointeri

 Exemplu:
vPtr
int v=10, *vPtr;

vPtr = &v; v
+
Variabile de tip pointer

* - operator de indirectare
#include<stdio.h>
int v = 10;
int *vPtr; %p – specificator de
void main() formatare adresa de memorie
{
printf("%p\n", vPtr); initializare variabila pointer
vPtr = &v;
printf("%d\n", *vPtr);
printf("%p\n", vPtr); *vPtr – valoarea stocata la
printf("%p\n", &v); adresa de memorie spre care
} pointeaza vPtr.
&v – adresa de memorie la
care este stocata valoarea
variabilei v
+
Subprograme

◼ Forma generală subprogram:

tip_rez nume ([lista parametrilor formali])

{
declaraţii;
instructiuni ; //corp suprogram
}

◼ Un subprogram poate fi apelat folosind o construcţie de

forma:

tip_rez rezultat;
rezultat=nume ([lista parametrilor actuali]);
+
Transmiterea parametrilor

◼ Prin parametri
◼ prin valoare

◼ prin adresă

◼ Prin variabile globale

+
Subprograme

#include <stdio.h> void main()

{
int x; variablila globala printf("x=%d \n",x);
x=7;
void f1 () printf("x=%d \n",x);
{ f1();
x++; printf("x=%d \n",x);
} f2();
void f2 () printf("x=%d \n",x);
{ }
x=x+5;
}
+
Transmiterea parametrilor
argument formal
#include <stdio.h> #include <stdio.h>
int sum(int a, int b) void sum(int a, int b, int *s)
{
{ variablila locala argument actual
*s=a+b;
int s;
}
s=a+b;
void main ()
return s;
{
} int x=10,y=15, s;
void main () sum(x,y,&s);
{ printf("x=%d y=%d \n",x,y);
int x=10,y=15, s; printf("sum=%d",s);
s=sum(x,y); }
printf("x=%d y=%d \n",x,y);
printf("sum=%d",s);
}
+
Alocarea dinamică a memoriei

◼ Se include fișierul antet:

malloc.h

◼ Funcţii importante:
◼ malloc()
tip *p;
p = (tip*) malloc(dimensiune);
◼ free()
free(p);
+
Alocarea dinamică a memoriei

◼ Legătura dintre vectori şi pointeri

int *p; *(p+5)  p[5]

◼ Legătura dintre matrice şi pointeri

int **a; *( *(a+2)+3)  a[2][3]

int v[8]; v:
int *p;
p=&v[0]; p:

V[1] *(p+1)
+
Alocarea dinamică a memoriei
◼ Vector alocat dinamic  Matrice alocată dinamic
• Declarare • Declarare
tip* p; tip* *a;
• Alocare • Alocare
p = (tip*) malloc( n * sizeof(tip)); a = (tip**) malloc(m*sizeof(tip*));
• Utilizare for(i=0;i<m;i++)
*(p+i) *(a+i)=(tip*) malloc(n*sizeof(tip));
• Eliberare (dezalocare) • Utilizare
free(p); *(*(a+i)+j)
• Eliberare (dezalocare)
for(i=0;i<m;i++)
free(a[i]);
free(a);
+
Alocarea dinamică a memoriei
// funcţia care determină vânzările medii Apel:
pentru m firme de panificaţie (n
produse) float *v;

void med1(float **a, float **v, int m,int n) med1(vanz,&v,m,n);

{
int i, j,k; Afisare şi eliberare memorie:
*v=(float *) malloc (m*sizeof(float));
for(i=0;i<m;i++) for(i=0;i<m;i++)
{ printf("v[%d]=%f\n",i,v[i]);
(*v)[i]=0; free(v);
for(j=0;j<n; j++) for(i=0;i<m;i++)
(*v)[i]=(*v)[i]+*(*(a+i)+j); free(vanz[i]);
(*v)[i]=(*v)[i]/n; free(vanz);
}
}
+
Alocarea dinamică a memoriei
float *med2(float **a, int m,int n) Apel:
{ float *v;
int i, j,k; v=med2(vanz,m,n);
float *v;
v=(float *) malloc (m*sizeof(float)); Afisare şi eliberare memorie:
for(i=0;i<m;i++)
{ for(i=0;i<m;i++)
v[i]=0; printf("v[%d]=%f\n",i,v[i]);
for(j=0;j<n;j++) free(v);
v[i]=v[i]+*(*(a+i)+j); for(i=0;i<m;i++)
v[i]=v[i]/n; free(vanz[i]);
} free(vanz);
return v;
}
+
Alocarea dinamică a memoriei
typedef float *REZ;
void med3(float **a, REZ *v, int m,int n)
{
int i, j,k;
*v=(float *) malloc (m*sizeof(float));
for(i=0;i<m;i++)
{
(*v)[i]=0;
for(j=0;j<n;j++)
(*v)[i]=(*v)[i]+*(*(a+i)+j);
(*v)[i]=(*v)[i]/n;
}
}
Apel:
REZ v;
med3(vanz,&v,m,n);
+
Alocarea dinamică a memoriei
//funcţie care determină vânzările medii mai mari de 500 RON
//pentru m firme de panificaţie (n produse)
float * med(float **a, int m, int n, int *k)
{ int i, j;
float *v; float s;
*k=0;
for(i=0;i<m; i++)
{ s=0;
for(j=0;j<n; j++) s=s+*(*(a+i)+j);
s=s/n;
if (s>500) (*k)++;
}
v=(float *) malloc((*k)*sizeof(float *));
int l=0;
for(i=0;i<m;i++)
{ s=0;
for(j=0;j<n;j++) s=s+*(*(a+i)+j);
if (s/n>500) {v[l]=s/m;l++;}
}
return v;
}
+
Alocarea dinamică a memoriei
//produsul a doua masive bidimensionale
void main()
int ** produs1(int **a, int**b, int m, int p,
int n) {
{int i, j,k; ……………………………….
int **c;
c=(int **) malloc (m*sizeof(int*)); int **d;
for(i=0;i<m;i++) ……………………………….
c[i]=(int *) malloc(p*sizeof(int));
for(i=0;i<m;i++)
for(j=0;j<p;j++) d=produs1(a,b,m,p,n);
c[i][j]=0;
……………………………….
for(i=0;i<m;i++)
for(j=0;j<p;j++) }
{
for(k=0;k<n;k++)
c[i][j]=c[i][j]+a[i][k]*b[k][j];
}
return c;
}
+
Alocarea dinamică a memoriei
void produs2(int **a, int**b, int m, int p, int n,int ***c) void main()
{int i, j,k; {
*c=(int **) malloc (m*sizeof(int*)); ……………………………….
for(i=0;i<m;i++) int **d;
(*c)[i]=(int *) malloc(p*sizeof(int)); ……………………………….
for(i=0;i<m;i++)
for(j=0;j<p;j++)
produs2(a,b,m,p,n,&d);
{(*c)[i][j]=0;
……………………………….
for(k=0;k<n;k++)
}
(*c)[i][j]=(*c)[i][j]+a[i][k]*b[k][j];
}
}
+
Alocarea dinamică a memoriei
#include<stdio.h>
void writeMatrix1(float** a, int m, int n)
#include<malloc.h>
{ int i, j;
void readMatrix1(float*** a, int* m, int* n)
for (i = 0; i < m; i++)
{int i, j;
printf("m: "); {
scanf_s("%d", &*m); printf("\n");
printf("n: "); for (j = 0; j < n; j++)
scanf_s("%d", &*n); printf("%5.2f ", a[i][j]);
*a = (float**)malloc(*m * sizeof(float*));
}
for (i = 0; i < *m; i++)
}
(*a)[i] = (float*)malloc(*n * sizeof(float));
for (i = 0; i < *m; i++) void write1(float*v, int m)

for (j = 0; j < *n; j++) {int i;

{ printf("\n");

printf("a[%d,%d]= ", i, j); for (i = 0; i < m; i++)

scanf_s("%f", &(*a)[i][j]); printf("%5.2f ", v[i]);

} }

}
+
Alocarea dinamică a memoriei
void med1(float** a, float** v, int m, int n) void main()
{ {
int i, j, k; float** a, * v;
*v = (float*)malloc(m * sizeof(float)); int m, n, i;
for (i = 0; i < m; i++) readMatrix1(&a, &m, &n);
{ (*v)[i] = 0; writeMatrix1(a,m,n);
for (j = 0; j < n; j++) med1(a, &v, m, n);
(*v)[i] = (*v)[i] + *(*(a + i) + j); write1(v, m);
(*v)[i] = (*v)[i] / n; free(v);
} for (i = 0; i < m; i++)
} free(a[i]);
free(a);
}