ALGORITMI SI STRUCTURI

DE DATE

Lect. dr. Cristian Bologa

Cabinet: 431

Email: cbologa@econ.ubbcluj.ro
 Organizare:
Semigrupe:

Marti 10,50-13,15 831-S1 Bologa Cristian (sala 441)

831-S2 Silaghi Gheorghe
Marti 13,15-15,40 832-S1 Bologa Cristian (sala 441)
832-S2 Silaghi Gheorghe
Marti 15,50-18,15 833-S1 Bologa Cristian (sala 441)
832-S2 Silaghi Gheorghe
 ?
Bibliografie:

[Aho85] Aho A. V. Hopcroft J. E., Ullman J. D. –Data Structures and

Algorithms, Addison Wesley, Reading, Massachusets, 1985
[Cormen00] Cormen T., Leiserson C., Rivest R. -Introducere în algoritmi,
Ed. Computer Libris Agora, Tg. Mureş, 2000.
[Knuth99] Knuth D. E. –Arta programării calculatoarelor, vol 1 , Algoritmi
fundamentali, Ed. Teora, Bucureşti, 1999
[Knuth00] Knuth, D. E. -Arta programarii calculatoarelor, vol. 2, Algoritmi
seminumerici, Ed. Teora, 2000.
[Knuth01] Knuth, D. E. - Arta programarii calculatoarelor, vol. 3, Sortare şi
căutare, Ed. Teora, 2001.
[Negrescu02] Negrescu L –Limbajele C şi C++ pentru începători, volumul
1: Limbajul C, Ed. Albastră, Cluj-Napoca, 2002.
[Bologa05] Bologa C. –Algoritmi si structuri de date; Editura Risoprint,
Cluj-Napoca, 2005, 328 pag, 250.000 lei (vechi)
 START

T1, P1, T2, P2

Examinare:
MT=(T1+T2)/2

MP=(P1+P2)/2

DA MT>=5 NU

DA MP>=5 NU

MG=(MT+MP)/2

“Ne vedem la “Ne vedem la

reexaminare” reexaminare”
MG

