Algoritmi şi programare

2011 – 2012

Cristian Gaţu
Mădălina Răschip

www.infoiasi.ro/~ap
 Organizare
• Lector dr. Cristian Gaţu
– e-mail: cgatu@info.uaic.ro
– cabinet: C212 (corp C, parter); tel: 0232-201546
– url: www.infoiasi.ro/~cgatu
– consultaţii: vineri, 10:00-12:00

• Asist. dr. Mădălina Răschip

– e-mail: mionita@info.uaic.ro
– cabinet: C416 ; tel: 0232-202469
– url: www.info.uaic.ro/~mionita
– consultaţii: luni, 10:00-12:00
Algoritmi şi programare 2
 Pagina cursului

www.info.uaic.ro/~ap

Algoritmi şi programare 3
 Obiective
• Algoritmi
– însuşirea unei gândiri algoritmice
– dezvoltarea abilităţilor de proiectare de soluţii
algoritmice
– însuşirea tehnicilor de utilizare a principalelor
structuri de date
– evaluarea timpului de execuţie în cazul cel mai
nefavorabil
• Programare
– iniţiere în utilizarea unui limbaj de programare
– implementarea principalelor structuri de date
– însuşirea tehnicilor de bază în proiectarea
programelor
Algoritmi şi programare 4
 Conţinutul disciplinei
• Algoritmi
– limbaj algoritmic, tablouri, structuri statice,
structuri înlănţuite
– liste liniare
– arbori binari, heap-uri, union-find
– grafuri (ca structuri de date)
– sortare, căutare
– paradigme
• Programare
– prezentarea graduată a limbajului C (ISO
Standard) cu accent pe implementarea
structurilor de date şi a soluţiilor prezentate în
partea de algoritmică
Algoritmi şi programare 5
 Evaluare
• condiţii:
– activitatea la laborator (AL)
– testele scrise (TS)
• criterii de promovare:
– număr de teme de laborator: 5
– AL >= 6, TS >= 4
• forme:
– AL
• fiecare temă de laborator va fi punctată (note 1-10)
• întrebări, participare la discuţii, soluţii originale (bonus!)
– TS:
• 2 teste scrise (săpt. 8, 16), fiecare test conţinând 8 întrebări de tip
grilă şi o problemă

Algoritmi şi programare 6
 Evaluare
• normele ECTS (European Credit Transfer System)
• Punctaj Final (PF) = 50% AL +50% TS

• Nota finală:
– <= 4 dacă sunt îndeplinite condiţiile şi NU sunt
îndeplinite criteriile de promovare,
– = 10 dacă PF este în primii 5% din cei promovaţi (A)
– = 9 următorii 10% din cei promovaţi (B)
– = 8 următorii 20% din cei promovaţi (C)
– = 7 următorii 30% din cei promovaţi (D)
– = 6 următorii 25% din cei promovaţi (E)
– = 5 ultimii 10% din cei promovaţi

Algoritmi şi programare 7
 Bibliografie
D. Lucanu, M. Craus: Proiectarea algoritmilor,
Polirom, 2008.
T.H. Cormen, C.E. Leiserson, R.L. Rivest:
Introducere in algoritmi, Libris Agora, 2000.
L. Livovschi, H. Georgescu: Sinteza si analiza
algoritmilor, Ed. Stiintifica si enciclopedica, 1986.
H. Schildt: C Manual complet, Teora, 1998.
B.W. Kernighan, D.M. Ritchie: The C Programming
Language, 2nd edition, Prentice Hall, 1988
A. Kelley, I. Pohl: A book on C: Programming in C,
4th edition, Addison Wesley, 1998
Algoritmi şi programare 8
 Curs 1
• limbaj algoritmic
• modelarea memoriei
• tipuri de date elementare

(cu prezentarea elementelor de

limbaj C corespunzătoare)

Algoritmi şi programare 9
 Algoritmi, limbaj algoritmic
• Problemă, Soluţie
• Algoritm: o secvenţă finită de paşi aranjată într-o
ordine logică specifică, cu proprietatea că, atunci
când este executată, produce o soluţie pentru o
problemă dată.
• Exemplu: reţeta culinară
• Algoritm calculator (“computer algorithm”) = un
algoritm pentru care secvenţa de paşi este
executată de un calculator
• Limbaj Algoritmic = un limbaj folosit pentru
descrierea algoritmilor
• Etimologie: Muhammad ibn Musa al-Khwarizmi
Algoritmi şi programare 10
 Algoritmi - proprietăţi
