skyler_sdf

Operaţii de intrare / ieşire Întrucât limbajul C nu a fost dezvoltat pentru un sistem particular de operare, şi datorită faptului că s-a dorit realizarea unei portabilităţi cât mai mari, atât a unui compilator C, cât şi a programelor scrise în acest limbaj, el nu posedă facilităţi de intrare / ieşire. Există totuşi un sistem de intrare / ieşire constituit dintr-un număr de subprograme care realizează funcţii de intrare / ieşire pentru programe scrise în C, dar care nu fac parte din limbajul C. Aceste subprograme se găsesc în biblioteca C. Scopul acestui capitol este de a descrie cele mai utilizate subprograme de intrare / ieşire şi interfaţa lor cu programele scrise în limbajul C. Intrări şi ieşiri standard; fişiere Sistemul I/O oferă utilizatorului trei „fişiere” standard de lucru. Cuvântul fişier a fost pus între ghilimele, deoarece limbajul nu defineşte acest tip de dată şi pentru că fişierele reprezintă mai degrabă nişte fluxuri de intrare / ieşire standard puse la dispoziţia utilizatorului. Aceste fişiere sunt: – fişierul standard de intrare (stdin); – fişierul standard de ieşire (stdout); – fişierul standard de afişare a mesajelor (stderr). Toate aceste trei fişiere sunt secvenţiale şi în momentul execuţiei unui program C sunt implicit definite şi deschise. stdin şi stdout sunt asociate în mod normal terminalului de la care a fost lansat programul în execuţie. Sistemul I/O permite redirectarea acestor fişiere pe alte periferice şi închiderea lor la încheierea execuţiei programului. Redirectarea fişierului stdin se specifică prin construcţia: <specificator-fişier-intrare în linia de comandă prin care a fost lansat programul. Redirectarea fişierului stdout se specifică prin construcţia: >specificator-fişier-ieşire în linia de comandă prin care a fost lansat programul. Redirectarea fişierului stdout pe un alt periferic, în scopul efectuării unei operaţii de adăugare (append) se specifică prin construcţia: >>specificator-fişier-ieşire stderr este întotdeauna asociat terminalului de la care a fost lansat programul în execuţie şi nu poate fi redirectat. Astfel că o linie de comandă a unui program poate arăta astfel: Prog <intrare-standard >ieşire-standard alţi parametri Prog < intrare-standard >> ieşire-standard alţi parametri Fiecare din parametri poate lipsi; în lipsa unui specificator de intrare sau ieşire standard se foloseşte terminalul curent. Asocierea unui fişier cu intrarea sau ieşirea standard este făcută de sistemul de operare, programul primind doar informaţii despre ceilalţi parametri din linia de comandă. Pentru a se putea face o referire la fişiere orice program C trebuie să conţină fişierul stdio.h, care se include printr-o linie de forma: #include <stdio.h> Pentru claritatea şi lizibilitatea programelor scrise în C, cât şi pentru crearea unei imagini sugestive asupra lucrului cu fişiere, în fişierul de definiţii standard stdio.h s-a definit un nou nume de tip de dată şi anume FILE care este o structură. Pentru a referi un fişier, este necesară o declaraţie de forma: FILE *fp; unde fp va fi numele de dată cu care se va referi fişierul în orice operaţie de intrare / ieşire asociată. Iată câteva informaţii păstrate de structura FILE: – un identificator de fişier pe care sistemul de operare âl asociază fluxului pe durata prelucrării; acesta poate fi aflat cu ajutorul funcţiei fileno; – adresele zonelor tampon asociate; poziţia curentă în aceste zone; – indicatorii de sfârşit de fişier şi de eroare; – alte informaţii. Accesul la fişiere, deschidere şi închidere Nume fopen - deschide un flux Declaraţie FILE *fopen(const char *num, const char *mod); Descriere Funcţia fopen deschide fişierul al cărui nume este un şir indicat de num şi îi asociază un flux. Argumentul mod indică un şir care începe cu una din secvenţele următoare: r deschide un fişier pentru citire; r+ deschide pentru citire şi scriere; w trunchiază fişierul la lungime zero sau creează un fişier pentru scriere; w+ deschide pentru adăugare la sfârşit, în citire şi scriere; fişierul este creat dacă nu există, altfel este trunchiat; a deschide pentru adăugare la sfârşit, în scriere; fişierul este creat dacă nu există; a+ deschide pentru adăugare la sfârşit, în citire şi scriere; fişierul este creat dacă nu există; Nume fclose - închide un flux Declaraţie int fclose( FILE *flux); Descriere Funcţia fclose închide fişierul asociat fluxului flux. Dacă flux a fost deschis pentru ieşire, orice date aflate în zone tampon sunt scrise în fişier în prealabil cu un apel fflush. Valori returnate În caz de succes se returnează 0. În caz de eroare se returnează EOF şi variabila globală errno indică codul erorii. Nume tmpfile - creează un fişier temporar Declaraţie FILE *tmpfile(); Descriere Funcţia tmpfile generează un nume unic de fişier temporar. Acesta este deschis în mod binar pentru scriere / citire ("wb+"). Fişierul va fi şters automat la închidere sau la terminarea programului. Valoare returnată Funcţia returnează un descriptor de flux în caz de succes, sau NULL dacă nu poate fi generat un nume unic de fişier sau dacă fişierul nu poate fi deschis. În caz de eroare variabila globală errno indică codul erorii. Nume fflush - forţează scrierea în flux Declaraţie int fflush(FILE *flux); Descriere Funcţia fflush forţează o scriere a tuturor datelor aflate în zone tampon ale fluxului flux. Fluxul rămâne deschis. Valori returnate În caz de succes se returnează 0. În caz de eroare se returnează EOF şi variabila globală errno indică codul erorii. Nume fseek, ftell, rewind - repoziţionează un flux Declaraţie int fseek(FILE *flux, long ofs, int reper); long ftell(FILE *flux); void rewind(FILE *flux); Descriere Funcţia fseek setează indicatorul de poziţie pentru fişierul asociat fluxului flux. Noua poziţie, dată în octeţi, se obţine adunând ofs octeţi (offset) la poziţia specificată de reper. Dacă reper este SEEK_SET, SEEK_CUR, sau SEEK_END, ofs este relativ la începutul fişierului, poziţia curentă a indicatorului, respectiv sfârşitul fişierului. Funcţia fseek şterge indicatorul de sfârşit de fişier Funcţia ftell obţine valoarea curentă a indicatorului de poziţie pentru fişierul asociat fluxului flux. Funcţia rewind poziţionează indicatorul de poziţie pentru fişierul asociat fluxului flux la începutul fişierului. Este echivalentă cu: (void)fseek(flux, 0L, SEEK_SET) cu completarea că funcţia rewind şterge şi indicatorul de eroare al fluxului. Valori returnate Funcţia rewind nu returnează nici o valoare. În caz de succes, fseek returnează 0, şi ftell returnează offset-ul curent. În caz de eroare se returnează EOF şi variabila globală errno indică codul erorii. Nume fileno – returnează descriptorul asociat fluxului Declaraţie int fileno(FILE *flux); Descriere Funcţia fileno examinează argumentul flux şi returnează descriptorul asociat de sistemul de operare acestui flux. Nume fgets - citeşte un şir de caractere dintr-un flux text Declaraţie char *fgets(char *s, int size, FILE *flux); Descriere Funcţia fgets citeşte cel mult size-1 caractere din flux şi le memorează în zona indicată de s. Citirea se opreşte la detectarea sfârşitului de fişier sau new-line. Dacă se citeşte caracterul new-line acesta este memorat în s. După ultimul caracter se memorează null. Apeluri ale acestei funcţii pot fi combinate cu orice apeluri ale altor funcţii de intrare din bibliotecă (fscanf, de exemplu) pentru un acelaşi flux de intrare. Valori returnate Funcţia returnează adresa s în caz de succes, sau NULL în caz de eroare sau la întâlnirea sfârşitului de fişier dacă nu s-a citit nici un caracter. Nume fputs - scrie un şir de caractere într-un flux text Declaraţie int fputs(const char *s, FILE *flux); Descriere Funcţia fputs scrie şirul s în flux fără caracterul terminator null. Apeluri ale acestei funcţii pot fi combinate cu orice apeluri ale altor funcţii de ieşire din bibliotecă (fprintf, de exemplu) pentru un acelaşi flux de ieşire. Valori returnate Funcţia returnează o valoare non-negativă în caz de succes, sau EOF în caz de eroare. Nume fread, fwrite - intrări / ieşiri pentru fluxuri binare Declaraţie unsigned fread(void *ptr, unsigned size, unsigned nel, FILE *flux); unsigned fwrite(const void *ptr, unsigned size, unsigned nel, FILE *flux); Descriere Funcţia fread citeşte nel elemente, fiecare având mărimea size octeţi, din fluxul indicat de flux, şi le memorează în zona indicată de ptr. Funcţia fwrite scrie nel elemente, fiecare având mărimea size octeţi, din fluxul indicat de flux, pe care le ia din zona indicată de ptr. Valori returnate Funcţiile returnează numărul de elemente citite sau scrise cu succes (şi nu numărul de caractere). Dacă apare o eroare sau se întâlneşte sfârşitul de fişier, valoarea returnată este mai mică decât nel (posibil zero). Nume scanf, fscanf, sscanf - citire cu format Declaraţie int scanf(const char *fmt, ...); int fscanf(FILE *flux, const char *fmt, ...); int sscanf(char *str, const char *fmt, ...); Descriere Funcţiile din familia ...scanf scanează intrarea în concordanţă cu şirul de caractere fmt după cum se descrie mai jos. Acest format poate conţine specificatori de conversie; rezultatele unor astfel de conversii (dacă se efectuează) se memorează prin intermediul argumentelor pointer. Funcţia scanf citeşte şirul de intrare din fluxul standard stdin, fscanf din flux, şi sscanf din şirul indicat de str. Nume printf, fprintf, sprintf - scriere cu format Declaraţie int printf(const char *fmt, ...); int fprintf(FILE *flux, const char *fmt, ...); int sprintf(char *str, const char *fmt, ...); Descriere Funcţiile din familia ...printf generează o ieşire în concordanţă cu format după cum se descrie mai jos. Funcţia printf afişează ieşirea la fluxul standard stdout; fprintf scrie ieşirea la flux; sprintf scrie ieşirea în şirul de caractere str. Nume perror - afişează un mesaj de eroare sistem Declaraţie void perror(const char *s); #include <errno.h> const char *sys_errlist[]; int sys_nerr; Descriere Rutina perror afişează un mesaj la ieşirea standard de eroare, care descrie ultima eroare întâlnită la ultimul apel sistem sau funcţie de bibliotecă. Mai întâi se afişează argumentul s, apoi virgula şi blanc, şi în final mesajul de eroare şi new-line. Se recomandă (mai ales pentru depanare) ca argumentul s să includă numele funcţiei în care a apărut eroarea. Codul erorii se ia din variabila externă errno. Lista globală de erori sys_errlist[] indexată cu errno poate fi folosită pentru a obţine mesajul de eroare fără new-line. Ultimul indice de mesaj din listă este sys_nerr-1. Se recomandă o atenţie deosebită în cazul accesului direct la listă deoarece unele coduri noi de eroare pot lipsi din sys_errlist[]. Dacă un apel sistem eşuează variabila errno indică codul erorii. Aceste valori pot fi găsite în <errno.h>. Funcţia perror serveşte la afişarea acestui cod de eroare într-o formă lizibilă. Dacă un apel terminat cu eroare nu este imediat urmat de un apel perror, valoarea variabilei errno se poate pierde dacă nu e salvată. Nume clearerr, feof, ferror - verifică şi resetează starea fluxului Declaraţie void clearerr(FILE *flux); int feof(FILE *flux); int ferror(FILE *flux); Descriere Funcţia clearerr şterge indicatorii de sfârşit de fişier şi eroare ai fluxului. Funcţia feof testează indicatorul de sfârşit de fişier al fluxului, şi returnează non-zero dacă este setat. Acesta este setat dacă o operaţie de citire a detectat sfârşitul de fişier. Funcţia ferror testează indicatorul de eroare al fluxului, şi returnează non-zero dacă este setat. Acesta este setat dacă o operaţie de citire sau scriere a detectat o eroare (datorată de exemplu hardware-ului).

