Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Informatică și Ingineria Sistemelor

RAPORT
Lucrarea de laborator nr. 4 la
Programarea Calculatoarelor

A efectuat: st. gr. RM-201

Grosu Maxim

A verificat Ștefan Stratulat

Chişinău ,2020
 Lucrarea de laborator nr. 4

________________________________

_________________________________
Varianta nr.7
Sa se sorteze liniile tabloului in ordine descendenta cu ajutorul
metodei bulelor
Mersul lucrării:
Noțiuni din teorie și metodele de lucru folosite:

Tablourile, la fel ca si variabilele pot fi initializate in trei moduri:

 Prin introducerea datelor de la tastatura

 Prin declararea acestuia global – toate elementele vor fi zero
  Imediat dupa declararea acestora 

Cele trei funcţii de alocare (malloc, calloc și realloc) au ca rezultat adresa zonei de

memorie alocate (de tip void*) şi ca argument comun dimensiunea, în octeţi, a zonei de
memorie alocate (de tip size_t ). Dacă cererea de alocare nu poate fi satisfăcută pentru că
nu mai există un bloc continuu de dimensiunea solicitată, atunci funcţiile de alocare au
rezultat NULL (ce reprezintă un pointer de tip void * la adresa de memorie 0, care prin
convenţie este o adresă nevalidă - nu există date stocate în acea zonă).

Descrierea variabilelor:

a) Date de intrare:n,i

b) Date de ieşire: n

!Rezultatele vor fi afișate pe ecran.

Codul Programului in C :

#include<stdio.h>
#include<stdlib.h>
float **Alocarea_dinamica (int x,int y);
 void Introducerea_elementelor(float **P,int x,int y);
void Completarea_aleatorie(float **P,int x,int y);
void Sortare_elementelor(float **P,int x,int y);
void Afisarea_tabloului(float **P, int x, int y);
void Eliberarea_memorie(float **p, int x);
int main(void)
{
int x,y,a,i;
float **P;
printf("Dati numarul de linii si coloane : ");
scanf ("%d %d", &x, &y);

while(1)
{
printf("\n1.Evidentierea memoriei.\n");
printf("2.Introducerea masivului la tastatura.\n");
printf("3.i\Inplerea rindului cu elemente random.\n");
printf("4.Sortarea elementelor tabloului.\n");
printf("5.Afisarea elementelor tabloului la ecran.\n");
printf("6.Eliberarea memoriei alocate pentru tablou.\n");
printf("0.Iesire din program.\n");
scanf("%d",&a);
switch (a)
{
case 1:
P = Alocarea_dinamica (x, y);
break;
case 2:
Introducerea_elementelor(P, x, y);
break;
case 3:
Completarea_aleatorie(P, x, y);
printf("\nProcedura de completare cu elemente aleatorii a fost efectuata\n\n");
break;
case 4:
Sortare_elementelor(P, x, y);
break;
case 5:
Afisarea_tabloului(P, x, y);
break;
case 6:
 Eliberarea_memoriei(P,x);
P=NULL;
printf("\nProcedura de eliberare a memoriei a fost efectuata\n\n");
break;
case 0:
printf("\nIesire din program\n");
return 0;
default :
printf("Numărul nu se regaseste in lista\n\n");
}
}
return 0;
}
float** Alocarea_dinamica (int x,int y)
{
int i;
float **P;
P=(float**)malloc(x*sizeof(float*));
for(i=0; i<x; i++)
{
P[i]=(float*)malloc(y*sizeof(float));
}
if (P==NULL)
{
printf("Procedura de alocare a memoriei nu a avut loc\n\n");
}
else
{
printf("Procedura de alocare a memoriei a avut loc \n\n");
}
return P;
}
void Introducerea_elementelor(float **P,int x,int y)
{
int i,j;
for(i=0; i<x; i++)
{
for(j=0; j<y; j++)
{
printf("P[%d][%d]=",i,j);
scanf("%f",&P[i][j]);
 }
}
}
void Completarea_aleatorie(float **P, int x,int y)
{
srand(time(NULL));
int i,j;
for(i=0; i<x; i++)
{
for(j=0; j<y; j++)
{
P[i][j]=rand() % 100-rand()%100;
}
}
printf("\n Matricea obtinuta este :\n");
for (i=0; i<x; i++)
{
for (j=0; j<y; j++)
{
printf("%f\t", P[i][j]);
}
}
printf("\n");
}
void Sortare_elementelor (float **P,int x,int y)
{
int i,j,c,t;
for (i=0; i<x-1; i++){
for (c=0; c<y; c++){
for (j=0; j<y-1; j++){
do {
t = P[c][j];
P[c][j] = P[c][j+1];
P[c][j+1] = t;
} while (P[c][j]>P[c][j+1]);
}
}
}

printf("\nOperatiunea de sortare a tabloului a avut loc \n");

}
 void Afisarea_tabloului(float **P, int x, int y)
{
int i,j;
printf("\nForma tabloului este :\n\n");
for(i=0; i<x; i++)
{
for(j=0; j<y; j++)
{
printf("%.f\t",P[i][j]);
}
printf("\n");
}
}
void Eliberarea_memoriei(float **P,int x)
{
int i;
for (i=0; i<x; i++)
free(P[i]);
free(P);
return;
}Concluzii:

În final pot spăune că în urma efectuării lucrării de laborator numărul doi am studiat
posibilitățile și mijloacele limbajului C pentru programarea algoritmilor cu structură
ramificată și ciclică la prelucrarea tablourilor unidimensionale. Am învățat că accesul
fiecărui element al tabloului se face prin numele acestuia urmat între paranteze
drepte [ ] de indicele sau (adică poziția pe care acesta o ocupă în tablou) În limbajul
C,indicii tablourilor încep numărătoarea de la 0 și se termină la (N–1) (unde N este
numărul total de elemente). Am determinat valoarea maximală negativă dintre
elementele tabloului și poziția primului element cu această valoare , precum și
numărul elementelor pozitive în tablou.