• intrare (input) – zero sau mai multe entităţi de
date furnizate din exterior

• ieşire (output) – algoritmul produce informaţie

• terminare – pentru orice intrare, algoritmul

execută un număr finit de paşi

• corectitudine – algoritmul se termină şi produce

ieşirea corectă pentru orice intrare. Spunem că
algoritmul rezolvă problema dată.

Algoritmi şi programare 12
 Primul program C

void main(){}

“You don’t have to know every detail of C++ to write

good programs.” (B. Stroustrup)

Algoritmi şi programare 13
 Primul program C
/*
* first program in C
*/
#include <stdio.h>

int main(void)
{
printf(“Salut!\n”);
printf(“Primul program C!”);
return (0);
}

Algoritmi şi programare 14
 Primul program C
/*
* first program in C
*/
#include <stdio.h>

int main(void)
{
printf(“Salut!\n”);
printf(“Primul program C!”);
return (0);
}

Algoritmi şi programare 15
 Primul program C

OUTPUT:

Salut!
Primul program C!Press any key to continue

Algoritmi şi programare 16
 Caracterele limbajului C
Litere:
A B C D … X Y Z
a b c d … x y z
Cifre:
0 1 2 3 4 5 6 7 8 9
Alte caractere:
+ - * / = ( ) { } [ ] < > ‘ “ !
# % & _ |^ ~ \ . , ; : ?
Caractere spaţiu: blank, newline, tab, etc.

Algoritmi şi programare 17
 Cuvintele cheie (rezervate)
auto break case char
const continue default do
double else enum
extern
float for goto if
inline int long
register
restrict return short signed
sizeof static struct switch
typedef union unsigned void
volatile while

Algoritmi şi programare 18
 Limbaj algoritmic
• modelarea memoriei
• tipuri de date elementare
• instrucţiuni
• tipuri de date structurate de nivel jos
• calcul
• timp de execuţie

Algoritmi şi programare 19
 Variabilă
• Nume
• Adresă
• Atribute (tip de date asociat valorilor
memorate)

x int
adr

• Instanţă a variabilei

Algoritmi şi programare 20
 Memoria
• Structură liniară de celule
– Variabile

adr
x int

– Pointeri adr
adr

p int*

*p int
Algoritmi şi programare 21
 Tip de date
• Domeniul tipului (colecţia de obiecte)
• Operaţiile tipului
• Categorii de tipuri de date:
– Tipuri de date elementare
– Tipuri de date structurate de nivel jos
• Operaţiile la nivel de componentă
– Tipuri de date de nivel înalt
• Operaţiile implementate de algoritmi utilizator

Algoritmi şi programare 22
 Tip de date
• O valoare memorată sau returnată de o funcţie este
determinată de tipul expresiei utilizate pentru a o
accesa (un identificator – cel mai simplu exemplu
de expresie – are tipul specificat în declaraţia sa)

• Tipuri
– obiect: descriu valori
– funcţie: descriu funcţii
– incomplete: descriu obiecte dar pentru determinarea
dimensiunii lor mai trebuiesc informaţii

Algoritmi şi programare 23
 Tipuri standard
• Tipul char
• Tipurile standard întregi:
– 5 tipuri întregi cu semn: signed char, short int,
int, long int şi long long int.
– 5 tipuri întregi fără semn: desemnate de cuvântul
unsigned (tipuri ce ocupă aceeaşi cantitate de
memorie)
• Tipuri reale flotante:
float, double şi long double.

Algoritmi şi programare 24
 Echivalenţe

signed short int ≡ short

unsigned short int ≡ unsigned short
signed int ≡ int
unsigned int ≡ unsigned
signed long int ≡ long
unsigned long int ≡ unsigned long

Algoritmi şi programare 25
 Declaraţii
• Forma unei declaraţii:
tip variabila;
tip var1, var2, …, varn;
tip variabila = expresie_constanta;
• Variabile globale: declararea lor se face în afara
oricărei funcţii.
• Variabile locale: declararea se face în corpul funcţiei.

char c;
signed char sc; int i;
int suma = 0; float x1, x2, x3;
long j; float pi = 3.14;
double y;
Algoritmi şi programare 26
 Tipul întreg