Funcţii Funcţiile sunt elementele de bază ale unui program scris în C: orice program, de orice dimensiune, constă din una sau mai multe funcţii, care specifică operaţiile care trebuie efectuate. Acest fapt dă limbajului C caracterul de limbaj de programare procedural. Funcţiile sunt singurul mod de a face faţă complexităţii programelor mari, permit desfacerea programelor mari în module mai mici, şi dau utilizatorului posibilitatea de a dezvolta programe, folosind ceea ce alţii au făcut deja, în loc să o ia de la început. Limbajul C a fost conceput să permită definirea de funcţii eficiente şi uşor de mânuit. În general e bine să concepem programe constituite din mai multe funcţii mici decât din puţine funcţii de dimensiuni mari. Un program poate fi împărţit în mai multe fişiere sursă în mod convenabil, iar fişierele sursă pot fi compilate separat. O prezentare a functiilor din biblioteca standard aici: Link Exemple: 1. Funcţia atof converteşte un şir de cifre din formatul ASCII într-un număr flotant în precizie dublă. Această funcţie acceptă un şir care conţine reprezentarea unui număr zecimal (eventual cu semn), compus din parte întreagă şi parte fracţionară (oricare putând lipsi), separate prin punct zecimal. double atof(char s[]) { double val,fr; int i,sn; sn = 1; i = 0; if (s[0]=='+' || s[0]=='-') sn = (s[i++]=='+') ? 1 : -1; for (val=0; s[i]>='0' && s[i]<='9'; i++) val = 10 * val + s[i] - '0'; if (s[i]== '.') i++; for (fr=1; s[i]>='0' && s[i]<='9'; i++) { val = 10 * val +s[i] - '0'; fr *= 10; } return sn * val / fr; } 2. Funcţia atoi converteşte un şir de cifre în echivalentul lor numeric întreg. int atoi(char s[]) { int i,sn,v; i = 0; sn = 1; if (s[i]=='+' || s[i]=='-') sn = (s[i++]=='+') ? 1 : -1; for (v=i=0; s[i]>='0' && s[i]<='9'; i++) v = 10 * v + s[i] - '0'; return sn * v; } 3. Funcţia lower converteşte literele mari din setul de caractere ASCII în litere mici. Dacă lower primeşte un caracter care nu este o literă mare atunci îl returnează neschimbat. int lower(int c) { if (c>='A' && c<='Z') return c + 'a' - 'A'; else return c; } 4. Funcţia binary realizează căutarea valorii x într-un masiv sortat v, care are n elemente. int binary(int x, int v[], int n) { int l,r,m; l = 0; r = n - 1; while (l<=r) { m = (l + r) / 2; if (v[m]==x) return m; if (v[m]<x) l = m + 1; else r = m - 1; } return -1; } Funcţia returnează poziţia lui x (un număr între 0 şi n-1), dacă x apare în v sau -1 altfel. Alte rutine din biblioteca standard: Sortare si cautare Nume qsort - sorteaza un masiv bsearch - cautare binara într-un masiv sortat Declaratie #include <stdlib.h> void qsort(void *base, unsigned nel, unsigned size, int (*comp) (const void *, const void *)); void *bsearch(const void *key, const void *base, unsigned nel, unsigned size, int Descriere Functia qsort sorteaza un masiv de nel elemente, fiecare de marime size. Argumentul base indica spre începutul masivului. Elementele masivului sunt sortate în ordine crescatoare în concordanta cu functia de comparare referita de comp, apelata cu doua argumente care indica spre obiectele ce se compara. Functia de comparare trebuie sa returneze un întreg mai mic decât, egal cu, sau mai mare decât zero daca primul argument este considerat a fi mai mic decât, egal cu, respectiv mai mare decât al doilea. Daca cele doua elemente comparate sunt egale, ordinea în masivul sortat este nedefinita. Functia bsearch cauta într-un masiv de nel elemente, fiecare de marime size, un membru care coincide cu obiectul indicat de key. Argumentul base indica spre începutul masivului. Continutul masivului trebuie sa fie sortat crescator în concordanta cu functia de comparare referita de comp, apelata cu doua argumente care indica spre obiectele ce se compara. Functia de comparare se defineste ca în cazul qsort. Primul argument este adresa cheii, al doilea este adresa unui element din masiv. Valoare returnata Functia bsearch returneaza un pointer la un membru al masivului care coincide cu obiectul indicat de key, sau NULL daca nu se gaseste nici un membru. Daca exista mai multe elemente care coincid cu key, poate fi returnat oricare element cu aceasta proprietate. Rutine de clasificare Nume isalnum, isalpha, isascii, iscntrl, isdigit, isgraph, islower, isprint, ispunct, isspace, isupper, isxdigit - rutine de clasificare tolower - conversie în litera mica toupper - conversie în litera mare Declaratie #include <ctype.h> int isalnum(int c); int isalpha(int c); int isascii(int c); int iscntrl(int c); int isdigit(int c); int isgraph(int c); int islower(int c); int isprint(int c); int ispunct(int c); int isspace(int c); int isupper(int c); int isxdigit(int c); int tolower(int c); int toupper(int c); Descriere Primele 12 functii verifica daca c, care trebuie sa fie o valoare de tip unsigned char sau EOF, se afla în una din clasele de caractere enumerate mai sus. isalnum Verifica daca c este alfanumeric (litera sau cifra). isalpha Verifica daca c este alfabetic (litera mare sau mica). isascii Verifica daca c este o valoare pe 7 biti din setul de caractere ASCII. iscntrl Verifica daca c este un caracter de control. isdigit Verifica daca c este o cifra (între 0 si 9). isgraph Verifica daca c este un caracter afisabil cu exceptia spatiului. islower Verifica daca c este o litera mica. isprint Verifica daca c este un caracter afisabil inclusiv spatiu. ispunct Verifica daca c este un caracter diferit de spatiu si non-alfanumeric. isspace Verifica daca c este un spatiu alb. isupper Verifica daca c este o litera mare. isxdigit Verifica daca c este o cifra hexazecimala din setul: 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F tolower Converteste caracterul c, daca este o litera, la litera mica corespunzatoare. toupper Converteste caracterul c, daca este o litera, la litera mare corespunzatoare. Valoare returnata Valoarea returnata de functiile is... este nenula daca caracterul c se afla în clasa testata, si zero în caz contrar. Valoarea returnata de functiile to... este litera convertita daca caracterul c este o litera, si nedefinita în caz contrar. Operatii cu siruri de caractere Pentru majoritatea functiilor din aceasta categorie compilatorul expandeaza codul acestora folosind instructiuni pe siruri de caractere. Aceste functii sunt declarate în <string.h> Nume strlen - calculeaza lungimea unui sir Declaratie unsigned strlen(const char *s); Descriere Functia strlen calculeaza lungimea sirului s, fara a include caracterul terminator null. Valoare returnata Functia returneaza numarul de caractere din s. Nume strcpy, strncpy - copiaza un sir de caractere Declaratie char *strcpy(char *dest, const char *src); char *strncpy(char *dest, const char *src, unsigned n); Descriere Functia strcpy copiaza sirul indicat de src (inclusiv caracterul terminator null) în zona indicata de dest. Sirurile nu trebuie sa se suprapuna, si în plus zona dest trebuie sa fie suficient de mare pentru a primi copia. Functia strncpy este similara, cu exceptia faptului ca nu se copiaza mai mult de n octeti din src. Astfel, daca caracterul terminator null nu se afla în primii n octeti din src, rezultatul nu va fi terminat cu null. În cazul în care lungimea lui src este mai mica decât n, restul octetilor din dest primesc valoarea null. Valoare returnata Functiile returneaza un pointer la sirul dest. Nume strdup - duplica un sir Declaratie char *strdup(const char *s); Descriere Functia strdup returneaza un pointer la un nou sir care este un duplicat al sirului s. Memoria pentru noul sir se obtine cu malloc, si poate fi eliberata cu free. Valoare returnata Functia returneaza un pointer la sirul duplicat, sau NULL daca nu exista memorie suficienta disponibila. Nume strcat, strncat - concateneaza doua siruri Declaratie char *strcat(char *dest, const char *src); char *strncat(char *dest, const char *src, unsigned n); Descriere Functia strcat adauga sirul src la sirul dest suprascriind caracterul null de la sfârsitul lui dest, si la sfârsit adauga un caracter terminator null. Sirurile nu trebuie sa se suprapuna, si în plus sirul dest trebuie sa aiba suficient spatiu pentru a pastra rezultatul. Functia strncat este similara, cu exceptia faptului ca numai primele n caractere din src se adauga la dest. Valoare returnata Functiile returneaza un pointer la sirul rezultat dest. Nume strcmp - compara doua siruri de caractere Declaratie int strcmp(const char *s1, const char *s2); Descriere Functia strcmp compara cele doua siruri s1 si s2. Valoare returnata Functia returneaza un întreg mai mic decât, egal cu, sau mai mare decât zero daca s1 este mai mic decât, coincide, respectiv este mai mare decât s2. Nume strchr, strrchr - localizeaza un caracter Declaratie char *strchr(const char *s, int c); char *strrchr(const char *s, int c); Descriere Functia strchr returneaza un pointer la prima aparitie a caracterului c în sirul s. Functia strrchr returneaza un pointer la ultima aparitie a caracterului c în sirul s. Valoare returnata Functiile returneaza un pointer la caracterul gasit sau NULL daca valoarea nu a fost gasita. Nume strstr - localizeaza un subsir Declaratie char *strstr(const char *sir, const char *subs); Descriere Functia strstr gaseste prima aparitie a subsirului subs în sirul sir. Caracterul terminator null nu este luat în considerare. Valoare returnata Functia returneaza un pointer la începutul subsirului, sau NULL daca subsirul nu este gasit. Nume strspn, strcspn - cauta un set de caractere într-un sir Declaratie unsigned strspn(const char *s, const char *acc); unsigned strcspn(const char *s, const char *rej); Descriere Functia strspn determina lungimea segmentului initial din s format în întregime numai cu caractere din acc. Functia strcspn determina lungimea segmentului initial din s format în întregime numai cu caractere care nu se gasesc în rej. Valori returnate Functia strspn returneaza pozitia primului caracter din s care nu se afla în acc. Functia strcspn returneaza pozitia primului caracter din s care se afla în rej. Biblioteca matematica 1) Functiile din prima categorie sunt declarate în <stdlib.h> Nume rand, srand - generarea numerelor pseudo-aleatoare Declaratie int rand(void); void srand(unsigned int seed); Descriere Functia rand returneaza un întreg pseudo-aleator între 0 si RAND_MAX (pentru majoritatea mediilor de programare C aceasta constanta este egala cu valoarea maxima cu semn reprezentabila pe un cuvânt al sistemului de calcul). Functia srand initializeaza generatorul cu valoarea seed pentru o noua secventa de valori întregi pseudo-aleatoare care vor fi returnate de rand. Aceste secvente se repeta daca srand se apeleaza cu aceeasi valoare seed. Se obisnuieste ca generatorul sa fie initializat cu o valoare data de ceasul sistemului de calcul, ca în exemplul de mai jos: #include <time.h> srand(time(NULL)); Valoare returnata Functia rand returneaza o valoare între 0 si RAND_MAX. Tot în fisierul <stdlib.h> sunt descrise si urmatoarele functii: int abs(int i); valoare absoluta long labs(long i); valoare absoluta int atoi(char *s); conversie din ASCII în întreg long atol(char *s); conversie din ASCII în întreg lung double atof(char *s); conversie din ASCII în dubla precizie Urmatoarele functii de conversie necesita o discutie detaliata: double strtod(char *str, char **end); conversie din ASCII în dubla precizie long strtol(char *str, char **end, int base); conversie din ASCII în întreg lung unsigned long strtoul(char *str, char **end, int base); conversie din ASCII în întreg lung fara semn Sirul de caractere str este convertit în reprezentare binara, ca si în cazul functiilor atoi, atol, atof. Pentru conversii de tip întreg se precizeaza si baza de numeratie folosita, care poate fi între 2 si 36. Pentru baze mai mari decât zece se folosesc litere mici sau mari. În plus, daca parametrul end indica o adresa valida (nu este null), la iesire primeste adresa primului caracter invalid din str, care nu respecta regulile de scriere a unei valori numerice de tipul asteptat. 2) Functiile din a doua categorie sunt declarate în <math.h> double fabs(double x); valoare absoluta double floor(double x); parte întreaga inferioara double ceil(double x); parte întreaga superioara double sqrt(double x); double sin(double x); sin(x) double cos(double x); cos(x) double tan(double x); tg(x) double asin(double x); arcsin(x) double acos(double x); arccos(x) double atan(double x); arctg(x) în [-pi/2,pi/2] double atan2(double y, double x); arctg(y/x) în [–pi,pi] double exp(double x); e^x double log(double x); ln(x) double pow(double x, double y); x^y double sinh(double x); sinh(x) double cosh(double x); cosh(x) double tanh(double x); tgh(x) double ldexp(double x, int e); x *2^e double fmod(double x, double y); x modulo y Functia fmod returneaza o valoare f definita astfel: x =a*y + f; a este o valoare întreaga (data de x/y) si 0 <= |f | < y; f are semnul lui x. Urmatoarele doua functii returneaza doua valori: una este valoarea returnata de functie (de tip double), si cealalta returnata prin intermediul unui argument de tip pointer la int respectiv double. double frexp(double x, int *e); Functia frexp desparte valoarea x în doua parti: o parte fractionara normalizata (f apartine intervalului [0.5,1)) si un exponent e. Daca x este 0 atunci f=0 si e=0. Valoarea returnata este f. double modf(double x, double *n); Functia modf desparte valoarea x în doua parti: o parte fractionara subunitara f si o parte întreaga n. Valorile f si n au acelasi semn ca si x. Valoarea returnata este f. Functii pentru timp si data calendaristica Functiile din aceasta categorie, împreuna cu tipurile si structurile de date folosite, sunt declarate în <time.h> Functia time Data si ora calendaristica se reprezinta în format compact printr-o valoare de tip time_t. Majoritatea mediilor de programare definesc acest tip ca un sinonim pentru unsigned long. Aceasta valoare se obtine prin apelul functiei time. time_t time(time_t *tims); Functia returneaza data si ora curenta în coordonate universale (UTC), care reprezinta numarul de secunde de la începutul erei Unix (1 ianuarie 1970, ora 0:00:00). Valoarea returnata este memorata la adresa indicata de argumentul tims, daca acesta nu este NULL. Daca argumentul tims este NULL, trebuie sa memoram valoarea returnata. Structura tm Functia gmtime O valoare de tip time_t poate fi defalcata pe componente si memorata într-o structura: struct tm { int tm_sec; /* secunde, între 0 si 59 */ int tm_min; /* minute, între 0 si 59 */ int tm_hour; /* ore, între 0 si 23 */ int tm_mday; /* ziua din luna, între 1 si 31 */ int tm_mon; /* luna, între 0 si 11 */ int tm_year; /* anul curent minus 1900 */ int tm_wday; /* ziua din saptamâna, duminica: 0 */ int tm_yday; /* ziua din an, între 0 si 365 */ int tm_isdst; /* optiunea daylight saving time */ }; Observatie. Alegerea numelui tm pentru aceasta structura a fost cât se poate de neinspirata. Programatorii trebuie sa fie deosebit de atenti ca, atunci când folosesc functii din aceasta categorie, sa nu foloseasca în nici un caz numele tm pentru definitii proprii. Functia gmtime returneaza adresa unei zone unde se afla data calendaristica defalcata. Informatiile din aceasta zona trebuie salvate în cazul în care se efectueaza prelucrari ulterioare. Un apel ulterior al functiei gmtime le va suprascrie, zona fiind alocata static în interiorul acesteia. struct tm *gmtime(const time_t *tims); Functia mktime time_t mktime(struct tm *datc); Aceasta functie efectueaza conversia inversa, de la o structura defalcata la o valoare compacta. Este suficient sa completam valorile tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec. Daca o valoare se afla în afara limitelor permise, acestea sunt automat normalizate. De exemplu, ora 25:00:00 este echivalata cu ora 1:00:00 a zilei urmatoare. Functia corecteaza (daca e nevoie) toate valorile structurii. Daca data calendaristica nu poate fi reprezentata ca o valoare de tip time_t, funcsia returneaza valoarea (time_t)(–1). Functiile ctime si asctime char *ctime(const time_t *tims); char *asctime(const struct *datc); Aceste functii convertesc data calendaristica în reprezentare ASCII. Aceste functii returneaza adresa unui sir de forma: "Sun Jun 05 10:00:00 2005" Informatiile din aceasta zona trebuie salvate în cazul în care se efectueaza prelucrari ulterioare. Un apel ulterior al functiei le va suprascrie, zona fiind alocata static în interiorul acesteia. Functia clock clock_t clock(void); Functia clock returneaza o aproximare a timpului pe care procesorul l-a folosit pentru program pâna la momentul apelului. Tipul clock_t este definit de majoritatea mediilor de programare ca un sinonim pentru unsigned long. Numarul de secunde de la lansarea programului se obtine astfel: (double)clock()/CLOCKS_PER_SECOND Constanta CLOCKS_PER_SECOND este specifica mediului de programare folosit. De exemplu, biblioteca GNU C Compiler pentru sistemul de operare Linux defineste valoarea 1000000. O consecinta a acestui fapt este ca pe un sistem de calcul pe 32 de biti functia clock va returna aceeasi valoare la aproximativ fiecare 72 de minute. Observatie. Standardul C nu impune ca aceasta cronometrare sa înceapa de la zero la lansarea programului. De aceea, pentru a garanta un maxim de portabilitate, cronometrarea se face astfel: main() { double stm; stm = clock(); . . . printf("Time:%.3lf\n",(clock()-stm)/ CLOCKS_PER_SECOND); } Unele sisteme de operare, de exemplu Linux, permit cronometrarea exacta a timpului de rulare a unui program (evident, cu limitarea la 72 de minute), incluzând aici si timpul ocupat de sistemul de operare pentru efectuarea unor operatii cerute de program. Nu este cronometrat timpul cât procesorul este ocupat cu rularea altui program. Executarea unei comenzi sistem Functia system, declarata în <stdlib.h>, ofera posibilitatea de a executa o comanda sub controlul programului. Nume system – executa o comanda a interpretorului de comenzi Declaratie system(char *com); Descriere Functia system executa comanda com prin lansarea interpretorului de comenzi cu acest parametru. Se recomanda folosirea cu atentie a acestei functii sub unele sisteme de operare (de exemplu Linux), daca interpretorul de comenzi permite precizarea mai multor comenzi într-o singura linie.

)

