Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Informatica Aplicată

RAPORT
Lucrarea de laborator nr.2 si 3
la Structuri de date si algoritmi

A efectuat:
st. gr. SI-151 D.Cucu

A verificat:
dr., conf.univ. M. Kulev

Chişinău 2016
 Lucrarea de laborator nr.2 si 3

Tema: Implementarea tipului de date abstract “Lista simplu inlanţuită” in limbajul C.

Scopul lucrării: obţinerea deprinderilor practice de implementare și de utilizare a unui tip de

date abstract (TDA) in limbajul C şi anume TDA “Lista simplu inlanţuită”.
Condiţia problemei (sarcina de lucru) : De scris trei fişiere in limbajul C pentru
implementarea (2 fişiere) si utilizarea (1 fişier – program cu functia main) pentru TDA “Lista
simplu inlanţuită”:
1. Fişierul antet cu extensia (h) care descrie structura de date a elementului listei simplu
inlanţuite (conform variantei din lucrare precedentă) şi prototipurile funcţiilor care asigură
operaţiunile de prelucrare a listei simplu inlanţuite.

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 listei simplu inlanţuite
cu afişarea meniului de opţiuni pe ecran si anume:

pentru lucrare de laborator 2 - crearea listei simplu inlanţuite cu n elemente în memoria

dinamică, întroducerea informaţiei despre elementele listei de la tastatură, afişarea informaţiei
despre elementele listei pe ecran (și a adreselor elementului current și următor), căutarea
elementului listei dupa unui cîmp informaţional, modificarea cîmpurilor elementului listei,
interschimbarea a 2 elemente listei, determinarea lungimei listei, sortarea elementelor listei după
unui cimp, eliberarea memoriei dinamice, ieşire din program;

pentru lucrare de laborator 3 - adaugarea unui element nou la sfirşitul listei, adaugarea unui
element nou la începutul listei, inserarea unui element nou în lista după elementul indicat,
inserarea unui element nou în lista înainte elementul indicat, stergerea unui element al listei,
divizarea listei simplu inlanţuite in două liste separate, unirea a 2 liste simlu inlanţuite intr-o
listă, scrierea informaţiei despre elementele listei în fişier, citirea informatiei despre elementele
listei din fişier.

Note teoretice
Listele simplu inlantuite sunt structuri de date dinamice omogene. Spre deosebire de masive,
listele nu sunt alocate ca blocuri omogene de memorie, ci ca elemente separate de memorie.
Fiecare nod al listei contine, in afara ce informatia utila, adresa urmatorului element. Aceasta
organizare permite numai acces secvential la elementele listei. Pentru accesarea listei trebuie
cunoscuta adresa primului element (numita capul listei); elementele urmatoare sunt accesate
parcurgand lista. Lista simplu inlantuita poate fi reprezentata grafic astfel:
 Varianta 10: Stat