• int
sizeof(int) = 2 sau 4 octeţi
• short int sau short
sizeof(short)=2, {-32768, …, 32767}
• long int sau long
sizeof(long)=4
{-2 147 483 648, …, 2 147 483 647}
• signed int, signed short int, signed long
int

Algoritmi şi programare 27
 Întregi fără semn
• unsigned int
• unsigned short int
{0, …, 65535}
• unsigned long int
• Nu există overflow (depăşire) – calculul se
efectuează modulo 2n, unde n este numărul
de biţi

Algoritmi şi programare 28
Întregi “foarte scurţi”: char
• Tipul char este o submulţime a tipului int
• char reprezintă, în funcţie de maşină,
domeniul de valori:
{-128, …, 127} sau {0, …, 255}
• unsigned char {0, …, 255}
• signed char {-128, …, 127}
• sizeof(char) = 1

Algoritmi şi programare 29
Constante întregi în <limits.h>
16 biţi 32 biţi
INT_MAX 215  1 231  1
INT_MIN  215  231
LONG_MAX 231  1 263  1
LONG_MIN  231  263

Atenţie la reprezentarea circulară!

•INT_MAX + 1 == INT_MIN
•INT_MIN – 1 == INT_MAX
•LONG_MAX + 1 == LONG_MIN
•LONG_MIN – 1 == LONG_MAX

Algoritmi şi programare 30
 Constante întregi
• Octale: au prefixul 0 (zero)
032 = 26 077 = 63
• Hexazecimale: au prefixul 0x sau 0X
0x32 = 50 0x3F = 63
• Întregi “long”: au sufixul l sau L
2147483647L 0xaf9Fl = 44959
• Întregi “unsigned” au sufixul u sau U
345u 0xffffu = 65535
• Caractere între apostrof: ‘A’, ‘+’, ‘n’
• Caractere în zecimal: 65, 42
• Caractere în octal: ’\101’, ‘\52’
• Caractere în hexazecimal: ‘\x41’, ‘\x2A’
• Notaţii pentru caractere speciale: ‘\n’, ‘\t’, ‘\r’, ‘\\’, ‘\a’,‘\’’,
‘\0’, ‘\”’

Algoritmi şi programare 31
 Citiri, afişări
printf(“a: ”);
•citirea unui int scanf(“%d”, &a);

int a = 10;
•afişarea unui int printf(“a = %d”, a);

•citirea unui char printf(“a: ”);

scanf(“%c”, &a);

•afişarea unui char char a = ‘a’;

printf(“a = %c”, a);

Algoritmi şi programare 32
 Constante - exemplu
/* Exemple de constante caracter */
#include <stdio.h>
int main(){
char a, b, c, d;
a = 'A'; b = 65; c = '\101'; d = '\x41';
printf("%c %c %c %c\n", a, b, c, d);
printf("%c %d %o %x\n", a, a, a, a);
return 0;
}

A A A A
A 65 101 41

Algoritmi şi programare 33
 Codurile ASCII
#include <stdio.h>
int main (void){
short c;
for(c = 0; c <= 127; c++){
printf("cod ASCII: %d",c);
printf(" caracter: %c\n",c);
}
return 0;
}

/* for(c=‘a’; c<=‘z’; c++) */

Algoritmi şi programare 34
 Macrourile getchar() şi putchar()
• Sunt definite în <stdio.h>
• Citire caracter de la tastatură
• Scriere caracter pe ecran

#include <stdio.h>
int main (void){
char c;
while ((c=getchar()) != EOF)
{putchar(c); putchar(c);}
return 0;
}
Sirul de intrare: 123456abcd
va produce sirul: 112233445566aabbccdd
Algoritmi şi programare 35
Operaţii; Funcţii în biblioteci
• Operaţii pentru tipurile întregi:
+ - * / % == != < <= >
>= ++ --
• Funcţii:
– cele de la tipul flotant
– cele din biblioteca <ctype.h>: tolower,
toupper, isalpha, isalnum, iscntrl, isdigit,
isxdigit, islower, isupper, isgraph, isprint,
ispunct, isspace

Algoritmi şi programare 36
 Operatorii ++ şi --
• Se aplică doar unei expresii ce desemnează
un obiect din memorie (L-value):

Expresie ++i i++ --i i--

Valoare i+1 i i-1 i
i după evaluare i+1 i+1 i-1 i-1