no comments!! nice site.ul!

Tutoriale: desktop development web development cloud development data development phone development game development Pentru detalii click aici: Link

e ceva in tara asta ce nu are interese politice? e de rau...

Un arbore binar de cautare(ABC) echilibrat AVL este un arbore in care in fiecare nod are proprietatea ca inaltimile subarborilor stang si drept difera cu cel mult 1. Avem 3 situatii posibile in acest nod, codificate cu valorile variabilei FactEch=(inaltimea subarborelui drept)-(inaltimea subarborelui stang), pe care o numim fator de echilibru, in felul urmator: FactEch= 1, daca h(left)=h(right)-1 0, h(left)=h(right) -1, daca h(left)=h(right)+1, unde h reprezinta inaltimea, left si right=subarborele stang, respectiv subarborele drept In vederea echilibrarii arborelui vom folosi functii de rotatie, in functie de valoarea factorului de echilibru. Un exemplu finalizat cu desene si explicatii pentru fiecare rotatie- aici: Link sau aici: Link #include<stdio.h> #include<malloc.h> #define F 0 #define T 1 struct nod{ char info; int FactEch; struct nod *st; struct nod *dr; }; struct nod *inserare( char , struct nod * , int * ); void listare(struct nod * , int ); struct nod *echilibrare_dr(struct nod * , int * ); struct nod *echilibrare_st(struct nod * , int * ); struct nod *sterge(struct nod * , struct nod * , int * ); struct nod *sterge_element(struct nod * , char , int * ); struct nod *inserare(char info, struct nod *tata, int *H) { struct nod *nod1; struct nod *nod2; if(!tata) { tata=(struct nod*)malloc(sizeof(struct nod)); tata->info=info; tata->st=NULL; tata->dr=NULL; tata->FactEch=0; *H=T; return tata; } if(info<tata->info) { tata->st=inserare(info, tata->st, H); if(*H) //creste inaltimea subarborelui stang { switch(tata->FactEch) { case 1: //subarborele drept este mai inalt tata->FactEch=0; *H=F; break; case 0: //subarbore echilibrat tata->FactEch=-1; break; case -1: //subarborele stang mai inalt nod1=tata->st; if(nod1->FactEch==-1) { printf("Rotatie simpla la dreapta \n"); tata->st=nod1->dr; nod1->dr=tata; tata->FactEch=0; tata=nod1; tata->FactEch=0; } else //cazul nod1->FactEch==0 nu este posibil pentru ca am fi avut *h=1 //ramane nod1->FactEch==1 { printf("Rotatie dubla la dreapta \n"); nod2=nod1->dr; nod1->dr=nod2->st; nod2->st=nod1; tata->st=nod2->dr; nod2->dr=tata; if(nod2->FactEch==-1) tata->FactEch=1; else if(nod2->FactEch==1) nod1->FactEch=-1; else nod1->FactEch=0; tata=nod2; } tata->FactEch=0; *H=F; } } } if(info>tata->info) { tata->dr=inserare(info, tata->dr, H); //subarborele drept devine mai inalt switch(tata->FactEch) { case -1: //subarborele stang este mai inalt tata->FactEch=0; *H=F; break; case 1: //subarborele drept este mai inalt nod1=tata->dr; if(nod1->FactEch==1) { printf("Rotatie simpla la stanga \n"); tata->dr=nod1->st; nod1->st=tata; tata->FactEch=0; tata=nod1; tata->FactEch=0; } else //cazul nod1->FactEch==0 nu este posibil pentru ca am fi avut *H=F //ramane nod1->FactEch==-1 { printf("Rotatie dubla la stanga \n"); nod2=nod1->st; nod1->st=nod2->dr; nod2->dr=nod1; tata->dr=nod2->st; nod2->st=tata; if(nod2->FactEch==1) tata->FactEch=-1; else if(tata->FactEch==1) nod1->FactEch=1; else nod1->FactEch=0; tata=nod2; } tata->FactEch=0; *H=F; } } return tata; } void listare(struct nod *arbore, int nivel) { int i; if(arbore) { listare(arbore->dr, nivel+1); printf("\n"); for(i=0; i<nivel; i++) printf(" "); printf("%c", arbore->info); listare(arbore->st, nivel+1); } } struct nod *echilibraredreapta(struct nod *tata, int *H) { struct nod *nod1, *nod2; switch(tata->FactEch) { case 1: tata->FactEch=0; break; case 0: tata->FactEch=1; *H=F; break; case -1: //re echilibrare nod1=tata->dr; if(nod1->FactEch>=0) { printf("Rotatie simpla la stanga \n"); tata->dr=nod1->st; nod1->st=tata; if(nod1->FactEch==0) { tata->FactEch=1; nod1->FactEch=-1; *H=F; } else { tata->FactEch=nod1->FactEch=0; } tata=nod1; } else { printf("Rotatie dubla la stanga \n"); nod2=nod1->st; nod1->st=nod2->dr; nod2->dr=nod1; tata->dr=nod2->st; nod2->st=tata; if(nod2->FactEch==1) tata->FactEch=-1; else tata->FactEch=0; if(nod2->FactEch==-1) nod1->FactEch=1; else nod1->FactEch=0; tata=nod2; nod2->FactEch=0; } } return tata; } struct nod *echilibrarestanga(struct nod *tata, int *H) { nod *nod1, *nod2; switch(tata->FactEch) { case 1: tata->FactEch=0; break; case 0: tata->FactEch=-1; *H=F; break; case -1: //re echilibrare nod1=tata->st; if(nod1->FactEch<=0) { printf("Rotatie simpla la dreapta \n"); tata->st=nod1->dr; nod1->dr=tata; if(nod1->FactEch==0) { tata->FactEch=-1; nod1->FactEch=1; *H=F; } else{ tata->FactEch=nod1->FactEch=0; } tata=nod1; } else { printf("Rotatie dubla la dreapta\n"); nod2=nod1->dr; nod1->dr=nod2->st; nod2->st=nod1; tata->st=nod2->dr; nod2->dr=tata; if(nod2->FactEch==-1) tata->FactEch=1; else tata->FactEch=0; if(nod2->FactEch==1) nod1->FactEch=-1; else nod1->FactEch=0; tata=nod2; nod2->FactEch=0; } } return tata; } //inlocuieste informatia nodului temp in care a fost gasita cheia cu informatia celui mai din dreapta descendent al lui r(pe care apoi il sterge struct nod *sterge(struct nod *r, nod *temp, int *H) { nod *dnod=r; if(r->dr!=NULL) { r->dr=sterge(r->dr, temp, H); if(*H) r=echilibrarestanga(r, H); } else { dnod=r; temp->info=r->info; r=r->st; free(dnod); *H=T; } return r; } //sterge element cu cheia respectiva din arbore struct nod *stergeelement(struct nod *tata, char info, int *H) { nod *temp; if(!tata) { printf("Informatia/nodul nu exista \n"); return tata; } else { if(info<tata->info) { tata->st=stergeelement(tata->st, info, H); if(*H) tata=echilibraredreapta(tata, H); } else if(info>tata->info) { tata->dr-stergeelement(tata->dr, info, H); if(*H) tata=echilibrarestanga(tata, H); } else { temp=tata; if(temp->dr==NULL) { tata=temp->st; *H=T; free (temp); } else if(temp->st==NULL) { tata=temp->dr; *H=T; free (temp); } else { temp->st=stergeelement(temp->st, info, H); if(*H) tata=echilibraredreapta(tata, H); } } } return tata; } void main() { int H; char info; char choice; struct nod *arbore=(struct nod* )malloc(sizeof(struct nod)); arbore=NULL; printf("Tastati 'b' pentru terminare: \n"); choice=getchar(); while(choice!='b') { fflush(stdin); printf("Informatia nodului (tip caracter: a, b, 1, 2, etc.): \n"); scanf("%c", &info); arbore=inserare(info, arbore, &H); printf("Arborele este: \n"); listare(arbore, 1); fflush(stdin); printf("Tastati 'b' pentru terminare: \n"); choice=getchar(); } fflush(stdin); while(1) { printf("Introduceti cheia pe care vreti sa o stergeti: \n"); scanf("%c", &info); if(info=='b') break; arbore=stergeelement(arbore, info, &H); printf(" Arborele este: \n"); listare(arbore, 1); } }

