Sunteți pe pagina 1din 16

Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra Informatica Aplicat

RAPORT
Lucrarea de laborator nr.1
la Structuri de date si algoritmi

A efectuat:
st. gr. SI-151

D.Cucu

A verificat:
dr., conf.univ.

M. Kulev

Chiinu 2016
0

Lucrarea de laborator nr.1


Tema: Implementarea tipului de date abstract Tablou de structuri in C
Scopul lucrrii: Obtinerea deprinderilor practice de implementare a unui tip de date abstract
(TDA) in limbajul C si anume a TDA Tablou de structuri
Condiia 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. Fiierul antet cu extensia .h care descrie structura elementului tabloului (dup varianta) i
prototipurile funciilor care asigur operaiunile de prelucrare a tabloului de structuri.
2. Fiier cu extensia .cpp (sau .c) care conine codurile (implementrile) tuturor funciilor
declarate n fiierul antet.
3. Fiierul utilizatorului - programul cu funcia main () pentru prelucrarea tabloului de structuri
cu afiarea meniului de opiuni pe ecran, si anume: alocarea memoriei dinamice pentru tablou,
introducerea informaiei despre elementele tabloului de la tastatura, afiarea informaiei despre
elementele tabloului pe ecran, cutarea elementului tabloului dupa unui cimp al structurei,
modificarea cmpurilor elementului tabloului, interschimbarea a 2 elemente tabloului, sortarea
elementelor tabloului dupa unui cmp, 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 informaiei despre elementele tabloului in fiier, citirea
informaiei despre elementele tabloului din fiier, eliberarea memoriei alocate pentru tablou, ieire
din program.

Varianta 10: Stat


Analiza datelor
Functia: Main
S- variabila locala, pointer la tipul de date structura, adresa inceputului tablolui de structuri
n- variabila locala de tip integer, numarul de elemente a structurii
k- variabila locala de tip integer, pozitia elementului in fata caruia(dupa care) dorim sa inseram
un element nou
k1,k2- variabila locala de tip integer, pozitia elementelor pe care dorim sa le interschimbam
nd- variabila locala de tip integer, numarul de ordine a elementului pentru stergere
nm- variabila locala de tip integer, numarul de ordine a elementului care trebuie de modificat
com- variabila locala de tip integer, comanda ce o alegem din meniu
denu variabila locala de tip character, sirul de caractere introdus de la tastatura
fnume[20] - variabila locala de tip character, numele fisierului
y- variabila locala de tip character, caracterul introdus de la tastatura care alege optiunea
Functia: reads(stat *S, int n) si
shows(stat *S,int n) :
S- variabila locala, pointer la tipul de date structura, adresa inceputului tablolui de structuri
n- variabila locala, numarul de elemente a structurii
ivariabila locala, indicele elementului in contur
Functia: searchs(stat *S, int n, char *denu)
S- variabila locala, pointer la tipul de date structura, adresa inceputului tablolui de structuri
n- variabila locala, numarul de elemente a structurii
ivariabila locala, indicele elementului in contur
1