++5 --(k+1) ++i++ nu au sens

Algoritmi şi programare 37
 Exemplu ++ (temă)
#include <stdio.h>
int* f(int* a){
int b = 2;
(*a) += b;
return a;
}
int main (void){
int a = 5;
(*f(&a))++;
printf("%d \n", a);
return 0;
}

Algoritmi şi programare 38
 Tipul flotant (real)
• float
– Numere reale în simplă precizie
– sizeof(float) = 4
–10 37  abs( f )  1038
– 6 cifre semnificative
• double
– Numere reale în dublă precizie
– sizeof(double) = 8
–10 307  abs( f )  10308
– 15 cifre semnificative

Algoritmi şi programare 39
 Tipul flotant (real)
• long double
– Numere reale în “extra” dublă precizie
– sizeof(long double) = 12
– 10 4931  abs( f )  10 4932
– 18 cifre semnificative
• Limitele se găsesc în <float.h>
• Operaţii: + - * / == != < <= > >=

Algoritmi şi programare 40
 Constante reale
• Constantele reale sunt implicit double
125.435 1.12E2 123E-2 .45e+6 13. .56

• Pentru a fi float trebuie sa aibă sufixul f sau F

.56f 23e4f 45.54E-1F

• Pentru long double trebuie sa aibă sufixul l sau L

123.456e78L

Algoritmi şi programare 41
 Citire, afişare
printf(“x: ”);
•citirea unui float scanf(“%f”, &x);

float pi = 3.14;
•afişarea unui float printf(“pi = %f”, pi);

•citirea unui double printf(“x: ”);

scanf(“%lf”, &x);

•afişarea unui double double pi = 3.14L;

printf(“pi = %lf”, pi);

Algoritmi şi programare 42
 Funcţii
(în biblioteca <math.h>)

sin cos tan asin

acos atan sinh cosh
tanh exp log log10
pow sqrt ceil floor
fabs ldexp frexp modf
fmod

Algoritmi şi programare 43
 Utilizare typedef
Mecanism prin care se asociază un tip unui
identificator:
typedef char litera_mare;
typedef short varsta;
typedef unsigned long size_t;

Identificatorul respectiv se poate utiliza pentru

a declara variabile sau funcţii:
litera_mare u, v=‘a’;
varsta v1, v2;
size_t dim;

Algoritmi şi programare 44
 Date booleene (logice)
• Nu există un tip special pentru date logice
• Domeniul de valori: {false, true}
• false = 0
• true = 1 dar şi orice întreg nenul
• Operaţii: ! && || == !=
• Declaraţii posibile:
typedef enum {false = 0, true = 1} bool;
bool x, y;

Algoritmi şi programare 45
 Expresii logice
expresie_relationala ::=
expr < expr | expr > expr
| expr <= expr | expr >= expr
| expr == expr | expr != expr
expresie_logica ::=
! expr
| expr || expr
| expr && expr

Algoritmi şi programare 46
Valoarea expresiilor relaţionale

a-b a<b a>b a<=b a>=b a==b a!=b

positiv 0 1 0 1 0 1
zero 0 0 1 1 1 0

negativ 1 0 1 0 0 1

Algoritmi şi programare 47
 Valoarea expresiilor logice ||

exp1 exp2 exp1 || exp2

nu se
<> 0
evaluează 1
1 dacă exp2 <> 0
= 0 se evaluează
0 dacă exp2 = 0

Algoritmi şi programare 48
 Valoarea expresiilor logice &&

exp1 exp2 exp1 && exp2

nu se
= 0 0
evaluează
1 dacă exp2 <> 0
<> 0 se evaluează
0 dacă exp2 = 0

Algoritmi şi programare 49
 Exemple
• O condiţie de forma a ≤ x ≤ b se scrie în
limbajul C:
(x >= a) && (x <= b) (a <= x) && (x <= b)

• O condiţie de forma a > x sau x > b se

scrie în limbajul C:
(x < a) || (x > b) !(x >= a && x <= b)

Algoritmi şi programare 50
 Operatorul condiţional ?:
exp1 ? exp2 : exp3

• Se evaluează exp1

• Dacă exp1 are valoare true (nenulă) atunci

valoarea expresiei este valoarea lui exp2; exp3 nu
se evaluează

• Dacă exp1 are valoare false (nulă) atunci valoarea