Un arbore binar ale carui chei iau valori de un tip total ordonat sn. arbore binar de cautare(ABC) daca cheia fiecarui nod este mai mare decat orice cheie din fiul sau stang si mai mica decat orice cheie din fiul drept. Arborii binari sunt special conceputi pentru a imbunatati operatia de cautare a unei chei. Prezint mai jos un algoritm de cautare ce returneaza un pointer catre minimul si maximul dintr-un ABC. Pentru parcurgerea arborelui in folosim SRD si SDR, prezentate la Metodele de parcurgere a arborilor. OBS: minimul se gaseste in subarborele stang, iar maximul se gaseste in subarborele drept. #include<stdio.h> #include<conio.h> //pointeri la minimul si maximul unui ABC struct arb { int info; arb*st,*dr; //st=stanga, dr=dreapta }; //functia de inserare void inserare(arb *&r,int k) { arb *pp; if (!r) { pp=new arb; //aloca spatiu ptr noul nod pp->info=k; pp->st=NULL; pp->dr=NULL; r=pp; } else if (r->info>k) inserare(r->st,k); else if (r->info<k) inserare(r->dr,k); else printf("Elementul deja exista! \n"); } void SRD(arb *pp) { if (pp) { SRD(pp->st); printf(" %d ",pp->info); SRD(pp->dr); } } void SDR(arb *pp) { if (pp) { SDR(pp->st); SDR(pp->dr); printf(" %d ",pp->info); } } int minim(arb *r) { if(r->st!=NULL) return minim(r->st); else return r->info; //minimul se gaseste in sub. stang } int maxim(arb *r) { if(r->dr) return maxim(r->dr); else return r->info; //maximul se gaseste in sub. drept } int main() { arb *root=NULL,*p; int min,max; int nr; printf("Radacina: "); //se citeste radacina scanf("%d",&nr); while (nr!=0) //daca este diferita de 0, se continua prin citirea nodurilor { inserare(root,nr); printf("Valoare noua:"); scanf("%d",&nr); } SRD(root); min=minim(root); printf("\n\nMinimul este: "); printf("%d", min); SDR(root); max=maxim(root); printf("\n\nMaximul este: "); printf("%d", max); getch(); return 0; }