STOP
Scurt istoric

 Algoritm: -pronuntia fonetica: Abu Ja`far Mohammed ibn Musa al-

Khowarizmi (780-850); “al-Khowarizmi” (din orasul Khowarizm)
 Algoritmul lui Euclid

Definitii:
 Odagescu: "Un algoritm poate fi definit ca o funcţie f: D → F, unde
F este mulţimea informaţiilor finale, iar D este mulţimea
informaţiilor iniţiale".
 Albeanu “Prin algoritm vom înţelege o secvenţă finită de comenzi
explicite şi neambigue care executate pentru o mulţime de date(ce
satisfac anumite condiţii iniţiale, conduce în timp finit la rezultatul
corespunzător.”
Caracteristici ale unui algoritm

 Generalitate

 Claritate

 Finititudine

 Corectitudine

 Performanta

 Robustete
Caracteristici ale unui program
+
 Claritate

 Extensibilitate

 Reutilizabilitate

 Compatibilitate

 Portabilitate

 Eficienta
Scurt istoric

 Program = exprimarea într-un limbaj de programare a unui

algoritm
 Algoritm = exprimarea într-un limbaj de reprezentare a unui
raţionament
 NU orice problema poate fi rezolvata prin algoritmizare (clasa
problemelor decidabile + clasa problemelor nedecidabile)
 Problema celor 4 culori; enuntare 1852 Francis Guthri;
rezolvare 1977 backtracking
Algoritmi
Caracterizati de:

 Elaborare

 Reprezentare

 Executie

 Analiza algoritmului

 Testarea programului
Fazele dezvoltarii unei aplicatii software
 Specificarea problemelor

 Proiectarea solutiilor

 Implementarea solutiilor

 Analiza solutiilor

 Testarea si depanarea

 Documentarea

 Exploatarea, actualizarea si intretinerea

Reprezentarea algoritmilor

 Limbaj natural

 Pseudocod

 Scheme logice

 Diagrame arborescente

 Tabele de decizie
Reprezentarea algoritmilor
73 15 15
Pseudocod
36 30 -

 Inmultirea a 2 18 60 -

numere folosind
9 120 120
doar adunari,
inmultiri si 4 240 -
impartiri cu 2
(« inmultirea a 2 480 -
la russe »)
1  960  960

    1.095
Reprezentarea algoritmilor
Pseudocod
function inmultire_a_la_russe(a, b)
  x[1]  a; y[1]  b
  i  1
  cat timp x[i] > 1 execută
   x[i+1]  x[i] div 2 {div reprezintă împărţirea întreagă}
    y[i+1]  y[i]+y[i]
    i  i + 1
sf-cat timp
  prod  0; i  i - 1
  cat timp i > 0 execută
   dacă x[i] este impar atunci prod  prod + y[i]
    i  i - 1
sf-cat timp
return prod
Reprezentarea algoritmilor
Scheme logice

 Simbolurile folosite in schemele logice au fost standardizate

prin standardul X35 aprobat de ANSI (American National
Standard Institute) in 1970, conform cu recomandarile
R1028/1969 ale ISO (International Standard Organization).
Reprezentarea algoritmilor
Scheme logice
Structuri de control

 Teorema de structura a lui Bohm si Jacopini

 Structura secventiala (liniara)

 Structura alternativa

 Structura repetitiva
Structuri de control

 Structura secventiala (liniara)

Structuri de control

 Structura alternativa
Structuri de control

 Structura repetitiva cu conditionare anterioara

Structuri de control

 Structura repetitiva cu conditionare posterioara

Structuri de control

 Structura repetitiva cu un numar cunoscut de pasi

Intrebari?
Limbajul C

 1972; Dennis Ritchie; Brian Kernigham (Bell

Laboratories) ->“The C Programming Language”
(Englewood Cliffs, Prentice Hall, 1978)

 BCPL (Basic Combined Programming Language) (1969,

Martin Richards) -> B (1970, Ken Thomson) -> C

 1983 ANSI American National Standard Language

Institute ->Comitetul de Limbaje de Programare
(Programming Language Committee) X3J11 -> 1989
ANSI C
Limbajul C

Avantaje

 Generalitate, absenta restrictiilor

 Aritmetica pointerilor

 Set bogat de operatori

 Exprimare concisa

 Acces direct la componente hardware

 Portabilitate
Limbajul C

Functii C

tip nume(lista_parametrii_formali)
declarare parametri
{
instrucţiuni specifice funcţiei: declarare variabile locale,
instrucţiuni executabile
}
Limbajul C

Functii C

#include<stdio.h>
void main(void)
{
printf(“Salut!”);
}
Limbajul C

Functii C

• Prototipul unei functii

• Transmiterea parametrilor in cadrul unei functii (prin

valoare sau prin adresa)
 Limbajul C
Transmiterea prin valoare

#include<stdio.h>
void schimbare(int x, int y) //se vor crea copii ale variabilelor x şi y
{ int tmp;
tmp=x;
x=y;
y=tmp; //în cadrul copiilor variabilelor se face inversarea
} //la revenire copiile variabilelor x şi y se distrug
void main(void)
{ int x=5, y=7;
schimbare(x,y); //transmitere prin valoare
printf(“%d %d\n”,x,y); //valorile rămân nemodificate adică se va afişa 5 7
}
 Limbajul C
Transmiterea prin adresa

#include<stdio.h>
void schimbare(int *x, int *y) //se vor crea copii ale variabilelor x şi y
{ int tmp;
tmp=*x;
*x=*y;
*y=tmp; //se face inversarea asupra zonei original
}
void main(void)
{ int x=5, y=7;
schimbare(&x,&y); //transmitere prin adresă
printf(“%d %d\n”,x,y); //valorile sunt inversate adică se va afişa 7 5
}
Limbajul C
Constructiile de baza ale limbajului C

 Caracterele

 Identificatorii

 Cuvintele cheie

 Tipuri de date

 Constantele si variabilele

 Comentariile

 Operatorii
 Limbajul C
Constructiile de baza ale limbajului C

 Caracterele (negrafice, spatiu, grafice, codul 0, ‘\n’)

 Identificatorii

 Cuvintele cheie:
int extern else char register for
float typedef do double static while
struct goto switch union return case
long sizeof default short break if
unsigned continue auto
Standardul ANSI C a mai adaugat 5:
 enum const signed void volatile
Limbajul C
Constructiile de baza ale limbajului C

 Tipuri de date

Fundamentale: caracter (char), intreg (int), virgula mobila

(float), virgula mobila dubla precizie (double), nedefinit
(void)

Derivate: tipuri structurate (tablouri, structuri, campuri de

biti, uniuni si enumerari), tipuri functie, tipuri pointer
Limbajul C
Constructiile de baza ale limbajului C

 Tipuri aritmetice
Limbajul C
Constructiile de baza ale limbajului C

 Tipuri aritmetice
Limbajul C
Constructiile de baza ale limbajului C

 Tipul intreg
int numar_octal=045;
int numar_hexa=0x25;
constanta zecimală 37 poate fi scrisă ca 045 în octal şi
ca 0x25 sau 0X25 în hexagesimal.

 Tipul flotant
-1,5e-5
2.e-4
12.4
Limbajul C
Constructiile de baza ale limbajului C

 Tipul caracter -se reprezinta pe un octet si are ca

valoare codul ASCII al caracterului respectiv
‘A’ -> 65
Caractere negrafice –se foloseste \
Limbajul C
Constructiile de baza ale limbajului C

 Tipul caracter
Corect: ‘\’’ (pentru apostrof) ‘\\’ (pentru
backslash)
Gresit: ‘’’ ‘\’

Derivat din tipul caracter este tipul sir de caractere ->

succesiune de octeti ce contin codurile ASCII ale
caracterelor din sir si la sfarsit octetul nul (termina
orice sir de caractere)

“A” -> 65 00
Limbajul C
Constructiile de baza ale limbajului C

 Constante
const double PI=3.1415;
const int LIM=10000;

 Variabile –declarare:
tip lista variabile;

char a,b,c;
int d;
double d;
float f;
Variabile locale, parametri formali si variabile globale.

#include<stdio.h>
int factorial(int n) //n este parametru formal si este
// declarat de tip întreg
{ int i,fact=1;
for(i=2;i<=n;i++) fact=fact*i; //în variabila locala fact
//calculăm n!
return(fact);//functia factorial returnează valoarea lui n!
}
void main(void)
{ int v;
printf("3!=%d\n",factorial(3)); //în functia printf
apelam //functia factorial având ca parametru real valoarea
3
printf("Introd o valoare:");
scanf("%d",&v);
printf("%d!=%d\n",v,factorial(v)); //functia factorial
//este apelata având ca parametru
//real valoarea citita în variabila v
Variabile locale, parametri formali si variabile globale.

#include<stdio.h>
int factorial(int n)
{ int i,fact=1;
for(i=2;i<=n;i++) fact=fact*i;
return(fact);
}
void main(void)
{ int v;
printf("3!=%d\n",factorial(3));
printf("Introd o valoare:");
scanf("%d",&v);
printf("%d!=%d\n",v,factorial(v));
}
Variabile locale, parametri formali si variabile globale.

#include<stdio.h>
int fact=1;
void factorial(int n)
{ int i;
fact=1;
for(i=2;i<=n;i++) fact=fact*i;
}
void main(void)
{ int v;
factorial(3);
printf("3!=%d\n",fact);
printf("Introd o valoare:");
scanf("%d",&v);
factorial(v); printf("%d!=
%d\n",v,fact);
}
Limbajul C
Constructiile de baza ale limbajului C

 Tablouri ->Indicii in C pornesc de la 0 !

int a[10];
float b[5][4];
char c[4];

Clasa de memorare:
clasa_de_memorare tip_de_baza lista_declaratori;

Clasa de memorare: automatic, static, extern si register.

Limbajul C
Constructiile de baza ale limbajului C

 Variabilele automatice -locale fiecarei apelari a unui

bloc sau sau functii si sunt declasate la iesirea din bloc

 Variabile statice –sunt locale unui bloc dar retin

valoarea pana la revenirea in blocul respectiv (interne
respectiv externe=variabile globale)

 Variabile externe –isi pastreaza valoarea in cursul

executiei programului; pot fi folosite pt comunicare
intre functii

 Variabile registru –pentru accesari rapide

Limbajul C
Constructiile de baza ale limbajului C

 Comentarii
/* Acesta este
un comentariu in C */
//comentariu linie C++

 Operatori aritmetici
Limbajul C
Constructiile de baza ale limbajului C

int a,v=0;
a=++v; //dupa executarea instructiunii v=1 si a=1
a=v++; //a=1 si v=2
a=v--; //a=2 si v=1
a=--v; //a=1 si v=0;

float b=5;
b=b + 1/2;
b=b + 1./2;
Limbajul C
Constructiile de baza ale limbajului C

 Operatori relationali si logici

0 –fals in C!
Orice val diferita de 0 = adevarat!
Limbajul C
Constructiile de baza ale limbajului C
 Operatori logici pe biti

7 000000000000000111
8 000000000000001000
si pe biti: 000000000000000000
7&8=0
7&&8=1 (adevarat si adevarat  adevarat).
Limbajul C
Constructiile de baza ale limbajului C
 Operatori logici pe biti
Limbajul C
Constructiile de baza ale limbajului C

 Operatori logici pe biti

Se considera n,p intregi. Sa se seteze pe 1 bitul p din

reprezentarea lui n.

#include<stdio.h>
{
unsigned int n=5,p=1;
n|=1<<p;
printf(“%u\n”n);
}
Limbajul C
Constructiile de baza ale limbajului C

 Operatori logici pe biti

Se considera n,p intregi. Sa se seteze pe 0 bitul p din

reprezentarea lui n.

#include<stdio.h>
{
unsigned int n=7,p=1;
n&= ~(1<<p);
printf(“%u\n”n);
}
Limbajul C
Constructiile de baza ale limbajului C

 Operatori logici pe biti

Sa se înlocuiasca primii p biti semnificativi din

reprezentarea interna a lui n cu complementul lor fata
de 1.
#include<stdio.h>
{
unsigned int n=7,p=3;
n^= ~0<<(8*sizeof(n)-p);
//x^0=x si x^1=!x, oricare ar fi x
printf(“%u\n”n);
}
Limbajul C
Constructiile de baza ale limbajului C

 Operatorul de atribuire

nume_variabila=expresie;

a = b = … = x =expresie;

v=v op expresie v op = expresie.

Limbajul C
Constructiile de baza ale limbajului C

 Operatorul de conversie explicita (cast)

(tip) operand

int a=10, b=4;

double c;
c=a/b;
c=(float)a/b
Limbajul C
Constructiile de baza ale limbajului C

 Operatorul dimensiune (sizeof)

 Operatorul conditional exp1?exp2:exp3;

int a=5, b=3,c;

c=a>b?b:a;

 Operatorul virgula expr1, expr2, … exprn

Limbajul C
Instructiuni C

 Instructiunea vida

 Instructiunea de atribuire

 Instructiunea compusa

 Instructiunea if
if (expresie) instructiune1;
else instructiune2
Limbajul C
Instructiuni C

if(x)
if(y) printf(“1”);
else printf(“2”);

if(x)
{if (y) printf(“1”); }
else printf(“2”);

if(i=0) printf(“Variabila i are valoarea 0”);

else printf(“variabila i are o valoare diferita de 0”);
->Gresit!
Limbajul C
Instructiuni C

 Instructiunea while

#include<stdio.h>
void main(void)
{
int a=18, b=12, r;
while (r=a%b) a=b,b=r;
printf(“cmmdc este %d\n”,b);
}
Limbajul C
Instructiuni C

 Instructiunea do while
do
instructiune;
while(expresie);

 Instructiunea for
for(exp1;exp2;exp3) instructiune;

#include<stdio.h>
void main(void)
{ int n=5, fact=1, i;
for(i=1;i<=n;i++) fact*=i;
printf(“%d! = %d\n”,n,fact);
}
Limbajul C
Instructiuni C

 Instructiunea return
return;
return expresie;

int max(int x, int y)

{
if(x>y) return(x);
else return(y);
}
Limbajul C
Instructiuni C

 Instructiunea break –>iesirea fortata dintr-o bucla

 Functia exit:
void exit(int cod_de_intoarcere);
-termina executia programului

 Instructiunea continue ->continua cu urmatoarea

iteratie a ciclului
Limbajul C
Instructiuni C

 Instructiunea goto –>saltul la o instr precedata de o

eticheta

goto eticheta;
eticheta: instructiune;

 Instructiunea switch
switch (expresie) {
case c1: instr1;
[case c2: instr2;]
…
[default: instr_default;]
}
Limbajul C
Pointeri C

tip *nume;

Operatori: * &

int *p, n=5, m;

p=&n;
m=*p;
m=*p+1;
Limbajul C
Pointeri C

int *p;
float x=1.23, y;
p=&x;
y=*p; ->valoare eronata pentru y

int *a,**b,c=1,d;
a=&c;
b=&a;
d=**b; ->d=1
Limbajul C
Operatii cu pointeri

Adunarea (scaderea) unei constante la un pointer

 
tip*p;
p++; ↔ p=p+sizeof(tip);
p--; ↔ p=p-sizeof(tip);
p=p+c; ↔ p=p+c*sizeof(tip);
p=p-c; ↔ p=p-c*sizeof(tip);
Limbajul C
Operatii cu pointeri

Scăderea a doi pointeri de acelasi tip

Compararea a doi pointeri (operatii relationale cu

pointeri) = =, !=, <, >, <=, >=

Pointeri si tablouri
tip v[lim1][lim2]…[limn];
tip *v;
Limbajul C
Pointeri si tablouri

int v[10];

int *v;
v=malloc(10*sizeof(int));

Referire elemente:
v[i]
*(v+i),
Limbajul C
Pointeri si tablouri

int i;
double v[100],x,*p;
p=&v[0]; ->corect, neelegant
p=v;
x=v[5];
x=*(v+5);
v++; ->incorect
p++; ->corect
Limbajul C
Pointeri si tablouri
void main(void)
{ int v[10]; …
f(v); …
}
void f(int *p)
{ …}
void f(int a[10])
{ …}
void f(int a[])
{ …}
Limbajul C
Pointeri la functii
#include<stdio.h>
int suma(int a, int b)
{ return(a+b);}
int produs(int a, int b)
{ return(a*b);}
void main(void)
{ int a,b;
int (*p)(int,int);
scanf("%d %d",&a,&b);
p=suma;
printf("suma este %d\n",p(a,b));
p=produs;
printf("produsul este %d\n",p(a,b));
}
Limbajul C
Alocarea si dezalocarea memoriei

void *malloc(numar_de_octeti);

void free(void tip);

str=(char *)malloc(10);
free(str);
p=(int *)malloc(50*sizeof(int));
Limbajul C
Tipuri structurate de date

 Structuri
struct nume_structura {
tip nume_camp_1;
tip nume-camp_2;
…
} [lista_variabile_structura];

struct data_calendaristica {
int zi;
int luna;
int an;
} d;
->Referire elemente: d.zi, d.luna, d.an
Limbajul C
struct {
int x;
int *y;
} *p;
 ++p->x incrementează pe x şi nu pe pointerul p, deoarece ordinea implicită este
++(p->x).
(++p)->x incrementează pointerul p inainte de a accesa x,
(p++)->x incrementează pointerul p după ce accesează pe x.
*p->y reprezintă valoarea întregului spre care pointează y
*p->y++ incrementează pointerul y după ce se accesează întregul spre care
pointează y
(*p->y)++ incrementează ceea ce pointează pointerul y
*p++->y incrementează pointerul p după accesul la întregul spre care pointează
y.
Limbajul C
struct NOD {
int cheie;
struct NOD *stanga, *dreapta;
} nod;

nod *creare();
void preordine(nod *p);
Limbajul C
Tipuri structurate de date

 Campuri de biti

struct nume_generic {
tip nume1:lungime;
tip nume2: lungime;
…
tip numen: lungime;
} lista_variabile;
Limbajul C
Tipuri structurate de date

 Uniuni

union nume_generic {
tip nume_variabilă;
tip nume_variabilă;
…
} variabile_uniune;

union exemplu_uniune {
int i;
char ch;
} eu; eu.i=10; eu.ch=’a’;
 Limbajul C
Tipuri structurate de date

 Enumerari

enum nume_generic {lista enumerărilor} lista_variabile_enumerare;

enum curcubeu {roşu, orange, galben, verde, albastru, indigo, violet};

enum curcubeu ec;

ec=albastru;
if (ec= =albastru) printf(“Albastru!\n”);
 Limbajul C
Linii de comanda pentru compilator

 Substitutia lexicala

#define identificator [text]

#define void
#define then
#define begin {
#define end }
#define N 100
 Limbajul C
Linii de comanda pentru compilator

 Substitutia lexicala

#define identificator [text]

#define void
#define then
#define begin {
#define end }
#define N 100
 Limbajul C
Linii de comanda pentru compilator

 Macroinstructiuni

#define max(a,b) (a)>(b)?(a):(b)

#define abs(a) (a)<0?-(a):(a)

#include<stdio.h>
#define PAR(a) a%2==0?1:0
void main(void)
{ if PAR(9+1)) printf(“este par\n”);
else printf(“este impar\n);
}

9+1%2==0 va conduce la 9+0 ==0 F ->”este impar”

 Limbajul C
Linii de comanda pentru compilator

 Suprimarea unei definitii

#undef identificator

 Compilari conditionate

#if expresie_constanta
…
else
…
#endif
 Limbajul C
Linii de comanda pentru compilator

 Compilari conditionate

#ifdef NUME
…
#endif
 
#ifndef NUME
…
#endif
 Limbajul C
Linii de comanda pentru compilator

 Includerea fisierelor

#include<nume_fisier>
#include ”nume_fisier”
 Limbajul C
Functii de intrare/iesire

 Functia printf
 Functia scanf

Functii de citire/scriere
int getchar(void);
int putchar(int c);
char *gets(char *s);
int *puts(char *s);
int getch(void);
int getche(void);
 Limbajul C
 
#include<stdio.h>
void main(void)
{ int a[10],i.n;
for(i=0;i<10;a[i++]=0);
while((n=getchar())!=’\n’)
if((n-‘0’>=0)&&(n-‘0’<=9)) a[n-‘0’]++;
for(i=0;i<10;i++)
if(a[i]) printf(“Cifra %d apare de %d ori\n”,i,a[i]);
}
 Limbajul C
Functii matematice
 Limbajul C
Functii de conversie

int atoi(const char *s);

long atol(const char*s);
double atof(char *s);

Functii generatoare de numere aleatoare

int rand(void);
void srand(unsigned int i);
 Limbajul C
Functii pentru operatii cu caractere si siruri de caractere

int isalpha(int c)
int isdigit(int c)
int isalnum(int c)
int isascii(int c)
int iscntrl(int c)
int isprint(int c)
int iscntrl(int c)
int isupper(int c)
int islower(int c)
int isspace(int c)
int ispunct(int c)
int isspace(int c)
int isxdigit(int c)
int toupper(int c)
int tolower(int c)
 Limbajul C
Functii pentru operatii cu caractere si siruri de caractere

int strcmp(const char *s1, const char *s2);

int *strcpy(char *d, const char *s);
int strncpy(char *d, const char *s, unsigned n);
char *strdup(const char *s);
int strlen(const char *s);
char *strcat(char *d, const char *s);
char *strncat(char *d, const char *s, unsigned n);
char *strchr(const char *s, int c);
char *strrchr(const char *s, int c);
char *strstr(const char *s, const char *subsir);
 Limbajul C
Operatii cu fisiere

-text
-binar

 stdin
 stdout
 stderr

FILE *fp;

FILE *fopen(const char *numefisier, const char *mod);

int fclose(FILE *flux);
 Limbajul C
putc()
fputc()
getc()
fgetc()
fseek()
fputs()
fgets()
fprintf()
fscanf()
fwrite()
fread()
feof()
ferror()
rewind()
rename()
remove()
fflush()
tmpfile()
 Limbajul C
Argumentele liniei de comanda

#include<stdio.h>
#include<stdlib.h>
void main(int argc, char *argv[])
{
if(argc!=2)
{ printf(“Nr invalid de arg pe linia de comanda!\n”);
exit(1);
}
printf(“Salut %s!\n”,argv[1]);
}
 Limbajul C
#include<stdio.h>
#include<stdlib.h>
void main(int argc, char *argv[])
{ FILE *fp;
char ch;
if(argc!=2)
{ printf(“Numar incorect de parametri!\n”);
exit(1); }
if((fp=fopen(argv[1],”w”))==NULL)
{ printf(“Nu se poate deschide in scriere fisierul precizat !\n”);
exit(1); }
do
{ch=getchar();
putc(ch,fp);
} while (ch!=EOF);
fclose(fp);
}