Ministerul Educaiei al Republicii Moldova

Universitatea Tehnica a Moldovei

Catedra Informatic Aplicat

Raport
Lucrare de laborator Nr.2,3

la Structuri de Date i Algoritmi

Varianta 8

A efectuat: st. gr. SI-162 N.Vladislav

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

Chiinau 2017
 Lucrarea de laborator nr. 2-3

Varianta 8

Tema: Implementarea tipului de date abstract Lista simplu

nlanuit n limbajul C.

Sarcina:De scris trei fisiere in C pentru implementarea si folosirea tipului

abstract de date a listei simplu inlantuite.

Scopul lucrrii: Obinerea deprinderilor practice de

implementare i de utilizare a tipului de date abstract (TDA)
Lista simplu nlanuit n limbajul C.

1. Fiierul antet lab23.h care conine:

a) specificaia structurei elementului listei simplu nlanuite

(conform variantei din lucrarea de laborator nr.1).

b) prototipurile funciilor care asigur operaiunile de

prelucrare a listei simplu nlanuite.

2. Fiierul lab23.c care conine codurile (implementrile) tuturor

funciilor declarate n fiierul antet.

3. Fiierul utilizatorului lab2_3.c care reprezint programul cu

funcia main ( ) pentru prelucrarea listei simplu nlanuite cu
afiarea meniului de opiuni pe ecran si anume:

Pentru lucrarea de laborator nr.2 - crearea listei simplu

inlanuite cu n elemente n memoria dinamic, ntroducerea
informaiei despre elementele listei de la tastatur, afiarea
informaiei despre elementele listei pe ecran (precum i
afiarea adreselor elementului current i urmtor), cutarea
elementului listei dupa unui cmp informaional al structurei,
modificarea cmpurilor elementului listei, interschimbarea a 2
elemente indicate ale listei, determinarea lungimii listei,
sortarea elementelor listei dup unui cmp, determinarea
adresei ultimului eliment al listei, eliberarea memoriei dinamice
allocate pentru lista, ieire din program;

Pentru lucrarea de laborator nr.3 - adugarea unui element nou

la sfiritul listei, adugarea unui element nou la nceputul listei,
inserarea unui element nou n lista dup elementul indicat,
inserarea unui element nou n lista nainte elementul indicat,
eliminarea (stergerea) unui element din lista, divizarea listei
simplu nlanuite in dou liste separate, unirea a 2 liste simlu
nlanuite intr-o list, scrierea (salvarea) informaiei despre
elementele listei n fiier, citirea informaiei despre elementele
listei din fiier.

Mersul lucrrii:

Noiuni principale din teorie i metode folosite [1,2]:

Cel mai simplu tip de structuri dinamice sunt listele. Lista

dinamica (lista inlantuita) este o colectie de date care contine
un numar variabil, dar finit de elemente de acelasi tip. Fiecare
element al listei se numeste nod sau celula. Fiecare nod al listei
contine, in afara de 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.

In functie de numarul de legaturi pe care le contine un

element, listele inlantuite sunt de 2 tipuri:

Liste simplu inlantuite (liste unidirectionale);

Liste dublu inlantuite (liste bidirectionale);
In lista simplu inlantuita fiecare element contine un pointer
care pointeaza spre elementul urmator si deci o celula a listei
 este o structura cu autoreferire, tipul careia se va defini
astfel:
// Structura unui element dintr-o lista simplu inlantuita

Struct Element { // datele efective memorate

Int Date valoare;

// legatura catre nodul urmator

Element* next;};

Informatia pastrata de structura pentru simplitate vom

considera ca reprezinta o variabila de tip intreg Date , care
va fi de fapt o cheie cu ajutorul careia poate fi determinata
celula. Pointerul *next este un pointer de legatura a celulei
cu celula urmatoare a listei.

Se observa ca lista poate fi parcursa intr-o singura

directie: de la inceputul ei spre sfirsit.De obicei listele se
parcurg prin cicluri si acesarea elementului urmator. Vom
considera ca toate celulele listei au aceiasi structura, iar
pointerul din ultima celula indica spre NULL in campul *next.

Analiza datelor si a functiilor