1. Merge-sort //Merge-sort este la fel ca si Quick-sort, o metoda eficienta de sortare. Se procedeaza astfel: //se sorteaza recursiv(crescator) prima jumatate a vectorului, apoi se sorteaza recursiv(crescator) csi a doua jumatate a vectorului. //urmeaza faza de combinare a solutiilor, adica constructia vectorului ordonat pe baza a doi vectori ordonati. //vom construi un alt vector b, vectorul ordonat rezultat din cele doua parti si il vom copia in a, in pozitiile corespunzatoare. #include<iostream.h> #include<conio.h> int a[20],n; //se realizeaza o functie pentru interclasare void interclasare(int i, int m, int j) { int b[20]; //vectorul initial se imparte in doua secvente, aceasta se imparte la randul ei, s.a. pana se ajunge la doua elemente, care se compara //dupa interclasarea celor doua, se executa procesul ptr urmatoarele elemente, s.a. int x=i; int k=1; int y=m+1; while(x<=m && y<=j) if (a[x]<a[y]) b[k++]=a[x++]; else b[k++]=a[y++]; while (x<=m) b[k++]=a[x++]; while (y<=j) b[k++]=a[y++]; int t=i; for (k=1;k<=(j-i)+1;k++) a[t++]=b[k]; } void div_imp(int i, int j) { if (i<j) { int m=(i+j)/2; //se alege mijlocul div_imp(i,m); div_imp(m+1,j); interclasare(i, m, j); } } void main() { cout<<"n="; cin>>n; for(int i=1;i<=n;i++) { cout<<"a["<<i<<"]="; cin>>a[i]; } div_imp(1,n); for(int i=1;i<=n;i++) cout<<a[i]<<" "; getch(); } Pentru a stabili complexitatea algoritmului de sortare prin interclasare, remărcam urmatoarele: - pentru un tablou cu n elemente, numărul de înjumătăţiri succesive până se ajunge la zone de lungime 1 sau 2 este de aproximativ log2n; - la fiecare din aceste divizări succesive, se mută din tab în tab1 şi invers în total n elemente. In consecinta, numarul de operatii elementare executate este de ordinul O(n.log(n)). Mai riguros, daca notam cu C(n) numarul de operaţii elementare pentru sortarea unui tablou cu n componente şi avem în vedere că, la fiecare pas al algoritmului, se fac doua invocări recursive ale metodei de sortare şi o interclasare, iar interclasarea are complexitatea n, atunci C(n) = 2.C(n/2)+n Continuând acest raţionament, putem scrie C(n) = 2(2C(n/4)+n/2)+n = 4C(n/4) + n + n Algoritmul se opreşte după log2(n) astfel de paşi, când se obţine C(n) = nC(n/n) + n + n + ... + n = n.log2(n) In consecinţă, complexitatea algoritmului de sortare prin interclasare este O(n.log2(n)). Constatăm deci că, pentru tablouri cu numar mare de componente, timpul de calcul este mult mai mic în cazul sortării prin interclasare, decât în cazul folosirii algoritmilor simpli, cum ar fi cel al selecţiei, inserţiei sau al bulelor, a căror complexitate este O(n2). Algoritmul de sortare prin interclasare consumă însă de două ori mai multă memorie decât cei simpli mentionaţi, deoarece necesită spaţiu suplimentar pentru tabloul auxiliar . 2. Quicksort //Ordonarea Quick-sort este celebra si una dintre metodele performante de sortare. //Ideea algoritmului este simpla: in vectorul cu capetele inf...sup alegem un element numit pivot si apoi rearanjam elementele vectorului astfel incat in stanga sa se grupeze elemente mai mici sau egale cu pivotul, iar la dreapta elemente mai mari decat pivotul. //in implementare vom alege ca pivot primul element al vectorului, apoi vom folosi doua variabile contor i si j cu care ne deplasam spre dreapta, resp. stanga. //apoi amplasam pivotul pe pozitia dintre cei doi subvectori care se formeaza si apelam quick_sort pentru acestia. //Procesul recursiv se executa doar daca cele doua limite sunt diferite. #include<iostream.h> #include<conio.h> int a[20], n; void quick_sort(int *a, int inf, int sup) //inf si sup sunt capetele vectorului { if(inf<sup) { int pivot=a[inf]; //se alege un pivot, int aux; int i=inf+1, j=sup; //re-aranjam elementele vectorului astfel incat in stanga sa se grupeze elementele mai mici sau egale cu pivotul, iar la dreapta elementele mai mari decat pivotul. //pivotul se alege defapt primul element al vectorului. //cu i si j ne deplasam la dreapta, resp. la stanga. while(i<=j) { while(i<=sup && a[i]<=pivot) i++; while(j>=inf && a[j]>pivot) j--; if(i<j && i<=sup && j>=inf) { aux=a[i]; a[i]=a[j]; a[j]=aux; } } i--; a[inf]=a[i]; a[i]=pivot; //amplasam pivotul pe pozitia dintre cei doi subvectori care se formeaza(unul cu elemente mai mici sau egale, unul cu elemente mai mari) quick_sort(a, inf, i-1); //si apelam quick_sort pentru acestia. quick_sort(a, i+1, pivot); } } void afisare() { int i; cout<<"vectorul sortat este: "; for(i=0; i<n; i++) cout<<a[i]<<" "; } void main() { int i; cout<<"n="; cin>>n; for(i=0; i<n; i++) { cout<<"a["<<i<<"]="; cin>>a[i]; } quick_sort(a, 0, n-1); afisare(); getch(); } Pentru a stabili complexitatea algoritmului Quick Sort aplicată unui tablou cu n componente, notăm cu C(n) numărul de comparaţii efectuate şi remarcăm că, la fiecare pas al algoritmului au loc n comparaţii însoţite de interschimbări ale elementelor şi două invocari recursive ale metodei de sortare, deci C(n) = n + C(k)+C(n-k) unde k este numărul de componente din zona din stânga a tabloului, iar C(k) si C(n-k) sunt complexităţile pentru cele două subzone care urmează a fi sortate recursiv. Situaţia este asemanatoare cu cea întalnită în cazul metodei MergeSort, cu deosebirea că, în acest caz, tabloul nu se mai împarte în două părţi egale. Cazul cel mai favorabil ar fi când, la fiecare recursie, cele două subzone (cu elemente mai mici şi respectiv mai mari decat elementul pivot) ar fi egale. În acest caz, calculul complexităţii se face la fel ca la MergeSort şi deci complexitatea este O(n.log(n)). Cazul cel mai defavorabil ar fi cel în care, la fiecare recursie, elementul pivot ar fi ales în mod atat de nefericit, încat una din cele două subzone obţinute după interschimbări ar fi vida. In acest caz C(n) = n + C(n-1) = n + (n-1) + C(n-2) = ... sau, continuand pana la C(1) C(n) = n + (n-1) + (n-2) + ... + 1 = (n+1)n/2 şi deci complexitatea algoritmului este O(n2). Acest caz "nefericit" este însă foarte puţin probabil. Cel mai probabil este că, în realitate, complexitatea sa fie situată în jurul valorii O(n.log(n)). 3. Heapsort #include<iostream.h> #include<conio.h>. //functia reconstituie_heap: //datele de intrare sunt un vector A si un indice //nodurile stang(i) si drept(i) sunt heap-uri //dar cum elementul A[i] poate fi mai mic decat descendantii sai, este posibil ca acesta sa nu //respecte proprietatea de heap. //aceasta functie face ca subarborele care are radacina in valoarea elementului de indice i, //sa devina heap. void reconstituie_heap(int *A, int i, int dimensiune) { int a, maxim, stang=2*i+1, drept=stang+1; if(stang<dimensiune && A[stang]>A[i]) maxim=stang; else maxim=i; if(drept<dimensiune && A[drept]>A[maxim]) maxim=drept; if(!maxim==i) { a=A[i]; A[i]=A[maxim]; A[maxim]=a; reconstituie_heap(A, maxim, dimensiune); } } //functia construieste_heap: //toate elementele subsirului A[[n/2]+1...n] sunt frunze, ele pot fi considerate heap-uri //formate din cate un element. //functia traverseaza restul elementelor si executa functia reconstituie_heap pentru fiecare nod //intalnit. //ordinea de prelucrare a nodurilor satisface cerinta ca subarborii, avand ca radacina //descendenti ai nodurilor i sa formenze heap-uri inainte ca reconstituie_heap sa fie executat //pentru aceste noduri. void construieste_heap(int *A, int dimensiune) { int i; for(i=(dimensiune-2)/2; i>=0; i--) reconstituie_heap(A, i, dimensiune); } void heapsort(int *A, int dimensiune) { int i, temp; construieste_heap(A, dimensiune); for(i=dimensiune-1; i>=1; i--) { temp=A[i]; A[i]=A[0]; A[0]=temp; dimensiune=dimensiune-1; reconstituie_heap(A, 0, dimensiune); } } void main() { int n, A[50]; cout<<"n="; cin>>n; int i; for(i=0; i<n; i++) { cout<<"A["<<i<<"]="; cin>>A[i]; } heapsort(A,n); cout<<"sirul sortat este: "; for(i=0; i<n; i++) cout<<A[i]<<" "; getch(); } Complexitatea algoritmului este O(nlog(in baza 2)n). 4. Shellsort //Shellsort //Sortarea cu micsorarea incrementului este o extensie simpla al insertion sortului care castiga viteza permitand schimbarea elementelor aflate departe. //Ideea de baza o constituie rearanjarea elementelor din vector in asa fel incat, luand fiecare element (incepand de oriunde), sa obtinem o tabela sortata. //Astfel spunem ca vectorul a este sortat. #include<iostream> using namespace std; int a[1001],n; void shellsort(int a[1001],int n) { int j,i,m,aux; for(m = n/2;m>0;m/=2) { for(j = m;j<=n;j++) { for(i=j-m;i>=0;i-=m) { if(a[i+m]>=a[i]) break; else { aux = a[i]; a[i] = a[i+m]; a[i+m] = aux; cout<<"S-a efectuat o interschimbare : a["<<i<<"] = "<<a[i] <<" cu a["<<i+m<<"] = "<<a[i+m]; cout<<"Starea vectorului este : "; for(int h=1;h<=n;h++) cout<<a[h]<<' '; } } } } } void main () { int i; cout<<"n="; cin>>n; cout<<"\nVectorul Nesortat este: "; for(i=1;i<=n;i++) cin>>a[i]; shellsort(a,n); cout<<"\n\n\nVectorul sortat este: "; for(i=1;i<=n;i++) cout<<a[i]<<" "; } Complexitatea algoritmului: 1. Cazul cel mai favorabil când vectorul e sortat crescǎtor: omega(n); 2. Cazul cel mai nefavorabil când vectorul e sortat descrescǎtor: O(n2). 5. Selective sort Acest algoritm selecteaza la fiecare pas i cel mai mic element din vectorul de la pasul i+1 pana la n. Valoarea minima de la pasul i este pusa in vector la pozitia i, facandu-se interschimbarea cu vectorii mari; in majoritatea cazurilor oferind rezultate mai slabe decat insertion sort. void selective(int a[],int n) { int i,aux,min,minat; for(i = 0; i < n - 1;i++) { minat = i; min = a[i]; for(j = i + 1;j < n;j++) //selectam minimul din vectorul ramas( de la i+1 la n) { if(min > a[j]) //sortare crescatoare { minat = j; //pozitia elementului minim min = a[j]; } } aux = a[i] ; a[i] = a[minat]; //interschimbare a[minat] = aux; } } 6. Insertion sort Sortarea prin insertie seamana oarecum cu sortarea prin selectie. Tabloul este impartit imaginar in doua parti - o parte sortata si o parte nesortata. La inceput, partea sortata contine primul element al tabloului si partea nesortata contine restul tabloului. La fiecare pas, algoritmul ia primul element din partea nesortata si il insereaza in locul potrivit al partii sortate. Cand partea nesortata nu mai are nici un element, algoritmul se opreste. void insertion(int a[], int n) { int i, j, aux; for (i = 1; i < n; i++) { j = i; while (j > 0 && a[j - 1] > a[j]) { aux = a[j]; a[j] = a[j - 1]; a[j - 1] = aux; j--; } } }