expresiei este valoarea lui exp3; exp2 nu se
evaluează

• Operatorul ?: este drept asociativ

Algoritmi şi programare 51
 Operatorul condiţional ?:
Exemple
x >= 0 ? x : y
x > y ? x : y
x > y ? x > z ? x : z : y > z ? y : z

#include <stdio.h>
int main(void){
int a=1, b=2, c=3;
int x, y, z;
x = a?b:c?a:b;
y = (a?b:c)?a:b; /* asociere stanga */
z = a?b:(c?a:b); /* asociere dreapta */
printf("x = %d, y = %d, z = %d\n", x, y, z);
}
/* x = 2, y = 1, z = 2 */

Algoritmi şi programare 52
Operatorul = (Expresia de atribuire)

exp1 = exp2
• exp1 este o “L-value” (obiect din memorie: variabilă,
variabilă tablou cu indici, etc.)
• Tipul expresiei este tipul lui exp1

• Se evaluează exp2, apoi exp1 capată valoarea lui exp2,

eventual convertită

• Aşadar, operatorul = modifică valoarea operandului stang

• Valoarea expresiei este valoarea lui exp1 după evaluare
• Operatorul = este drept asociativ

Algoritmi şi programare 53
 Operatorul = (Exemple)
x = sqrt(9);
a = ( b = 2 ) + ( c = 3 );
a = b = c = 0; /* echivalenta cu */
a = (b = (c = 0));
while((c = getchar()) != EOF) putchar(c);

Nu confundaţi e1 = e2 cu e1 == e2 !
a = 0;
if ( a == 0 ) printf(“nul”);
else printf(“nenul”); /* nul */

if ( a = 0) printf(“nul”);
else printf(“nenul”); /* nenul */

Algoritmi şi programare 54
Operatori de atribuire compusă
O expresie de atribuire compusă are forma:
exp1 op= exp2
unde op= este unul din:
+= -= *= /= %= &= |= ^= >>= <<=

Expresia este echivalentă cu

exp1 = exp1 op (exp2)
cu precizarea că exp1 se evaluează o singură dată.

j *= k + 3; /* echivalentă cu: */
j = j * (k + 3);

j *= k = m + 5; /* echivalentă cu: */
j = (j * (k = (m + 5)));

Algoritmi şi programare 55
 Operatorul virgulă ,
expresia_virgula ::= expresie, expresie

• Se evaluează prima expresie apoi cea de-a doua.

• Valoarea şi tipul întregii expresii este valoarea şi tipul
operandului drept.
• Operatorul virgulă are cea mai mică precedenţă.

a = 1, b = 2;
i = 1, j = 2, ++k + 1;
k != 1, ++x * 2.0 + 1;
for(suma = 0, i = 1; i <= n; suma += i, ++i);

Algoritmi şi programare 56
 Tipul void
• Conversia în tip void a unei expresii semnifică
faptul că valoarea sa este ignorată

• Utilizat pentru tipul pointer; nu se face controlul

tipului la un pointer de tip void

• Utilizat pentru funcţii fără valoare returnată sau

pentru funcţii fără parametri

• Este un tip incomplet ce nu poate fi completat

Algoritmi şi programare 57
 Operatorul sizeof()
• Operator unar ce permite găsirea numărului
de octeţi pe care se reprezintă un obiect
(tip,expresie)
sizeof(int), sizeof(double);
sizeof(b*b-4*a*c), sizeof(i);

sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)
sizeof(signed) = sizeof(unsigned) = sizeof(int)
sizeof(float)<=sizeof(double)<=sizeof(long double)

Algoritmi şi programare 58
 Operatorul sizeof()
#include <stdio.h>

int main(void){
int x = 1; double y = 9; long z = 0;
printf("Operatorul sizeof()\n\n\n");
printf("sizeof(char) = %2u\n",sizeof(char));
printf("sizeof(int) = %2u\n",sizeof(int));
printf("sizeof(short) = %2u\n",sizeof(short));
printf("sizeof(long) = %2u\n",sizeof(long));
printf("sizeof(float) = %2u\n",sizeof(float));
printf("sizeof(double) = %2u\n",sizeof(double));
printf("sizeof(long double) = %2u\n",sizeof(long double));
printf("sizeof(x +y + z) = %2u\n",sizeof(x+y+z));
return 0;
}