denu- variabila locala, pointer la tipul de date caaracter, sirul de caractere introduse de la
tastatura sunt comparate cu sirul de caractere existente in un cimp din structura.
j- variabila locala de tip integer, numarul de elemente cautate existente.
Functia: modifys(stat *S, int nm)
S- variabila locala, pointer la tipul de date structura , adresa inceputului tablolui de structuri
nm- variabila locala de tip integer, numarul de ordine a elementului din structura introdus de la
tastatura.
Functia: sorts(stat *S,int n)
S- variabila locala, pointer la tipul de date structura, adresa inceputului tablolui de structuri
n- variabila locala, numarul de elemente a structurii
ivariabila locala, indicele elementului in contur
t- variabila locala de tip structura, variabila intermediara dedicata pentru interschimbarea a 2
elemente
Functia: swaps(stat *S, int k1, int k2)
S- variabila locala, pointer la tipul de date structura , adresa inceputului tablolui de structuri
k1-variabila locala de tip integer, numarul de ordine a primului element care trebuie de
interschimbat
k2- variabila locala de tip integer, numarul de ordine a al doilea element care trebuie de
interschimbat
t- variabila locala de tip structura, variabila intermediara dedicata pentru interschimbarea a 2
elemente
Functia: appends(stat *S, int *n)
S- variabila locala, pointer la tipul de date structura , adresa inceputului tablolui de structuri
n- variabila locala de tip pointer la integer, numarul de elemente a tabloului de structuri
B-variabila locala returnabila de tip pointer la structura, adresa elementului nou format
Functia: 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 structura , adresa inceputului 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-variabila locala returnabila de tip pointer la structura, adresa elementului nou format
Functia: deletes(stat *S,int *n, int nd)
nd- variabila locala de tip integer, numarul de ordine a elementului care dorim sa-l stergem.
S- variabila locala, pointer la tipul de date structura , adresa inceputului tablolui de structuri
n- variabila locala de tip pointer la integer, numarul de elemente a tabloului de structure
ivariabila locala, indicele elementului in contur
Functia: saves(stat *S, int n, char *fnume) si
loads(char *fnume, int *n )
fnume[20]- variabile locala de tip pointer la tipul de date character,adresa unde se pastreaza
numele fisierului in care salvam datele sau de unde citim datele.
n- variabila locala de tip pointer la integer, numarul de elemente a tabloului de structure
ivariabila locala, indicele elementului in contur

Codul programului:
Fisierul sta.h