1. Cautarea secventiala in tabloul ordonat Fie v sortat crescator v1<=v2<=...<=vn La compararea unui element vi u k avem urmatoarele 3 situatii: 1. vi=k, algoritmul se incheie, cautarea cu succes 2. vi>k, algoritmul se incheie, cautare fara succes 3. vi<k, se continua cautarea daca i<=n #include<iostream.h> #include<conio.h> int v[20], n, i, k, gata, gasit, int, aux; void sortare() { do{ ind=0; for(i=1; i<=n-1; i++) { if(v[i]>v[i+1]) { aux=v[i]; v[i]=v[i+1]; v[i+1]=aux; ind=1; } } } while(ind!=0); } void afisare() { for(i=1; i<=n; i++) cout<<v[i]<<" "; } void main() { cout<<"dati nr de elemente ale vectorului: "; cin>>n; for(i=1; i<=n; i++) { cout<<"v["<<i<<"]="; cin>>v[i]; } sortare(); cout<<"vectorul sortat este: "; afisare(); cout<<endl<<"dati valoarea pe care o caut: "; cin>>k; gata=0; gasit=0; i=1; while(i<=n && !gata) { if(v[i]==k) { gata=1; gasit=1; } else if(v[i]>k) gata=1; else i++; } if(i>n || !gasit) cout<<"valoarea data nu se alfa in vector"; else cout<<"valoarea data se afla in vector"; getch(); } 2.Cautarea binara(caz in care tabloul este ordonat)-var. recursiva #include<iostream.h> #include<conio.h> int v[20], n, k, c; void citire() { int i; cout<<"Elementele sirului in ordine crescatoare: "; cout<<"v[i]="; cin>>v[1]; for(i=2; i<=n; i++) do{ cout<<"v["<<i<<"]="; cin>>v[i]; }while(v[i]<=v[i-1]; } void afisare() { int i; for(i=1; i<=n; i++) cout<<v[i]<<" "; } int cautare(int k, int inf, int sup) { int mij; //mijlocul //inf=capatul de inceput //sup=sfarsitul if(inf<=sup) { mij=(inf+sup)/2; if(v[mij]==k) return mij; //a gasit valoarea data pe pozitia mij else if(v[mij]>k) cautare(k, inf, mij-1); //cauta in partea din stanga else cautare(k, mij+1, sup); //cauta in partea din dreapta } else return 0; } void main() { do{ cout<<"dati nr de elemente ale vectorului: "; cin>>n; }while(n<1 || n>20); citire(); cout<<"vectorul dat: "; afisare(); cout<<endl<<"dati valoarea pe care o caut: "; cin>>k; c=cautare(k, 1, n); if(c==0) cout<<"valoarea data nu se afla in sir"; else cout<<"valoarea se gaseste in sir"; getch(); 3.Cautarea secventiala- nu se specifica nimic despre elementele vectorului v #include<iostream.h> #include<conio.h> void main() { int v[20], n, i, k; cout<<"dati nr de elementle ale vectorului: "; cin>>n; for(i=1; i<=n; i++) { cout<<"v["<<i<<"]="; cin>>v[i]; } cout<<endl<<"dati valoarea pe care o caut: "; cin>>k; i=1; while(i<=n && v[i]!=k) i++; if(i<=n) cout<<"valoarea se afla in sir"; else cout<<"valoarea nu se gaseste in sir"; getch(); }

