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

Universitatea Tehnică a Moldovei

Departamentul Informatica și Ingenieria Sistemelor

RAPORT
Lucrarea de laborator nr.1
la Structuri de date și algoritmi

A efectuat:
st. gr. C-171 V.Ciubotaru
A verificat:
dr., conf.univ. M. Kulev

Chişinău -2018
 Lucrarea de laborator nr.1

Tema: Implementarea tipului de date abstract “Tablou de structuri” în C

Scopul lucrării: Obținerea deprinderilor practice de implementare a unui tip de date abstract
(TDA) în limbajul C si anume a TDA “Tablou de structuri”

Condiţia problemei (sarcina de lucru) : De scris trei fisiere in limbajul C pentru implementarea (2
fisiere) si utilizarea (1 fisier – program cu functia main ) a TDA “Tablou de structuri”:
1. Fişierul antet cu extensia .h care descrie structura elementului tabloului (după varianta) şi
prototipurile funcţiilor care asigură operaţiunile de prelucrare a tabloului de structuri.
2. Fişier cu extensia .cpp (sau .c) care conţine codurile (implementările) tuturor funcţiilor declarate în
fişierul antet.
3. Fişierul utilizatorului - programul cu funcţia main () pentru prelucrarea tabloului de structuri cu
afişarea meniului de opţiuni pe ecran, si anume: alocarea memoriei dinamice pentru tablou, introducerea
informaţiei despre elementele tabloului de la tastatura, afişarea informaţiei despre elementele tabloului pe
ecran, căutarea elementului tabloului dupa unui cimp al structurei, modificarea câmpurilor elementului
tabloului, interschimbarea a 2 elemente tabloului, sortarea elementelor tabloului dupa unui cîmp,
adaugarea unui element nou la sfirsitul tabloului, adaugarea unui element nou la îinceputul tabloului,
inserarea unui element nou în tabloul la pozitia indicată, stergerea unui element al tabloului, scrierea
informaţiei despre elementele tabloului in fişier, citirea informaţiei despre elementele tabloului din fişier,
eliberarea memoriei alocate pentru tablou, ieşire din program.

Varianta 7: Disciplina
Analiza datelor
Funcția: Main
S- variabilă locală, pointer la tipul de date structura, adresa începutului tablolui de structuri
n- variabilă locală de tip integer, numărul de elemente a structurii
k- variabilă locală de tip integer, poziția elementului în fața căruia (după care) dorim să înserăm un
element nou
k1,k2- variabilă locală de tip integer, poziția elementelor pe care dorim să le interschimbăm
nd- variabilă locală de tip integer, numărul de ordine a elementului pentru ștergere
nm- variabilă locală de tip integer, numărul de ordine a elementului care trebuie de modificat
comanda- variabilă locală de tip integer, comanda ce o alegem din meniu
denumirea – variabila locală de tip character, șirul de caractere introdus de la tastatură
fnume[20] - variabilă locală de tip character, numele fișierului
y- variabilă locală de tip character, caracterul introdus de la tastatură care alege opțiunea
Funcția: reads(disciplina *S, int n) și
shows(disciplina*S,int n) :
S- variabilă locală, pointer la tipul de date structură, adresă începutului tablolui de structuri
n- variabilă locală, numărul de elemente a structurii
i- variabilă locală, indicele elementului în contur

Funcția: searchs(disciplina *S, int n, char *denumirea)

S- variabilă locală, pointer la tipul de date structură, adresă începutului tablolui de structuri
n- variabilă locală, numărul de elemente a structurii
i- variabilă locală, indicele elementului în contur
denumirea- variabilă locală, pointer la tipul de date caaracter, șirul de caractere introduse de la
tastatură sunt comparate cu șirul de caractere existente în un cîmp din structură.
j- variabilă locală de tip integer, numărul de elemente căutate existente.

Funcția: modifys(disciplina*S, int nm)

S- variabilă locală, pointer la tipul de date structura , adresa inceputului tablolui de structuri
nm- variabilă locală de tip integer, numărul de ordine a elementului din structura introdus de la
tastatură.
Funcția: sorts(disciplina*S,int n)
S- variabila locala, pointer la tipul de date structura, adresa inceputului tablolui de structuri
n- variabilă locală, numărul de elemente a structurii
i- variabilă locală, indicele elementului in contur
t- variabilă locală de tip structură, variabilă intermediară dedicată pentru interschimbarea a 2 elemente