Functia: Main()
caseDeSchimb *a=NULL; /*element pentru sortare/interschimbare*/
caseDeSchimb *b=NULL; /*element pentru sortare/interschimbare*/
caseDeSchimb *head2=NULL; /*element cap pentru divizare*/
char a1[100]; /*string 1 pentru interschimbare*/
char b1[100]; /*string 2 pentru interschimbare*/
char srch[100]; /*string pentru cautare*/
char savef[100]; /*string pentru salvare*/
char loadf[100]; /*string pentru incarcare*/
int n; /*numarul de elemente in lista*/
int m = 1; /*ciclu infinit meniu principal*/
int com1; /*indice pentru meniu pricipal*/
int mod; /*indice pentru modificare*/
int id_devide; /*indice pentru devizare*/
int id_before; /*indice pentru adaugare inaintea indicelui*/
int id_after; /*indice pentru adaugare dupa indice*/
int id_delete; /*indice pentru stergere a elemenentului*/
Functia: int create(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: void read(void) si void show(void);

c variabila locala de tip pointer la strucura
i -Variabila locala de tip integer, numarul de ordine a elementului in lista

Functia: void showSearchcaseDeSchimb(char* s);

c variabila locala de tip pointer la strucura
denu variabila locala de tip pointer la character, adresa sirul de caractere introdus
de la tastatura
Valoarea returnabila: de tip pointer la structura

Functia: void sort(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: void modify(int id)

nm- variabila locala de tip integer, numarul de orine pentru modificare
i-variabile locale de tip integer, indicele elementului in contor
cm,cm1- variabile locale de tip integer, optiuni pentru alegere din meniuri
Valoarea returnabila: void

Functia: int append(caseDeSchimb ap) si int prepend(caseDeSchimb pp)

c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura
ap- variabila de tip structura, elemntul nou de adaugat
pp- variabila de tip structura, elemntul nou de adaugat

Functia: void deletel (int id)

i- 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: void swap(caseDeSchimb *a, caseDeSchimb *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 date.
 Functia: void length(void)
l- variabila locala de tip integer, lungimea listei simplu inlantuite
c-variabila locala de tip pointer la structura

Functia: int save( char *fname) si void load( 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
Valoarea returnabila:la functia save de tip integer
la functia load de tip void

Functia: void freemem(void)

c- variabila locala de tip pointer la structura
p- variabila locala de tip pointer la structura
Valoarea returnabila: void

Functia: void join(caseDeSchimb **head_2);

head_2- variabila locala de tip pointer la pointer la structura, adresa variabilei in
memorie unde este salvata adresa capului listei 2.
c- variabila locala de tip pointer la structura

Fisierul lab23.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct caseDeSchimb {

char numeCasa[100];
char adresa[100];
char directorul[100];
int nrTotalValute;
float baniiInLeiRamasi;
struct caseDeSchimb *next;
} caseDeSchimb;

caseDeSchimb* head = NULL;

int create(int n);

void read_f();
void showF(caseDeSchimb* head);
void showSearchcaseDeSchimb(char* s);
caseDeSchimb* searchcaseDeSchimb(char* s);
void swap(caseDeSchimb *a,caseDeSchimb *b);
int lenght();
void sort();
caseDeSchimb* end();
void modif(int id);
void add_after_id(int id);
void add_before_id(int id);
void add_to_end();
int prepend(disciplina pp);
void delete_id(int id);
void devide(int id,caseDeSchimb** head2);
void join(caseDeSchimb** head2);
void freem();
void save(char* fname);
void load(char* fname);

Fisierul lab2_3.c
int main()
{
// MARK: Declararea variabilelor

caseDeSchimb *a=NULL; /*element pentru sortare/interschimbare*/

caseDeSchimb *b=NULL; /*element pentru sortare/interschimbare*/
caseDeSchimb *head2=NULL; /*element cap pentru divizare*/
char a1[100]; /*string 1 pentru interschimbare*/
char b1[100]; /*string 2 pentru interschimbare*/
char srch[100]; /*string pentru cautare*/
char savef[100]; /*string pentru salvare*/
char loadf[100]; /*string pentru incarcare*/
int n; /*numarul de elemente in lista*/
int m = 1; /*ciclu infinit meniu principal*/
int com1; /*indice pentru meniu pricipal*/
int mod; /*indice pentru modificare*/
int id_devide; /*indice pentru devizare*/
int id_before; /*indice pentru adaugare inaintea indicelui*/
int id_after; /*indice pentru adaugare dupa indice*/
int id_delete; /*indice pentru stergere a elemenentului*/

// MARK: Meniul

while(1)
{
while(m)
{
m=0;
system("clear");
printf("--------------------------------Creare-----------------------\n" );
printf("1.Crearea listei si introducerea datelor manual\n" );
printf("2.Crearea listei si introduucerea datelor din fisier\n\n");
printf("-------------------Functiile De: Prelucrare----------------\n");
printf("3.--------------------------Afisarea listei----------------------\n");
printf("4.--------Sortarea listei dupa BaniiInLeiRamasi---------\n");
printf("5.----------------Modificarea unui element---------------\n");
printf("6.----------------Interschimbarea elementelor------------\n");
printf("7.--------------------Cautarea unui element---------------\n");
printf("8.-----------Devizarea elementelor in doua liste---------\n");
printf("9.--------------Unirea a doua liste cu elemente--------\n\n");
printf("------------Functiile De: Adaugare \&&\ Stergere-------\n");
printf("10.--------Adaugarea elementuui inaintea indicelui---\n");
printf("11.---------Adaugarea elementului dupa indice---------\n");
printf("12.----------Adaugarea elementului la sfirsitul listei----\n");
printf("13.-----------------Stergea unui element-----------------\n\n");
printf("------------Functiile De: Salvare \&&\ Iesire-----------\n");
printf("14.---------------------Salvarea in fisier----------------------\n");
printf("15.---------------------Salvare si Iesire-----------------------\n");
printf("---------------------------------------------------- \n");
printf("\nDati comanda\n>");
scanf("%d",&com1);
switch(com1)
{
case 1:
system("cls");
if(head)
{
printf("Memoria este deja alocata\n");
system("pause");
m=1;
break;
}
system("cls");
printf("Dati numarul de elemente in lista\n>");
scanf("%d",&n);
create(n);
read_f();
if(head)
{
system("cls");
printf("Lista a fost creata cu succes!\a\n");
system("pause");
m=1;
break;
}
case 2:
system("cls");
if(head)
{
printf("Memoria este deja alocata\n");
system("pause");
m=1;
break;
}
printf("Dati numele fisierului\n>");
fflush(stdin);
gets(loadf);
strcat(loadf,".txt");
 load(loadf);
printf("\aIntroducerea a fost efectuata cu succes!\n");
m = 1;
system("pause");
break;
case 3:
system("cls");
if(!head)
{
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
system("pause");
m=1;
break;
case 4:
system("cls");
if(!head)
{
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
sort();
printf("Lista a fost sortata cu succes!\a\n");
system("pause");
m=1;
break;
case 5:
system("cls");
if(!head)
{
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
printf("\nDati indicile elementului pentru modificare\n>");
scanf("%d",&mod);
system("cls");
modif(mod);
printf("Modificara a avut loc cu succes!\a\n");
m=1;
system("pause");
break;
case 6:
system("cls");
if(!head)
{
 printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
printf("Dati numele primului element pentru interschimbare\n>");
fflush(stdin);
gets(a1);
a = searchcaseDeSchimb(a1);
printf("Dati numele primului element pentru interschimbare\n>");
fflush(stdin);
gets(b1);
b = searchcaseDeSchimb(b1);
system("cls");
swap(a,b);
printf("Interschimbarea a avut loc cu succes!\a\n");
m=1;
system("pause");
break;
case 7:
system("cls");
if(!head)
{
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
printf("Dati denumirea\\modelul\\originea pentru cautare\n>");
fflush(stdin);
gets(srch);
showSearchcaseDeSchimb(srch);
m=1;
system("pause");
break;
case 8:
system("cls");
if(!head)
{
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
printf("\nIntrodu indicile de unde lista v-a fi despartita\n");
scanf("%d",&id_devide);
if(lenght() > 1 && id_devide>0 && id_devide < lenght()){
devide(id_devide,&head2);
}
printf("Devizarea a fost efectuata cu succes!\a\n");
showF(head);
showF(head2);
 m=1;
system("pause");
break;
case 9:
system("cls");
if(!head){
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
if(head2){
join(&head2);
printf("Unirea a avut loc cu succes\n");
}
else {
printf("\aMai intii lista trebuie despartita!\n");
}
m=1;
system("pause");
break;
case 10:
system("cls");
if(!head){
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
printf("\nIntrodu numarul de ordine:\n");
scanf("%d",&id_before);
if(id_before > 0 && id_before <= lenght() ){
system("cls");
add_before_id(id_before);
}
else {
printf("\aAti introdus un numar iesit din intervalul existent\n");
}
system("cls");
printf("Adaugarea s-a efectuat cu succes!\a\n");
m=1;
system("pause");
break;
case 11:
system("cls");
if(!head){
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
printf("\nIntrodu numarul de ordine:\n");
 scanf("%d",&id_after);
if(id_after > 0 && id_after <= lenght() ){
system("cls");
add_after_id(id_after);
}
else {
printf("\aAti introdus un numar iesit din intervalul existent\n");
}
system("cls");
printf("Adaugarea s-a efectuat cu succes!\a\n");
m=1;
system("pause");
break;
case 12:
system("cls");
if(!head){
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
add_to_end();
system("cls");
printf("Adaugarea s-a efectuat cu succes!\a\n");
m=1;
system("pause");
break;
case 13:
system("cls");
if(!head){
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
showF(head);
printf("Dati indicele elementului pentru stergere\n");
scanf("%d",&id_delete);
delete_id(id_delete);
system("cls");
printf("Stergerea a fost efectuata cu succes!\a\n");
m=1;
system("pause");
break;
case 14:
system("cls");
printf("Dati numele fisierului\n>");
fflush(stdin);
gets(savef);
save(savef);
printf("\aSalvarea a fost efectuata cu succes!\n");
m=1;
system("pause");
break;
 case 15:
system("cls");
if(head)
{
printf("Dati numele fisierului\n>");
fflush(stdin);
gets(savef);
save(savef);
printf("\aSalvarea a fost efectuata cu succes!\n");
system("pause");
freem();
exit(1);
}
break;

default:
system("cls");
printf("Ati introdus o tasta incorecta!\a\n");
m=1;
system("pause");
break;
}
}
}
return 0;
}

Fisierul lab23.c
int create(int n)
{
int i;
caseDeSchimb *c,*p;
for(i=0;i<n;i++)
{
c=(caseDeSchimb*)malloc(sizeof(caseDeSchimb));
if(c == NULL) return 0;
if(i == 0)
{
head=c;
p=c;
}
else
{
p->next=c;
p=c;
}
}
p->next=NULL;
return 1;
}
void read_f()
{
caseDeSchimb *c=head;
int i=0;
while(c)
{
printf("\n****************************************\n\n");
printf("Introdu datele caseDeSchimbului %d\n",i+1);
printf("Numele: ");
scanf("%s",&c->numeCasa);
printf("Adresa: ");
scanf("%s",&c->adresa);
printf("Directorul: ");
scanf("%s",&c->directorul);
printf(" Numarul total de valute: ");
scanf("%d",&c->nrTotalValute);
printf("Banii in lei ramasi: ");
scanf("%f",&c->baniiInLeiRamasi);

c=c->next;
i++;
}
}

void showF(caseDeSchimb* head)

{
caseDeSchimb* c=head;
int i=0;
while(c)
{
printf("****************************************\n\n");
printf("Datele caseDeSchimbului: %d\n",i+1);
printf("Numele: %s\n",c->numeCasa);
printf("Adresa: %s\n",c->adresa);
printf("Directorul: %s\n",c->directorul);
printf("Nr totatl de valute: %d\n",c->nrTotalValute);
printf("Banii in lei ramasi($): %.2f\n\n",c->baniiInLeiRamasi);
printf("Adresa : %p\n",c);
printf("Adresa elementului urmator: %p\n",c->next);
c=c->next;
i++;
}
}

void showSearchcaseDeSchimb(char* s)
{
caseDeSchimb *c=head;
int i=0,k=0;
while(c)
{
if((strcmp(s,c->numeCasa)==0) || (strcmp(s,c->adresa)==0 ) ||
(strcmp(s,c->directorul)==0))
{
 printf("****************************************\n\n");
printf("Datele caseDeSchimbului: %d\n",i+1);
printf("Numele: %s\n",c->numeCasa);
printf("Adresa: %s\n",c->adresa);
printf("Directorul: %s\n",c->directorul);
printf("Nr totatl de valute: %d\n",c->nrTotalValute);
printf("Banii in lei ramasi($): %.2f\n\n",c->baniiInLeiRamasi);
k++;
}
c=c->next;
i++;
}
if(k==0)
printf("Elementul nu a fost gasit!\n");
}
int prepend(caseDeSchimb pp) {
disciplina *t;
t = (caseDeSchimb*)malloc(sizeof(*t));
if(!t) { return 0; }
t->next = head;
head = t;
*t = pp; // last()-next = head; pentru circulara

return 1;
}

caseDeSchimb* searchcaseDeSchimb(char* s)
{
caseDeSchimb* c=head;
int k=0;
while(c)
{
if(strcmp(s,c->numeCasa)==0 || strcmp(s,c->adresa)==0 || strcmp(s,c-
>directorul)==0)
{
return c;
k++;
}
c=c->next;
}
if(k==0)
{
printf("Nu exista asa CasaDeSchimb!\n");
}
return NULL;
}

void swap(caseDeSchimb *a,caseDeSchimb *b)

{
caseDeSchimb t,*na,*nb;
na=a->next;
nb=b->next;
t=*a;
 *a=*b;
*b=t;
a->next=na;
b->next=nb;
}

int lenght()
{
caseDeSchimb *c=head;
int i=0;
while(c)
{
i++;
c=c->next;
}
return i;
}

void sort()
{
caseDeSchimb *a,*b;
int i,k,l;
l=lenght();
for(i=0;i<l-1;i++)
{
a=head;
b=a->next;
for(k=0;k<l-1-i;k++)
{
if(a->baniiInLeiRamasi < b->baniiInLeiRamasi)
{
swap(a,b);
}
a=a->next;
b=b->next;
}
}
}

caseDeSchimb* end()
{
caseDeSchimb* c;
c=head;
while(c->next)
{
c=c->next;
}
return c;
}

void modif(int id)

{
caseDeSchimb* c=head;
int i=0;
 while(c)
{
if(i+1 == id)
{
printf("Datele caseDeSchimbului %d pentru modificare:\n",i+1);
printf("Numele: ");
scanf("%s",&c->numeCasa);
printf("Adresa: ");
scanf("%s",&c->adresa);
printf("directorul ");
scanf("%s",&c->directorul);
printf("Nr toatal Val: ");
scanf("%d",&c->nrTotalValute);
printf("Banii in lei ramasi: ");
scanf("%f",&c->baniiInLeiRamasi);
}
c=c->next;
i++;
}
}

void add_after_id(int id)

{
caseDeSchimb *c=head,*p;
int i=0;
while(c){
if(i == id-1){
p=c;
c=(caseDeSchimb*)malloc(sizeof(caseDeSchimb));
printf("\n****************************************\n\n");
printf("Introdu datele caseDeSchimbului %d\n",i+2);
printf("Numele: ");
scanf("%s",&c->numeCasa);
printf("adresa: ");
scanf("%s",&c->adresa);
printf("directorul: ");
scanf("%s",&c->directorul);
printf("nrTotalValute: ");
scanf("%d",&c->nrTotalValute);
printf("Banii in lei ramasi: ");
scanf("%f",&c->baniiInLeiRamasi);
c->next=p->next;
p->next=c;
break;
}
i++;
c=c->next;
}
}

void add_before_id(int id){

caseDeSchimb *c=head,*p;
int i=0;
while(c){
 if(i == id-1){
p=c;
c=(caseDeSchimb*)malloc(sizeof(caseDeSchimb));
printf("\n****************************************\n\n");
printf("Introdu datele caseDeSchimbului %d\n",i-2);
printf("Numele: ");
scanf("%s",&c->numeCasa);
printf("adresa: ");
scanf("%s",&c->adresa);
printf("directorul: ");
scanf("%s",&c->directorul);
printf("NrTotalValute: ");
scanf("%d",&c->nrTotalValute);
printf("BaniiInLeiRamasi: ");
scanf("%f",&c->baniiInLeiRamasi);
if(p == head){
c->next=head;
head=c;
break;
}
else {
c->next=p;
i=0;
p=head;
while(p){
if(i == id-2){
p->next=c;
}
i++;
p=p->next;
}
break;
}
}
i++;
c=c->next;
}
}

void add_to_end(){
caseDeSchimb *c=head,*p;
while(c){
if(c->next == NULL){
p=c;
c=(caseDeSchimb*)malloc(sizeof(caseDeSchimb));
printf("\n****************************************\n\n");
printf("Introdu datele casei \n");
printf("Numele: ");
scanf("%s",&c->numeCasa);
printf("adresa: ");
scanf("%s",&c->adresa);
printf("directorul: ");
scanf("%s",&c->directorul);
printf("nrTotalValute: ");
 scanf("%d",&c->nrTotalValute);
printf("baniiInLeiRamasiul($): ");
scanf("%f",&c->baniiInLeiRamasi);
p->next=c;
c->next=NULL;
break;
}
c=c->next;
}
}

void delete_id(int id){

caseDeSchimb *c=head,*p;
int i=0;
while(c){
if(i == id-1){
if(c == head){
head=c->next;
free(c);
break;
} else if(c->next == NULL){
p=head;
while(p){
if(p->next == c){
free(c);
p->next=NULL;
break;
}
p=p->next;
}
} else {
p=head;
while(p){
if(p->next == c){
p->next=c->next;
free(c);
break;
}
p=p->next;
}
}
}
i++;
c=c->next;
}
}

void devide(int id,caseDeSchimb** head2){

caseDeSchimb *c=head;
int i=0;
while(c){
if(i == id-1){
*head2=c->next;
c->next=NULL;
 break;
}
i++;
c=c->next;
}
}
void join(caseDeSchimb** head2){
caseDeSchimb *c=head;
while(c){
if(c->next == NULL){
c->next=*head2;
break;
}
c=c->next;
}
*head2=NULL;
}
void freem()
{
caseDeSchimb *c=head,*p;
while(c)
{
p=c;
c=c->next;
free(p);
if(c == NULL)
{
break;
}
}
head=NULL;
}

void save(char* fname)

{
caseDeSchimb*c=head;
FILE *txt=fopen(fname,"wt");
while(c)
{
fprintf(txt,"%s %s %s %d %.2f %p %p",c->numeCasa,c->adresa,c-
>directorul,c->nrTotalValute,c->baniiInLeiRamasi,c,c->next);
if(c->next != NULL)
{
fprintf(txt, "\n");
}
c=c->next;
}
fclose(txt);
}

void load(char* fname)

{
caseDeSchimb* c,*p;
int i=0;
 FILE *txt=fopen(fname,"r");
if(!txt)
{
printf("Fisierul nu exista!\a\n");
}
while(!feof(txt))
{
c=(caseDeSchimb*)malloc(sizeof(caseDeSchimb));
if(c == NULL)
{
printf("\aMemoria nu a fost alocata\n");
}
if(i == 0)
{
head=c;
p=c;
}
else
{
p->next=c;
p=c;
}
fscanf(txt,"%s%s%s%d%f",&c->numeCasa,&c->adresa,&c->directorul,&c-
>nrTotalValute,&c->baniiInLeiRamasi);
i++;
}
p->next=NULL;
fclose(txt);
}
Concluzii:

1. n urma efecturii acestui program am acumulat deprinderi practice de

creare i implementare a tipului abstract de date in limbajul C . Utilizind
tipuri abstracte pentru principalele structuri de date, tragem atentie in
 special, la algoritmii din ce este compus progrumul. In urma lucrului mi-
am perfectionat cunostintele in limbajul C.
2. Rezultatele obinute au demonstrat aplicarea corecta a cunostinelor
teoretice despre prelucrarea listelor simplu inlantuite in limbajul C.
3. Functiile din aceasta lucrare de laborator sunt universale, ele pot fi
folosite atit pentru orice tip de lista unidimensionala.
4. Avantajul folosirii listelor consta in gestionarea dinamica a memoriei.
Nodurile se aloca dimanic de utilizator si ele pot fi atit adaugate cit si
sterse.
5. Realizind aceasta lucrare de laborator ajungem la concluzia ca legatura
dintre nodurile invecinate trebuie facuta logic, explicit de catre
programator, prin plasarea informatiilor de legatura in fiecare nod (pe
linga valoarea utila).
6. Indeplinind aceasta lucrare putem compara listele si tablourile, intelegand
avantajele si dezavantajele fiecarui mod de stocare a datelor in calculator.

Bibliografie:
1. Conspectul prelegerilor la SDA pentru studentii anului I, specialitatea
calculatoare

2. Calculatoare, anul de studii 2011-2012 ( lector dr. conf.univer. M.Kulev);