dragut site.ul...

recomand sa mentii sistemul de operare updatat, AV-ul (Kaspersky) si antispyware-ul mereu active.

decat v.ati "certa" p aici , mai degraba ati face ceva util...parerea mea...de exemplu unii colegi au nevoie d ajutor(mts33, mao, mafios_X) .ps: nu prea tine de domeniu meu , asa ca <rog> sa le dea un raspuns cine stie mai bine!

dap..e super what can i say?bafta la invatat!!

Cauta un msa.exe, sau mai simplu cu task manager, e un virus..daca nu.l ai incearca sa re.activezi def:task manager>services tab>right click windefend.>select start device, sau din msconfig.. Sau run>regedit.exe>hkey_local_machine\software\policies\microsoft\windows defender si sp.mi ce setari ai acolo

Uneori chiar si o simpla scanare<boot scan>cu AV.ul nu e destul de eficienta..de ex la avast, un boot scan nu detecteaza nimic grav, si ai nevoie d MBAM si OTS, in urma carora afli daca ai un virus serios sau nu...acum depinde d ce antivirus ai.

me too

salut. la Device Manager>>Universal Serial Bus Controllers>>USB Root Hub>>Power Management, incearca sa debifezi tot: "allow the computer to turn off this device to save power". ptr vista, gasesti device manager in control panel, ptr XP: in control panel>>system>>hardware>>device manager. alta idee nu am