Funcția: swaps(disciplina *S, int k1, int k2)

S- variabilă locală, pointer la tipul de date structură , adresa începutului tablolui de structuri
k1-variabilă locală de tip integer, numărul de ordine a primului element care trebuie de interschimbat
k2- variabilă locală de tip integer, numărul de ordine a al doilea element care trebuie de interschimbat
t- variabilă locală de tip structură, variabilă intermediară dedicată pentru interschimbarea a 2 elemente

Funcția: appends(disciplina*S, int *n)

S- variabilă locală, pointer la tipul de date structură , adresa începutului tablolui de structuri
n- variabilă locală de tip pointer la integer, numărul de elemente a tabloului de structuri
B-variabilă locală returnabilă de tip pointer la structura, adresa elementului nou format

Funcția: insert_befores (stat *S, int *n, int k) si

insert_afters (stat *S, int *n, int k)
S- variabila locala, pointer la tipul de date structură , adresa începutului tablolui de structuri
n- variabila locala de tip pointer la integer, numarul de elemente a tabloului de structuri
k-variabila locala de tip integer, numarul de ordine a elementului inaintea(dupa) caruia(care) adaugam
un element nou.
B-variabilă locală returnabilă de tip pointer la structura, adresa elementului nou format

Funcția: deletes(disciplina*S,int *n, int nd)

nd- variabilă locală de tip integer, numărul de ordine a elementului care dorim să-l ștergem.
S- variabilă locală, pointer la tipul de date structura , adresa începutului tablolui de structuri
n- variabilă locală de tip pointer la integer, numărul de elemente a tabloului de structure
i- variabilă locală, indicele elementului în contur

Funcția: saves(disciplina *S, int n, char *fnume) si

loads(char *fnume, int *n )
fnume[20]- variabilă locală de tip pointer la tipul de date character,adresa unde se păstrează numele
fișierului în care salvam datele sau de unde citim datele.
n- variabilă locală de tip pointer la integer, numărul de elemente a tabloului de structure
i- variabilă locală, indicele elementului în contur
 Codul programului:

Fișierul
disciplina.h
typedef struct disciplina
{
char denumire[100];
char profesor[100];
char universitatea[100];
char specialitatea[100];
int numaruldecredite;
} disciplina ;
void reads (disciplina*S, int n);
void shows (disciplina*S, int n);
int searchs (disciplina*S, int*n, char*denumire);
void sorts (disciplina*S, int n);
void modifys (disciplina*S, int nm);
disciplina*appends (disciplina*S, int*n);
disciplina*prepends (disciplina*S, int*n);
disciplina*insert_befores(disciplina*S, int*n,int k);
disciplina*insert_afters(disciplina*S, int*n,int k);
disciplina*deletes (disciplina*S, int*n, int nd);
void swaps(disciplina*S, int k1, int k2);
void saves(disciplina*S, int n, char *fnume);
disciplina* loads (disciplina *S, char*fnume, int *n);
void form_disciplina (disciplina*nr);