Algoritmi şi programare 59
 Operatorul sizeof()
Rezultatul executiei Visual C++:

sizeof(char) = 1
sizeof(int) = 4
sizeof(short) = 2
sizeof(long) = 4
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(x + y + z) = 8

Algoritmi şi programare 60
 Precedenţa operatorilor
Operatori Asociere
() ++ -- (postfix) stânga
++ -- (prefix) ! & (adresa) dreapta
* (deref) + - (unari) sizeof()
* / % stânga
+ - stânga
< <= > >= stânga
== != stânga
&& stânga
|| stânga
?: dreapta
= += -= *= /= %= dreapta
, (operatorul virgula) stânga

Algoritmi şi programare 61
Compatibilitatea tipurilor predefinite

• Toate tipurile aritmetice (caractere, întregi,

reale) sunt compatibile între ele;
compilatorul admite orice combinaţie de
obiecte de diverse tipuri într-o expresie

• La evaluarea unei expresii în care apar tipuri

diferite compilatorul face conversii implicite

Algoritmi şi programare 62
 Reguli pentru conversia implicită

• În absenţa unui unsigned obiectele se convertesc

la tipul cel mai “înalt” în ordinea (descrescatoare):
long double, double, float, long int, int

• Regulile pentru operanzii unsigned depind de

implementare.

• Conversia la unsigned se face doar în caz de

necesitate (de ex. valoarea din unsigned nu
“încape” în celălat operand).

Algoritmi şi programare 63
 Reguli pentru conversia implicită
• Regula “integer promotion” : operaţiile se fac cel
puţin în int, deci char şi short sunt “promovaţi” la
int.

• La o asignare (v = exp) tipul membrului drept se

converteşte la tipul membrului stâng (care este şi
tipul rezultatului).
– ATENŢIE: se pot produce
• Pierderea preciziei (double → float → long int)
• Pierderea unor biţi semnificativi (long → int)
• Nedeterminări

Algoritmi şi programare 64
 Exemplu
#include <stdio.h>
int main(void){
char c1 = -126, c2; /* c1 = 10000010 */
unsigned char c3, c4 = 255; /* c4 = 111111111 */
short s1, s2 = -32767; /* s2=10000000 00000001 */
short s3 = -1, s4; /* s3 = 11111111 11111111 */
s1 = c1;
printf("c1 = %d, s1 = %d\n", c1, s1);
c2 = s2;
printf("c2 = %d, s2 = %d\n", c2, s2);
c3 = s3;
printf("c3 = %d, s3 = %d\n", c3, s3);
s4 = c4;
printf("c4 = %d, s4 = %d\n", c4, s4);
return 0;
}
Algoritmi şi programare 65
 Exemplu (rezultatul execuţiei)
c1 = 10000010 s1 = c1;
c1 = -126, s1 = -126

s2=10000000 00000001 c2 = s2;

c2 = 1, s2 = -32767

s3 = 11111111 11111111 c3 = s3;

c3 = 255, s3 = -1

c4 = 111111111 s4 = c4;
c4 = 255, s4 = 255

Algoritmi şi programare 66
 Forţarea tipului - cast
• Conversia explicită la tipul numetip:
(numetip) expresie
• Exemple:
(long)(‘A’ + 1.0)
(int)(b*b-4*a*c)
(double)(x+y)/z
(float)x*y/z
x / (float)2

Algoritmi şi programare 67
 Exemplu cast
#include <stdio.h>
int main(void){
int i, j; double x, y, z, t;
i = 5/2; x = 5/2; y = (double)(5/2);
j = (double)5/2; z = (double)5/2;
t = 5./2;
printf(“%d, %g, %g, %d, %g, %g\n”,
i, x, y, j, z, t);
return 0;
}
/* 2, 2, 2, 2, 2.5, 2.5 */

Algoritmi şi programare 68
Fişiere în bibliotecă relative la tipuri

• <limits.h> - pentru tipurile întregi

– Întregul min/max: INT_MIN, INT_MAX
– Numărul de biţi pe caracter CHAR_BIT
– Etc.

• <float.h> - pentru tipurile flotante:

– Exponentul maxim
– Precizia zecimală, etc.

• <stdlib.h> - conţine funcţii de conversie:

– Şir de caractere în int: atoi(const char*)
– Şir de caractere în float:atof(const char*)

Algoritmi şi programare 69