LA MULTI ANI, CORI!

as vrea sa pot ajuta, dar nu prea am timp, asa ca nu ma implic mai mult de atat...ii sustin pe cei care cred ca pot fi moderatori si merita.

Exista sau nu Virusi pe Linux? ei bine, desi multa lume spune: "nu, pe Linux nu exista virusi!", adevarul este ca exista. Linux, Unix şi alte Unix-like sisteme de operare sunt în general considerate ca fiind foarte bine protejate - dar nu imune - la viruşi de calculator. Malware-ul de Linux include viruşi, troieni, viermi şi alte tipuri de malware care afecteaza Sistemul de Operare Linux. Linux oferă o protecţie mai bună în comparaţie cu Microsoft Windows. Linux-ul nu este, inca, amenintat la o scara asa mare precum Windows. Totusi numărul de programe malware - inclusiv virusi, troieni, şi a altor ameninţări - special scris pentru Linux a fost în creştere în ultimii ani şi s-au dublat ca numar ,de la 422 la 863, dar sigur sunt in continua crestere. Voi enumera(partial) mai jos, cateva ameninţări cunoscute ale Linux: 1.Troieni: Kaiten = Cal Troian Linux.Backdoor Rexob = Cal trojan Linux.Backdoor Waterfall = backdoor screensaver - pe gnome-look.org 2.Viermi: Adm-Net = LinuxWorm Adora Cheese Devnull Kork Lupper Lion (cunoscut si ca Ramen) Mighty Ramen Slapper SSH Bruteforce 3.Virusi: 42 Arches Alaeada Bad Bunny Binom Bliss Brundle Diesel Kagob MetaPHOR (cunoscut si ca Simile) OSF.8759 RST Staog Vit Winter Winux (cunoscut si ca Lindose si PEElf) ZipWorm Solutii anti-virus pentru computerele pe care ruleaza Linux: ClamAV (free software) Avast! (versiuni freeware si comerciala) AVG (versiuni freeware si comerciala) Eset (versiune comerciala) Sophos (proprietar) Avira (versiuni freeware si comerciala)

n.am de unde sa stiu 100% cum sunt site.urile, doar ca informatiile sunt "dubioase", asa ca si unele site.uri sunt pe masura.

what?no AV?cum rezistati?mie mi.a crapat windows.ul si cu antivirus, da' nu stiu fara cum ar fi

problema rezolvata, era d ajuns un: http://www.google.ro/firefox?client=firefox-a&rls=org.mozilla:en-US:official la home page. sper sa fie d folos si celor care mai au probl asta.

am o mica/mare probl: de la home page>>mozilla, click>>search apare yahoo ..am incercat toate metodele posibile sa scap d ea..chiar si p aia cu remove>>yahoo toolbar>> din control panel si tot nu merge ma calca serios p nervi, si nici macar la add-ons>>extensions nu apare ca sa.i dau uninstall d acolo..alte idei sunt bine venite as putea sa pun la home page>>http://google.ro, dar nu vreau sa renunt la pagina cu mozilla