Fișierul :
disciplina.cpp
#include "disciplina.h" printf("****************************************\n\
#include <stdio.h> n");
#include <conio.h> printf("Datele disciplinei: %d\n\n",i+1);
#include <string.h> printf("Denumirea: %s\n\n",S[i].denumire);
#include <stdlib.h> printf("Universitatea: %s\n\n",S[i].universitatea);
//introducerea informatiei despre elementele tabloului de la printf("Profesor: %s\n\n",S[i].profesor);
tastatura printf("Specialitatea: %s\n\n",S[i].specialitatea);
void reads(disciplina *S, int n) printf("Numarul de credite: %d\n\
{int i; n",S[i].numaruldecredite);
puts("Scriti informatia despre disciplina:"); }
for(i=0; i<n; i++) return;
{puts("\n********************"); }
printf("Disciplina %d:\n\n",i+1); //cautarea elementului tabloului dupa denumire
printf("Denumire:"); void searchs(disciplina *S, int n, char *denumire)
fflush (stdin); {
gets(S[i].denumire); int i,j=0;
printf("Universitatea:"); for(i=0;i<n; i++)
fflush (stdin); {
gets(S[i].universitatea); if(stricmp(S[i].denumire, denumire)==0)
printf("Profesor:"); {
fflush (stdin);
gets(S[i].profesor); printf("****************************************\n\n");
printf("Specialitatea:"); printf("Datele disciplinei: %d\n",i+1);
fflush (stdin); printf("Denumirea: %s\n",S[i].denumire);
gets(S[i].specialitatea); printf("Universitatea: %s\n",S[i].universitatea);
printf("Profesor: %s\n",S[i].profesor);
printf("Numarul de credite:"); printf("Specialitatea: %s\n",S[i].specialitatea);
scanf("%d",&S[i].numaruldecredite); printf("Numar de credite: %d\n\
} n",S[i].numaruldecredite);
return; j++;
} }
//afisarea informatiei despre elementele tabloului pe ecran }
void shows(disciplina *S,int n) if(!j)
{int i; {system("cls");
puts("Informatia despre disciplina:"); printf("Nu s-a gasit disciplina: %s\n\n",denumire);
for(i=0; i<n; i++) }
{
} //adaugarea unui element nou la inceputul tabloului
//modificarea cimpurilor elementului tabloului disciplina* prepends(disciplina *S, int *n)
void modifys(disciplina *S, int nm) {
{ int i;
nm=nm-1; disciplina *M;
printf("\n****************************************\n\ disciplina nr;
n"); form_disciplina (&nr);
printf("Nr. de ordine: %d\n",nm+1); M=(disciplina*) realloc (S, (*n+1)*sizeof(*M));
printf("Denumirea: %s\n",S[nm].denumire); if (!M)
printf("Universitatea: %s\n",S[nm].universitatea); {
printf("Profesor: %s\n",S[nm].profesor); return 0;
printf("Specialitatea: %s\n",S[nm].specialitatea); }
printf("Numarul de credite: %d\n\ for (i=*n; i>0; i--)
n",S[nm].numaruldecredite); {
printf("****************************************\n\ M[i]=M[i-1];
n"); }
printf("Introdu datele disciplinei pentru modificare:\n"); M[0]=nr;
printf("Denumirea: "); *n=*n+1;
scanf("%s",&S[nm].denumire); return M;
printf("Universitatea: "); }
scanf("%s",&S[nm].universitatea); //adaugarea unui element nou inaintea elementului inserat
printf("Profesor: "); disciplina* insert_befores (disciplina *S, int *n, int k)
scanf("%s",&S[nm].profesor); {
printf("Specialitatea: "); int i;
scanf("%s",&S[nm].specialitatea); disciplina *M;
printf("Numarul de credite: "); disciplina nr;
scanf("%d",&S[nm].numaruldecredite); form_disciplina (&nr);
} M=(disciplina*) realloc (S, (*n+1)*sizeof(*M));
//sortarea elementelor tabloului dupa alfabet if (!M)
void sorts(disciplina *S,int n) {
{int i,k; return 0;
disciplina t; }
for(i=0;i<n-1;i++) for (i=*n; i>=k; i--)
{ {
for(k=0;k<n-1-i;k++) M[i]=M[i-1];
{ }
M[k-1]=nr;
if(stricmp(S[k].denumire,S[k+1].denumire)>0) *n=*n+1;
{ return M;
t=S[k]; }
S[k]=S[k+1]; //adaugarea unui element nou dupa elementul inserat
S[k+1]=t; disciplina* insert_afters (disciplina*S, int *n, int k)
} {
} int i;
} disciplina *M;
shows(S,n); disciplina nr;
}
//interschimbarea a 2 elemente tabloului form_disciplina (&nr);
void swaps(disciplina *S, int k1, int k2) M=(disciplina*) realloc (S, (*n+1)*sizeof(*M));
{ if (!M)
disciplina t; {
t=S[k1-1]; return 0;
S[k1-1]=S[k2-1]; }
S[k2-1]=t; for (i=*n; i>k; i--)
return; {
} M[i]=M[i-1];
//adaugarea unui element nou la sfirsitul tabloului }
disciplina *appends(disciplina *S, int *n) M[k]=nr;
{ disciplina *M; *n=*n+1;
disciplina nr; return M;
form_disciplina (&nr); }
M=(disciplina*) realloc (S, (*n+1)*sizeof(*M)); //stergerea unui element al tabloului
if (!M) disciplina*deletes (disciplina*S, int*n, int nd)
{ disciplina*M;
int i;
{ for (i=nd;i<*n;i++)
return M; { S[i]=S[i+1];}
} M=(disciplina*)realloc(S,(*n-1)*sizeof(*M));
M[*n]=nr; *n=*n-1;
*n=*n+1; return M;
return M; }
} //salvarea datelor
void saves(disciplina *S, int n, char *fnume) *n=m;
{ }
int i; fclose(demo);
FILE *demo=fopen(fnume,"wt"); return S;
for(i=0;i<n;i++){ }
fprintf(demo,"%s %s %s %s //formarea unui element nou
%d",S[i].denumire,S[i].universitatea,S[i].profesor,S[i].specialit void form_disciplina (disciplina *nr)
atea,S[i].numaruldecredite); {
if(i<n-1) printf ("Denumire: ");
fprintf(demo,"\n"); fflush (stdin);
} gets (nr->denumire);
fclose(demo); printf ("Universitatea: ");
} gets (nr->universitatea);
//citirea informatiei despre elementele tabloului din fisier printf ("Profesor: ");
disciplina* loads(disciplina *S ,char *fnume, int *n ) gets (nr->profesor);
{ printf ("Specialitatea: ");
int i=0,m=0; gets (nr->specialitatea);
FILE *demo=fopen(fnume,"r"); printf ("Numarul de credite: ");
if(!demo){ scanf ("%d", &nr->numaruldecredite);
printf("\aFisierul nu exista!\n"); }
system("pause"); // realocarea memoriei
exit(1); disciplina* reloc(disciplina *S,int n)
} {
while(!feof(demo)) S=(disciplina*)realloc(S,n*sizeof(disciplina));
{ if(!S){
m++; printf("\a\nNu sa alocat memorie!\n");
S=(disciplina*) realloc (S,m*sizeof (*S)); system("pause");
fscanf(demo,"%s%s%s%s exit(1);
%d",&S[i].denumire,&S[i].universitatea,&S[i].profesor,&S[i].s }
pecialitatea,&S[i].numaruldecredite); return S;
i++; }

Fișierul:
main
#include <stdio.h> system("cls");
#include <conio.h> switch(com){
#include <string.h> case 0:
#include <stdlib.h> free(S);
#include "disciplina.cpp" puts ("Doriti sa iesiti din program?\n 1/0");
int main() scanf ("%d", &l);
{disciplina *S=NULL; if (l==1)
int n=0,k=NULL,m,k1,k2,nr,nd,nm,l=NULL,com; {
char fnume[100],y; return 0;
char denumire[100]; }
disciplina *M; else
while(1){ {
system("cls"); if (l==0)
printf("\t\t|Meniu |\ {
n-------------------------------------------------"); break;
printf("\n[ 1 ] Introducerea informatiei despre disciplina }
manual"); else
printf("\n[ 2 ] Citirea informatiei despre elementele tabloului {
din fisier");
printf("\n[ 3 ] Lista cu discipline"); system ("cls");
printf("\n[ 4 ] Cautarea disciplinei dorite"); puts
printf("\n[ 5 ] Sortarea disciplinelor dupa alfabet"); ("Nu ati ales optiunea corecta!\nAlegeti optiunea din nou!\n");
printf("\n[ 6 ] Adaugarea disciplinei la inceputul listei"); puts
printf("\n[ 7 ] Adaugarea disciplinei la sfirsitul listei"); ("\nPentru a continua apasati ENTER!");
printf("\n[ 8 ] Modificarea unei disciplini");
printf("\n[ 9 ] Interschimbarea a 2 disciplini");
printf("\n[ 10 ] Adaugarea unei disciplini inaintea elementului system ("pause");
inserat");
printf("\n[ 11 ] Adaugarea unei disciplini dupa elementul break;
inserat"); }
printf("\n[ 12 ] Stergerea unei disciplini"); }
printf("\n[ 13 ] Salvarea listei cu discipline in fisier"); case 1:
printf("\n[ 0 ] Exit"); system ("cls");
printf("\n\n Introduceti numarul comenzi >> "); printf("Introdu numarul de disciplini: ");
scanf("%d",&com); scanf("%d",&n);
 S=(disciplina*) calloc (n, sizeof (*S)); {printf("\nNu exista disciplina cu asa
if (!S) numar de ordine\a\n");}
{ system ("pause");
puts ("\ break;
nMemoria nu a fost alocata!\n"); case 9:
puts ("Pentru system ("cls");
a iesi din program apasati ENTER!\n"); puts ("\t\tLista cu disciplini\
system n*********************************************");
("pause"); shows(S, n);
exit (1); printf ("Alegeti primul element care trebuie
} de interschimbat:");
else{ scanf ("%d", &k1);
reads(S, n); printf ("Alegeti al doilea element care trebu
system de interschimbat:");
("pause"); scanf ("%d", &k2);
break; swaps (S, k1, k2);
} break;
case 2: case 10:
system ("cls"); system ("cls");
printf("Introduceti numele fisierului salvat puts ("\t\tLista cu disciplini\
anterior pentru citire:\n"); n*********************************************");
scanf("%s",&fnume); shows(S, n);
strcat(fnume,".txt"); printf ("Alegeti elementul in fata caruia
S=loads(S,fnume,&n); doriti sa inserati noul element:");
printf("%d\n",n); scanf ("%d", &k);
system ("pause"); S=insert_befores (S, &n, k);
break; system ("pause");
case 3: break;
system ("cls"); case 11:
shows(S,n); system ("cls");
system ("pause"); puts ("\t\tLista cu disciplini\
break; n*********************************************");
case 4: shows(S, n);
system ("cls"); printf ("Alegeti elementul dupa care doriti
puts ("Introduceti denumirea disciplinei sa inserati noul element:");
pentru cautare:"); scanf ("%d", &k);
scanf ("%s",&denumire); S=insert_afters (S, &n, k);
searchs (S, n, denumire); system ("pause");
system ("pause"); break;
break; case 12:
case 5: system ("cls");
system ("cls"); printf("Introduceti numarul disciplinei pentru
printf("Sortarea disciplinelor dupa alfabet:\ stergere:");
n"); scanf ("%d",&nd);
sorts(S,n); M=deletes(S, &n, nd-1);
system ("pause"); if(M==NULL)
break; {puts ("Memoria nu a fost alocata");}
case 6: else
system ("cls"); {S=M;}
S=prepends (S, &n); printf("\nStergerea a avut loc cu succes!\a\n\n");
system ("pause"); system ("pause");
break; getch();
case 7: break;
system ("cls"); case 13:
system ("cls");
S=appends(S, &n); printf("Introdu numele fisierului pentru
system ("pause"); salvare:");
break; scanf("%s",&fnume);
case 8: strcat(fnume,".txt");
system ("cls"); saves(S,n,fnume);
puts ("\t\tdisciplinile initiale\ printf("\nSalvare a avut loc cu succes!\a\
n*********************************************"); n");
shows(S, n); system ("pause");
printf("Introduceti numarul de ordine a break;
disciplinei:"); default:
scanf("%d",&nm); printf("\aAti introdus o comanda gresita!\
if(nm<=n && nm>=1) n");\
{modifys(S, nm); system("pause");
system ("pause");} break;
else }
}
}
 Rezultatele obținute:
Meniu

Introducerea informației despre disciplini manual

Introducerea informației despre disciplini din fișier

Afișarea listei cu disciplini

 Căutarea disciplinei

Sortarea disciplinelor după denumire

 Modificarea unui disciplini

Adăugarea unei disciplini la început

Adăugarea unei discipline la sfîrșit
 Ștergerea unei disciplini

Interschimbarea a 2 disciplini
 Salvarea listei cu disciplini în fișier

Adăugarea unei disciplini înainte elementului înserat

Exit
 Adăugarea unei disciplini după elementul înserat

Analiza rezultatelor și concluzii:

Am obținut deprinderi practice de implementare a unui tip de date abstract (TDA) în limbajul C și
anume a TDA “Tablou de structuri”
Am obținut deprinderi la scriere unui program în 3 fisiere.
Am înțeles cum să facem legătura între aceste 3 fișiere și am înțeles cum lucrează programul.
Am înțeles facilitatea scrierii programului în 3 fișiere.