Fisierul state.cpp
#include "stat.h"
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
//introducerea informatiei despre elementele tabloului
de la tastatura
void reads(stat *S, int n)
{int i;
puts("Scriti informatia despre stat:");
for(i=0; i<n; i++)
{puts("\n********************");
printf("Statul %d:\n",i+1);
printf("Denumire:");
scanf("%s",&S[i].denumire);
printf("Capitala:");
scanf("%s",&S[i].capitala);
printf("Suprafata:");
scanf("%d",&S[i].sup);
printf("Numarul de locuitori:");
scanf("%d",&S[i].nl);
printf("PIB-ul:");
scanf("%f",&S[i].pib);
}
return;
}
//afisarea informatiei despre elementele tabloului pe
ecran
void shows(stat *S,int n)
{int i;
puts("Informatia despre stat:");
for(i=0; i<n; i++)
{
printf("****************************************\n
\n");
printf("Datele statului:
%d\n",i+1);
printf("Denumirea:
%s\n",S[i].denumire);

printf("Capitala:
%s\n",S[i].capitala);
printf("Suprafata:
%d\n",S[i].sup);
printf("Numarul de locuitori: %d\n",S[i].nl);
printf("PIB-ul:
%.2f\n\n",S[i].pib);
}
return;
}
//cautarea elementului tabloului dupa denumire
void searchs(stat *S, int n, char *denu)
{int i,j=0;
for(i=0;i<n; i++)
{
if(stricmp(S[i].denumire, denu)==0)
{
printf("****************************************\n\
n");
printf("Datele statului:
%d\n",i+1);
printf("Denumirea:
%s\n",S[i].denumire);
printf("Capitala:
%s\n",S[i].capitala);
printf("Suprafata:
%d\n",S[i].sup);
printf("Numarul de locuitori: %d\n",S[i].nl);
printf("PIB-ul:
%.2f\n\n",S[i].pib);
j++;
}
}
if(!j)
{system("cls");
printf("Nu s-a gasit statul: %s\n\n",denu);
}
}
//modificarea cimpurilor elementului tabloului
void modifys(stat *S, int nm)
{
nm=nm-1;
printf("\n****************************************\
n\n");

printf("Nr. de ordine:
%d\n",nm+1);
printf("Denumirea:
%s\n",S[nm].denumire);
printf("Capitala:
%s\n",S[nm].capitala);
printf("Suprafata:
%d\n",S[nm].sup);
printf("Numarul de locuitori: %d\n",S[nm].nl);
printf("PIB-ul:
%.2f\n\n",S[nm].pib);
printf("****************************************\n
\n");
printf("Introdu datele statului pentru modificare:\n");
printf("Denumirea: ");
scanf("%s",&S[nm].denumire);
printf("Capitala: ");
scanf("%s",&S[nm].capitala);
printf("Suprafata: ");
scanf("%d",&S[nm].sup);
printf("Numarul de locuitori: ");
scanf("%d",&S[nm].nl);
printf("PIB-ul: ");
scanf("%f",&S[nm].pib);
}
//sortarea elementelor tabloului dupa alfabet
void sorts(stat *S,int n)
{int i,k;
stat t;
for(i=0;i<n-1;i++)
{
for(k=0;k<n-1-i;k++)
{
if(stricmp(S[k].denumire,S[k+1].denumire)>0)
{
t=S[k];
S[k]=S[k+1];
S[k+1]=t;
}
}
}
shows(S,n);
}
//interschimbarea a 2 elemente tabloului
void swaps(stat *S, int k1, int k2)
{
stat t;

{
int i;
stat *B;
stat nr;
form_stat (&nr);
B=(stat*) realloc (S, (*n+1)*sizeof(*B));
if (!B)
{
return 0;
}
for (i=*n; i>0; i--)
{
B[i]=B[i-1];
}
B[0]=nr;
*n=*n+1;
return B;
}
//adaugarea unui element nou inaintea elementului
inserat
stat* insert_befores (stat *S, int *n, int k)
{
int i;
stat *B;
stat nr;
form_stat (&nr);
B=(stat*) realloc (S, (*n+1)*sizeof(*B));
if (!B)
{
return 0;
}
for (i=*n; i>=k; i--)
{
B[i]=B[i-1];
}
B[k-1]=nr;
*n=*n+1;
return B;
}
//adaugarea unui element nou dupa elementul inserat
stat* insert_afters (stat *S, int *n, int k)
{
int i;
stat *B;
stat nr;

t=S[k1-1];
S[k1-1]=S[k2-1];
S[k2-1]=t;
return;

form_stat (&nr);
B=(stat*) realloc (S, (*n+1)*sizeof(*B));
if (!B)
{
return 0;
}
for (i=*n; i>k; i--)
{
B[i]=B[i-1];
}
B[k]=nr;
*n=*n+1;
return B;

}
//adaugarea unui element nou la sfirsitul tabloului
stat *appends(stat *S, int *n)
{
stat *B;
stat nr;
form_stat (&nr);
B=(stat*) realloc (S, (*n+1)*sizeof(*B));
if (!B)
{
return B;
}
B[*n]=nr;
*n=*n+1;
return B;
}
//adaugarea unui element nou la inceputul tabloului
stat* prepends(stat *S, int *n)

}
//stergerea unui element al tabloului
void deletes(stat *S,int *n, int nd)
{int i;
*n=*n-1;
if(*n>0){
for(i=nd;i<*n;i++){
S[i]=S[i+1];
}
}else

printf("\nNu mai sunt state!\a\n");


S=reloc(S,*n);
}
//salvarea datelor
void saves(stat *S, int n, char *fnume)
{
int i;
FILE *demo=fopen(fnume,"wt");
for(i=0;i<n;i++){
fprintf(demo,"%s %s %d %d
%.2f",S[i].denumire,S[i].capitala,S[i].sup,S[i].nl,S[i].pib);
if(i<n-1)
fprintf(demo,"\n");
}
fclose(demo);
}
//citirea informatiei despre elementele tabloului din
fisier
stat* loads(char *fnume, int *n )
{
int i=0,m=0;
stat *S=NULL;
FILE *demo=fopen(fnume,"r");
if(!demo){
printf("\aFisierul nu exista!\n");
system("pause");
exit(1);
}
while(!feof(demo)){
m++;
S=reloc(S,m);
fscanf(demo,"%s%s%d%d
%f",&S[i].denumire,&S[i].capitala,&S[i].sup,&S[i].nl,&S[i
].pib);

i++;
}
*n=m;
fclose(demo);
return S;
}
//formarea unui element nou
void form_stat (stat *nr)
{
printf ("Denumire: ");
scanf ("%s", nr->denumire);
printf ("Capitala: ");
scanf ("%s", nr->capitala);
printf ("Suprafata: ");
scanf ("%d", &nr->sup);
printf ("Numarul de locuitori: ");
scanf ("%d", &nr->nl);
printf ("PIB-ul: ");
scanf ("%f", &nr->pib);
}
// realocarea memoriei
stat* reloc(stat *S,int n){
S=(stat*)realloc(S,n*sizeof(stat));
if(!S){
printf("\a\nNu sa alocat memorie!\n");
system("pause");
exit(1);
}
return S;
}

Fisierul: Main
#include "state.cpp"
int main()
{stat *S=NULL;
int n=0,k=NULL,k1,k2,nr,nd,nm,l=NULL,com;
char fnume[20],y;
char denu;
stat *B;
while(1){
system("cls");
printf("\t\t|Meniu
|\n-------------------------------------------------");
printf("\n[ 1 ] Introducerea informatiei despre state
manual");
printf("\n[ 2 ] Introducerea informatiei despre state din
fisier");
printf("\n[ 3 ] Lista cu state");
printf("\n[ 4 ] Cautarea statului dorit");
printf("\n[ 5 ] Sortarea statelor dupa alfabet");
printf("\n[ 6 ] Adaugarea statului la inceputul listei");
printf("\n[ 7 ] Adaugarea statului la sfirsitul listei");
printf("\n[ 8 ] Modificarea unui stat");
printf("\n[ 9 ] Interschimbarea a 2 state");
printf("\n[ 10 ] Adaugarea unui stat inaintea elementului
inserat");
printf("\n[ 11 ] Adaugarea unui stat dupa elementul
inserat");
printf("\n[ 12 ] Stergerea unui stat");
printf("\n[ 13 ] Salvarea listei cu state in fisier");
printf("\n[ 0 ] Exit");
printf("\n\nComanda << ");
scanf("%d",&com);

system("cls");
switch(com){
case 0:
free(S);
puts ("Doriti sa iesiti din program?\n 1/0");
scanf ("%d", &l);
if (l==1)
{
return 0;
}
else
{
if (l==0)
{
break;
}
else
{
system ("cls");
puts ("Nu ati ales optiunea corecta!\nAlegeti
optiunea din nou!\n");
puts ("\nPentru a continua apasati ENTER!");
system ("pause");
break;
}
}
case 1:

system ("cls");
printf("Introdu numarul de state: ");
scanf("%d",&n);
S=(stat*) calloc (n, sizeof (*S));
if (!S)
{
puts
("\nMemoria nu a fost alocata!\n");
puts
("Pentru a iesi din program apasati ENTER!\n");
system
("pause");
exit (1);
}
else{
reads(S, n);
system
("pause");
break;
}
case 2:
system ("cls");
printf("Introduceti numele fisierului
salvat anterior pentru citire:\n");
scanf("%s",&fnume);
strcat(fnume,".txt");
S=loads(fnume,&n);
system ("pause");
break;
case 3:
system ("cls");
shows(S,n);
system ("pause");
break;
case 4:
system ("cls");
puts ("Introduceti denumirea statului
pentru cautare: ");
scanf ("%s",&denu);
searchs (S, n, &denu);
system ("pause");
break;
case 5:
system ("cls");
printf("Sortarea statelor dupa denumire:
\n");
sorts(S,n);
system ("pause");
break;
case 6:
system ("cls");
B=prepends (S, &n);
system ("pause");
break;
case 7:
system ("cls");
B=appends(S, &n);
system ("pause");
break;
case 8:
system ("cls");
puts ("\t\tStatele
initiale\n****************************************
*****");
shows(S, n);
printf("Introduceti numarul de ordine a
statului: ");
scanf("%d",&nm);
if(nm<=n && nm>=1)
{modifys(S, nm);
system ("pause");}
else

{printf("\nNu exista stat cu asa numar


de ordine\a\n");}
system ("pause");
break;
case 9:
system ("cls");
puts ("\t\tLista cu
state\n******************************************
***");
shows(S, n);
printf ("Alegeti primul element care
trebuie de interschimbat: ");
scanf ("%d", &k1);
printf ("Alegeti al doilea element care
trebu de interschimbat: ");
scanf ("%d", &k2);
swaps (S, k1, k2);
break;
case 10:
system ("cls");
puts ("\t\tLista cu
state\n******************************************
***");
shows(S, n);
printf ("Alegeti elementul in fata caruia
doriti sa inserati noul element: ");
scanf ("%i", &k);
B=insert_befores (S, &n, k);
system ("pause");
break;
case 11:
system ("cls");
puts ("\t\tLista cu
state\n******************************************
***");
shows(S, n);
printf ("Alegeti elementul dupa care
doriti sa inserati noul element: ");
scanf ("%i", &k);
B=insert_afters (S, &n, k);
system ("pause");
break;
case 12:
system ("cls");
puts ("\t\tStatele
initiale\n****************************************
*****");
shows(S, n);
dt:
printf("Introdu numarul de ordine a
statului pentru stergere: ");
scanf("%d",&nd);
if(nd<1 || nd>n){
system("cls");
printf("\aAti introdus un numar de
ordine care nu exista!\nIncercati din nou.\n");
system("pause");
system("cls");
goto dt;
} else {
nd=nd-1;
printf("\n\n***************************************
*\n\n");
printf("Nr. de ordine:
%d\n",nd+1);
printf("Denumirea:
%s\n",S[nd].denumire);
printf("Capitala:
%s\n",S[nd].capitala);
printf("Suprafata:
%d\n",S[nd].sup);

printf("Numarul de locuitori:

}
break;

%d\n",S[nd].nl);
printf("PIB-ul:
%.2f\n\n",S[nd].pib);

case 13:

printf("****************************************\n
\n");
printf("Doriti sa stergeti aceasta
inregistrare? y/n\n");
scanf("%s",&y);
if(y=='y'){
deletes(S,&n,nd);
} else
if(y=='n'){
break;
} else{
printf("\n\aAti introdus o comanda
gresita!\n");
system("pause");
system("cls");
goto dt;
}

salvare: ");

system ("cls");
printf("Introdu numele fisierului pentru
scanf("%s",&fnume);
strcat(fnume,".txt");
saves(S,n,fnume);
printf("\nSalvare a avut loc cu
succes!\a\n\n");
system ("pause");
break;
default:
printf("\aAti introdus o comanda
gresita!\n");\
system("pause");
break;
}
}
}

Rezultatele obtinute:
Meniu

Introducerea informatiei despre state manual

Introducerea informatiei despre state din fisier

Afisarea listei cu state

Cautarea statului
8

Sortarea statelor dupa denumire

Adaugarea unui stat la inceput

Adaugarea unui stat la sfirsit

10

Modificarea unui stat

11

Interschimbarea a 2 state

12

Adaugarea unui stat inainte elementului inserat

13

Adaugarea unui stat dupa elementul inserat

Stergerea unui stat

14

Salvarea listei cu state in fisier

Exit

Concluzie
1. Am obtinut deprinderi practice de implementare a unui tip de date abstract (TDA) in
limbajul C si anume a TDA Tablou de structuri
2. Am obtinut deprinderi la scriere unui program in 3 fisiere.
3. Am inteles cum sa facem legatura intre aceste 3 fisiere si am inteles cum lucreaza
programul.
4. Am inteles facilitatea scrierii programului in 3 fisiere.

Bibliografie:

TOTUL DESPRE C SI C++ (MANUALUL FUNDAMENTAL DE


PROGRAMARE IN C SI C++)[RO][Kris Jamsa][Lars Kland]

http://www.scribd.com/doc/41293824/Negrescu-Liviu-Limbajele-C-si-Cpentru-incepatori-vol-1

15