Analiza datelor
Functia: Main
a,b – variabile locale de tip pointer la structura, adresa elementelor ce trebuie interschimbate
c – variabila locala de tip pointer la strucura
head_2- variabila locala de tip pointer la structura, adresa capului listei a doua
n- variabila locala de tip integer, numarul de elemente a listei simplu inlantuite
nd – variabila locala de tip integer, numarul de ordine a elementului pentru stergere
nm- variabila locala de tip integer, numarul de orine a statului pentru modificare
id- variabila locala de tip integer, numarul de ordine a elementului inaintea(dupa) caruia(care)
adaugam un element nou.
l- variabila locala de tip integer, lungimea primei parti a listeisimplu inlantuite
com, com1, af- variabile locale de tip integer, optiuni pentru alegere din meniuri
fname[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.
denu – variabila locala de tip character, sirul de caractere introdus de la tastatura
Functia: creates(int n);
n- variabila locala de tip integer, numarul de elemente a listei simplu inlantuite
c – variabila locala de tip pointer la strucura
p- variabila locala de tip pointer la strucura
Functia: reads() si shows(stat *head_2);
c – variabila locala de tip pointer la strucura
i- Variabila locala de tip integer, numarul de ordine a elementului in lista
head_2- variabila locala de tip pointer la structura, adresa capului listei a doua
Functia: searchs ( char *denu)
c – variabila locala de tip pointer la strucura
denu – variabila locala de tip pointer la character, adresa sirul de caractere introdus de la
tastatura
Functia: sorts(void)
a,b – variabile locale de tip pointer la structura, adresa elementelor ce trebuie interschimbate
pentru sortarea listei
l- variabila locala returnabila de tip integer, lungimea listei simplu inlantuite
i,k –variabile locale de tip integer, indicele elementului in contor

Functia: appends() si prepends()

c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura

Functia: deletes(int id)

nd- variabila locala de tip integer, numarul de ordine a statului care trebuie sters
c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura

Functia: insertbefores(int id) si

insertafters(int id)
id- variabila locala de tip integer, numarul de ordine a elementului inaintea(dupa) caruia(care)
adaugam un element nou
c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura

Functia: modifys(int m)
nm- variabila locala de tip integer, numarul de orine a statului pentru modificare
i- variabile locale de tip integer, indicele elementului in contor
cm,cm1- variabile locale de tip integer, optiuni pentru alegere din meniuri

Functia: swaps(stat *a, stat *b)

a,b – variabile locale de tip pointer la structura, adresa elementelor ce trebuie interschimbate
na,nb- variabile locale de tip pointer la structura, adresele elementelor urmatoare a elementelor
a si b in lista simplu inlantuita.
t- variabila locala de tip pointer la structura, adresa elementului intermediar care ajuta la
interschimbarea a 2 state.

Functia: lengths(void)
l- variabila locala de tip integer, lungimea listei simplu inlantuite
c-variabila locala de tip pointer la structura

Functia: saves( char *fname) si

loads( char *fname)
fname[]- 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
c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura

Functia: freemems(void)
c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura

Functia: splits(int l,stat **head_2)

l- variabila locala de tip integer, lungimea primei parti a listeisimplu inlantuite
head_2- variabila locala de tip pointer la pointer la structura, adresa variabilei in memorie unde
este salvata adresa capului listei a doua
c- variabila locala de tip pointer la structura
i- variabile locale de tip integer, indicele elementului in contor

Functia: joins(stat **head_2)

head_2- variabila locala de tip pointer la pointer la structura, adresa variabilei in memorie unde
este salvata adresa capului listei a doua
c- variabila locala de tip pointer la structura
 Codul programului:
Fisierul : “Lab2.1.h”

Fisierul : “functii lab2.cpp”

#include "Lab2.1.h" p=c;
#include <stdio.h> }
#include <stdlib.h> c->next=NULL;
#include <conio.h> return 1;
#include <string.h> }
//crearea listei simplu inlantuite //introducere de la tastatura
int creates(int n) void reads(void)
{ stat *c,*p; {stat *c;
int i; int i=0;
for(i=0;i<n;i++) puts("Scriti informatia despre stat:");
{c=(stat*)malloc(sizeof(*c)); c=head;
if(!c) while(c)
{return 0; {
} printf("Statul %d:\n",i+1);
if(i==0) printf("Denumirea: ");
{head =c; scanf("%s",&c->denumire);
} printf("Capitala: ");
else scanf("%s",&c->capitala);
{p->next=c; printf("Suprafata: ");
} scanf("%d",&c->sup);
 printf("Numarul de locuitori: ");
scanf("%d",&c->nl); printf("****************************************\n\
printf("PIB-ul: "); n");
scanf("%f",&c->pib); printf("Datele statului: %d\n",i+1);
c=c->next; printf("Denumirea: %s\n",c-
i++; >denumire);
if(c==head) break; printf("Capitala: %s\n",c->capitala);
} printf("Suprafata: %d\n",c->sup);
} printf("Numarul de locuitori: %d\n",c->nl);
//interschimbarea a 2 state printf("PIB-ul: %.2f\n\n",c->pib);
void swaps(stat *a,stat *b) k++;
{stat *na,*nb; }
stat t; c=c->next;
na=a->next; i++;
nb=b->next; }
t=*a; if(k){
*a=*b; return 1;
*b=t; }
a->next=na; return 0;
b->next=nb; }
} //sortarea
//afisarea listei void sorts(void)
void shows(stat *head_2) {stat *a,*b;
{ int l;
stat *c; int i,k;
int i=0; l=lengths();
if(head_2 == NULL){ for(i=0;i<l-1;i++)
c=head; {a=head;
} else { b=a->next;
c=head_2; for(k=0;k<l-1-i;k++)
} {if(stricmp (a->denumire, b->denumire)>0)
puts("Informatia despre stat:"); {swaps(a,b);
while(c) }
{printf("****************************************\ a=a->next;
n\n"); b=b->next;
printf("Datele statului: %d\n",i+1); }
printf("Denumirea: %s\n",c->denumire); }
printf("Capitala: %s\n",c->capitala); }
printf("Suprafata: %d\n",c->sup); //modificare
printf("Numarul de locuitori: %d\n",c->nl); void modifys(int nm)
printf("PIB-ul: %.2f\n\n",c->pib); {stat *c=head;
printf ("Adresa elementului curent: "); int i=0,cm,cm1;
printf ("%p\n", c); while(c){
printf ("Adresa elementului urmator: "); if(i+1 == nm){
printf ("%p", c->next); asd:system("cls");
printf ("\n");
c=c->next;
i++; printf("****************************************\n\
} n");
} printf("Datele statului: %d\n",i+1);
//lungimea listei printf("[1] Denumire: %s\n",c->denumire);
int lengths(void) printf("[2] Capitala: %s\n",c->capitala);
{int l; printf("[3] Suprafata: %d\n",c->sup);
stat *c; printf("[4] Numarul de locuitori: %d\n",c->nl);
l=0; printf("[5] PIB-ul: %.2f\n\n",c->pib);
c=head; printf("Ce doriti sa modificati?\n\nComanda << ");
while(c) scanf("%d",&cm);
{l++; switch(cm){
c=c->next; case 1:
if(c==head) break; printf("Denumirea: ");
scanf("%s",&c->denumire);
} break;
return l; case 2:
} printf("Capitala: ");
//cautarea scanf("%s",&c->capitala);
int searchs(char *denu) break;
{stat *c=head; case 3:
int i=0,k=0; printf("Suprafata: ");
while(c){ scanf("%d",&c->sup);
if(stricmp(c->denumire, denu)==0){ break;
 case 4: }
printf("Numarul de locuitori: }
"); //adaugarea inainte
scanf("%d",&c->nl); stat *insertbefores(int id){
break; stat *c=head,*p;
case 5: int i=0;
printf("PIB-ul: "); while(c){
scanf("%f",&c->pib); if(i == id-1){
break; p=c;
default: c=(stat*)malloc(sizeof(stat));
printf("\n\aAti introdus o
comanda gresita! { %d }\nIncercati din nou.\n"); printf("\n****************************************\
system("pause"); n\n");
goto asd; printf("Introdu datele statului\n");
break; printf("Denumirea: ");
} scanf("%s",&c->denumire);
printf("\n\nMai doriti sa modificati ceva? 1 / 0 \n"); printf("Capitala: ");
scanf("%d",&cm1); scanf("%s",&c->capitala);
if(cm1){ printf("Suprafata: ");
goto asd; scanf("%d",&c->sup);
} else { printf("Numarul de locuitori: ");
return; scanf("%d",&c->nl);
} printf("PIB-ul: ");
} scanf("%f",&c->pib);
c=c->next; if(p == head){
i++; c->next=head;
} head=c;
} break;
//elierarea memoriei } else {
void freemems(void) c->next=p;
{stat *c,*p; i=0;
c=head; p=head;
while(c) while(p){
{p=c; if(i == id-2){
c=c->next; p->next=c;
free(p); }
if(c==head) break; i++;
p=p->next;
} }
return; break;
} }
//adaugarea dupa }
stat* insertafters(int id) i++;
{ c=c->next;
stat *c=head,*p; }
int i=0; }
while(c){ //adaugarea la sfirsit
if(i == id-1){ void appends(){
p=c; stat *c=head,*p;
c=(stat*)malloc(sizeof(stat)); while(c){
if(c->next == NULL){
printf("\n**************************************** p=c;
\n\n"); c=(stat*)malloc(sizeof(stat));
printf("Introdu datele statului\n");
printf("Denumirea: "); printf("\n****************************************\
scanf("%s",&c->denumire); n\n");
printf("Capitala: "); printf("Introdu datele statului\n");
scanf("%s",&c->capitala); printf("Denumirea: ");
printf("Suprafata: "); scanf("%s",&c->denumire);
scanf("%d",&c->sup); printf("Capitala: ");
printf("Numarul de locuitori: "); scanf("%s",&c->capitala);
scanf("%d",&c->nl); printf("Suprafata: ");
printf("PIB-ul: "); scanf("%d",&c->sup);
scanf("%f",&c->pib); printf("Numarul de locuitori: ");
c->next=p->next; scanf("%d",&c->nl);
p->next=c; printf("PIB-ul: ");
break; scanf("%f",&c->pib);
} p->next=c;
i++; c->next=NULL;
c=c->next;
 break; }
} i++;
c=c->next; c=c->next;
} }
} }
//adaugarea la inceput //divizarea
int prepends(){ void splits(int l,stat **head_2){
stat *c,*p; stat *c=head;
p=(stat*)malloc(sizeof(stat)); int i=0;
if(!p) while(c){
{return 0; if(i == l-1){
} *head_2=c->next;
if(head==NULL) c->next=NULL;
{p->next=NULL; break;
p=head; }
} i++;
else c=c->next;
{p->next=head; }
head=p; }
//unirea
printf("\n**************************************** void joins(stat **head_2){
\n\n"); stat *c=head;
printf("Introdu datele statului\n"); while(c){
printf("Denumirea: "); if(c->next == NULL){
scanf("%s",&p->denumire); c->next=*head_2;
printf("Capitala: "); break;
scanf("%s",&p->capitala); }
printf("Suprafata: "); c=c->next;
scanf("%d",&p->sup); }
printf("Numarul de locuitori: "); *head_2=NULL;
scanf("%d",&p->nl); }
printf("PIB-ul: "); //salvarea
scanf("%f",&p->pib); void saves(char *fname){
stat *c=head;
FILE *demo=fopen(fname,"w");
} while(c){
} fprintf(demo,"%s %s %d %d %.2f",c->denumire,c-
//stergerea statului >capitala,c->sup,c->nl,c->pib);
void deletes(int nd) if(c->next != NULL){
{ fprintf(demo,"\n");
stat *c=head,*p; }
int i=0; c=c->next;
while(c){ }
if(i == nd-1){ fclose(demo);
if(c == head){ }
head=c->next; //citirea din fisier
free(c); void loads(char *fname){
break; stat *c,*p;
} else if(c->next == NULL){ int i=0;
p=head; FILE *demo=fopen(fname,"r");
while(p){ if(!demo){
if(p->next == c){ printf("\aFisierul nu exista!\n");
free(c); system("pause");
p->next=NULL; exit(1);
break; }
} while(!feof(demo)){
p=p->next; c=(stat*)malloc(sizeof(stat));
} if(c == NULL){
} else { printf("\n\aEroare la alocarea memoriei!\n");
p=head; system("pause");
while(p){ }
if(p->next == c){ if(i == 0){
head=c;
p->next=c->next; p=c;
free(c); } else {
break; p->next=c;
} p=c;
p=p->next; }
} fscanf(demo,"%s %s %d %d %f",&c->denumire,&c-
} >capitala,&c->sup,&c->nl,&c->pib);
i++; fclose(demo);
} }
p->next=NULL;

Fisierul: “Main2.cpp”

#include "functii lab2.cpp"

int main(){ printf("\n[ 6 ] Stergerea unui stat");

stat *head2=NULL; printf("\n[ 7 ] Modifica datele statului");
stat *a,*b,*c,*head_2=NULL ; printf("\n[ 8 ] Sortarea statelor dupa denumire");
int n,m=1,nd,nm,id,l,af; printf("\n[ 9 ] Salvarea datelor in fisier");
int com,com1; printf("\n[ 10 ] Interschimbarea a 2 elemente");
char fname[20]; printf("\n[ 11 ] Adaugarea unui stat nou inaintea statului
char denu; indicat");
while(1){ printf("\n[ 12 ] Adaugarea unui stat nou dupa statul
fflush(stdin); indicat");
while(m){ printf("\n[ 13 ] Desparte lista in 2");
fflush(stdin); printf("\n[ 14 ] Unirea listei");
m=0; printf("\n[ 15 ] Meniul precedent");
system("cls"); printf("\n[ 0 ] Exit");
printf("Introduceti datele printf("\n\nComanda << ");
statelor|\n-------------------------------\n"); scanf("%d",&com1);
printf("\n[ 1 ] Manual\n[ 2 ] Fisier\n\n[ 0 ] system("cls");
Exit\n\nComanda << "); switch(com1){
scanf("%d",&com); case 0:
system("cls"); if(head){
switch(com){ freemems();
case 0: }
if(head){ exit(0);
freemems(); break;
} case 1:
exit(0); if(head_2){
break; printf("[ 1 ] Afisare head_1\n");
case 1: printf("[ 2 ] Afisare head_2\n\n");
printf("Introdu numarul de state: "); printf("[ 0 ] Iesire din acest meniu\n");
scanf("%d",&n); printf("\nComanda << ");
if(creates(n)){ scanf("%d",&af);
reads(); switch(af){
} else { case 0:
printf("\nEroare la alocarea goto qaz;
memoriei!\a\n"); break;
system("pause"); case 1:
} shows(NULL);
break; break;
case 2: case 2:
printf("Introdu numele fisierului pentru shows(head_2);
citire:\n"); break;
scanf("%s",&fname); default:
strcat(fname,".txt"); printf("\aAti
loads(fname); introdus o comanda gresita!\n");
break; system("pause");
default: goto qaz;
printf("\aAti introdus o comanda break;
gresita!\n"); }
system("pause"); } else {
m=1; shows(NULL);
break; }
} break;
saves(fname); case 2:
} printf("Introduceti denumirea statului:
qaz: system("cls"); ");
printf("\n[ 1 ] Lista cu state"); scanf("%s",&denu);
printf("\n[ 2 ] Cautarea statelor dupa denumire"); if(!searchs(&denu)){
printf("\n[ 3 ] Lista in ordine descrescatoare dupa printf("\nNu sa gasit stat cu
suprafata"); asa denumire{ %s }\a\n\n",denu);
printf("\n[ 4 ] Adaugarea statului la sfirsit"); }
printf("\n[ 5 ] Adaugarea statului la inceput"); break;
 case 3: system ("cls");
printf("Lista in ordine descrescatoare printf ("Alegeti numarul de ordine a
dupa suprafata: \n"); statului dupa care doriti sa inserati noul stat: ");
sorts(); scanf ("%i", &id);
c=insertafters(id);
shows(NULL); system ("pause");
break; break;
case 4: case 13:
appends(); printf("Introdu lungimea primei parti,
break; ( partea a 2 va obtine restul)\n");
scanf("%d",&l);
if(lengths() > 1 && l>0 && l <
case 5: lengths()){
splits(l,&head_2);
prepends(); } else {
break; printf("\aListele trebuie sa
case 6: aiba macar cite un element!\n");
printf("Introdu numarul de ordine a }
statului pentru stergere: "); break;
scanf("%d",&nd); case 14:
if(nd > 0 && nd <= lengths()){ if(head_2){
deletes(nd); joins(&head_2);
printf("Statul a fost sters cu printf("Unirea a avut loc cu succes\n");
succes.\n"); } else {
} else { printf("\aMai intii lista trebuie
printf("\aAti introdus un numar iesit despartita!\n");
din intervalul existent\n"); }
system("pause"); break;
goto qaz; case 15:
} m=1;
break; break;
case 7: default:
printf("Introdu numarul de ordine a printf("\aAti introdus o comanda
statului: "); gresita!\n");
scanf("%d",&nm); break;
modifys(nm); }
break;
case 8: system("pause");
system ("cls"); }
sorts (); return 0;
shows (head_2); }
system ("pause");
break;
case 9:
printf("Introdu numele fisierului pentru
salvare: ");
scanf("%s",&fname);
strcat(fname,".txt");
saves(fname);
break;
case 10:
system ("cls");
printf ("Alegeti primul element care
trebuie de interschimbat: ");
scanf ("%stat", &a);
printf ("Alegeti al doilea element care
trebu de interschimbat: ");
scanf ("stat", &b);
swaps (a, b);
getch ();
break;
case 11:
system ("cls");
printf ("Alegeti numarul de ordine a
statului inaintea caruia doriti sa inserati noul stat: ");
scanf ("%i", &id);
c=insertbefores(id);
system ("pause");
break;
case 12:
 Rezultatele obtinute:
Meniul de introducere a datelor de la tastatura si din fisier

Introducerea de la tastatura

Citirea din fisier

 Meniu

Afisarea listei cu state

Cautarea statului dupa denumire

Adaugarea statului la sfirsit

Adaugarea statului la inceput
 Stergerea unui stat

Modificarea unui stat

Sortarea statelor dupa denumire
 Salvarea datelor in fisier

Adaugarea unui element nou inainte statului indicat

Adaugarea unui stat nou dupa statul indicat

Despartirea listei in 2
 Unirea listei

Eliberarea memoriei

Concluzie
In urma acestei lucrari de laborator am ajuns la ideia ca e destul de usor de lucrat cu
structuri de date liste, ele sunt usor de modificat si lucrul dat nu necesita mult timp.
De asemenea verificarea rezultatelor demonstreaza ca valorile primite sunt adevarate
ceea ce arata ca programul lucreaza.

Bibliografie:
 http://programmersclub.ru/01/
 http://www.scribd.com/doc/41293824/Negrescu-Liviu-Limbajele-C-si-C-
pentru-incepatori-vol-1
 http://devcentral.iftech.com/learning/tutorials/c-cpp/c