Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Calculatoare si Retele

RAPORT
Lucrarea de laborator nr.2-3
la disciplina Structuri de date și Algoritmi

A efectuat:
st. gr. CR-182 Mardari I.
A verificat: Munteanu S.

Chişinău – 2019

Lucrare de laborator 2-3

Tema: Implementarea tipului de date abstract “Lista simplu inlantuita” in C
Scopul lucrarii: obtinerea deprinderilor practice de implementare a unui tip de
date abstract (TDA) in limbajul C si anume a TDA “Lista simplu inlantuita”
Sarcina de lucru: De scris trei fisiere in limbajul C pentru implementarea (2
fisiere) si utilizarea (1 fisier – program cu functia main ) a TDA “Lista simplu
inlantuita”:
1. Fișierul antet cu extensia .h care descrie structura de date a elementului
listei simplu inlantuite (conform variantei din lucrare precedenta) și
prototipurile funcțiilor care asigură operațiunile de prelucrare a listei simplu
inlantuite.
2. Fișier cu extensia .cpp (sau .c) care contine codurile (implementarile)
tuturor functiilor declarate în fișierul antet.
3. Fișierul utilizatorului - programul cu funcția main () pentru prelucrarea listei
simplu inlantuite cu afisarea meniului de optiuni pe ecran, si anume:
 pentru lucrare de laborator 2- crearea listei simplu inlantuite in memoria
dinamica, introducerea informatiei despre elementele listei de la tastatura,
afisarea informatiei despre elementele listei pe ecran, cautarea elementului listei
dupa unui cimp informational, modificarea cimpurilor elementului listei,
interschimbarea a 2 elemente listei, determinarea lungimei listei, sortarea
elementelor listei dupa unui cimp, eliberarea memoriei dinamice alocate pntru
lista, ieșire din program;
pentru lucrare de laborator 3- adaugarea unui element nou la sfirsitul listei,
adaugarea unui element nou la începutul listei, inserarea unui element nou in lista
dupa elementul indicat, inserarea unui element nou in lista inainte elementul
indicat, stergerea unui element al listei, divizarea listei simplu inlantuite in doua
liste separate, unirea a 2 liste simlu inlantuite intr-o singura lista, scrierea
informatiei despre elementele listei in fisier, citirea informatiei despre elementele
listei din fișier, ieșire din program.

Mersul lucrării:
Noţiuni principale din teorie şi metode folosite:
O listă simplu înlănţuită este o colecţie de noduri aşezate într-o ordine liniară (dar
NU în locaţii succesive din memorie - aşa cum se întâmplă la vectori). Fiecare nod
are cel puţin un pointer către următorul nod, pe care îl vom numi next. Primul nod
se numeşte head,. Lista se numeşte simplu înlănţuită deoarece fiecare nod
memorează un singur pointer către următorul nod. Spre deosebire de vectori, lista
nu are o mărime fixă. Poate fi redimensionată prin adăugarea sau ştergerea
nodurilor. Un nod este ca un obiect (item) care conţine atât informaţia pe care vreţi
s-o stocaţi cât şi legătura către următorul obiect.
Datorită faptului ca elementele listei sunt stocate în diferite părți ale memoriei
calculatorului sunt ușurate anumite operații cu lista, de exemplu inserarea sau
ștergerea unui element al listei nu necesită mișcarea celorlalte elemente pentru a
face loc sau pentru a strînge lista, așa cum se întîmplă la vectori de exemplu.
Exemplu de bază de date în formă de listă simplu înlănțuită:
typedef struct film
{
char marca[40];
char model[40];
char origine[40];
int anu;
float pret;
struct film *next;
}film;
film* head=NULL;
Fisierul film.h
typedef struct film
{
char denumire[40];
char durata[40];
char origine[40];
int anu;
float pret;
struct film *next;
}film;
film* head=NULL;
int create(int n);
Functia de creare a listei simplu inlantuita necirculara,primenste ca
paramentru „n” care este numarul de elemente care urmeaza a fi
alocate.
void read();
Funcita de introducere a elementelor in lista simplu inlantuita
necirculara.
film* search(char* s);
Functia de cautare in lista simplu inlantuita necirculara dupa un
cimp al structurii.Primeste ca parametru adresa la string-ul
introdus de utilizator si returneaza elementele gasite.
void show_search();
Funcita de afisare a elementelor cautate cu ajutorul functiei
search(char*);
void show(film* head);
Funtia de afisarea tuturor elemente din lista simplu inlantuita
necirculara avind ca paramentru capul listei.
void swap(film* a,film* b);
Functia de interschimbare a a doua elemente intre ele in lista
simplu inlantuita necirculara avind 2 parametri fiind elemente a
listei.
void sort();
Functia de sortare dupa pret(cimp al structurii).
int length();
Functia care determina lungimea listei simplu inlantuite
necirculare returneaza o valoare de tip int care reprezinta
lungimea listei.
film* end();
Funtia care determina care este ultimul elemente din lista simplu
inlantuita necirculara returnind adresa acestui element.
void add_after_id(int id);
Functia de adaugare a elementelor dupa indicele indicat de
utilizator in lista simplu inlantuita necirculara,are ca
paramentru indicele tastat de utilizator.
void add_before_id(int id);
Functia de adaugare a elementelor inainte de indicele indicat de
utilizator in lista simplu inlantuita necirculara,are ca
paramentru indicele tastat de utilizator.
void add_to_end();
Functia de adaugare a elementelor la sfirsit de lista simplu
inlantuita necirculara.
void delete_id(int id);
Funcita de stergere a unui element din lista simplu inlantuita
necirculara.
void devide(int id,film** head2);
Functia care devizeaza lista in doua liste,are 2 parametri,primul
ste o variabila de tip int care reprezinta indicile deunde lista
v-a fi devizata,ia al doilea este adresa elementului care urmeaza
sa fie capul listei 2*/
void join(film** head2);
Functia de unire a listei in doua,are ca parametru adresa
elementului care este capul listei 2.
void modif(int id);
Funcita de modificare a unui element din lista simplu inlantuita
necirculara,avind ca parametru o variabila de tip int care este
indicile elementului care urmeaza a fi modificat.
void save(char* s);
Funcitia de salvare a informatiei din lista simplu inlantuita
necirculara in fisier,are ca paramentru adresa la string-ul
introdus de utilizator care reprezinta numele fisierului.
void load(char* s);
Funcitia de incarcare a informatiei din fisier in lista simplu
inltantuita necirculare,are ca paramentru adresa la string-ul
introdus de utilizator care reprezinta numele fisierului.
void freem();
Funcita de eliberearea memoriei,distrugerea listei simplu
inlantuite necirculare.

Fisierul functii.cpp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "film.h"
int create(int n)
{
int i;
film *c,*p;
for(i=0;i<n;i++)
{
c=(film*)malloc(sizeof(film));
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()
{
film *c=head;
int i=0;
while(c)
{
printf("\n****************************************\n\n");
printf("Introdu datele filmului %d\n",i+1);
printf("Denumirea: ");
scanf("%s",&c->denumire);
printf("Durata: ");
scanf("%s",&c->durata);
printf("Originea: ");
scanf("%s",&c->origine);
printf("Anul de productie: ");
scanf("%d",&c->anu);
printf("Pretul($): ");
scanf("%f",&c->pret);
c=c->next;
i++;
}
}

void show(film* head)

{
film* c=head;
int i=0;
while(c)
{
printf("****************************************\n\n");
 printf("Datele filmului: %d\n",i+1);
printf("Denumirea: %s\n",c->denumire);
printf("Durata: %s\n",c->durata);
printf("Originea: %s\n",c->origine);
printf("Anul de productie: %d\n",c->anu);
printf("Pretul($): %.2f\n\n",c->pret);
printf("Adresa curenta: %p\n",c);
printf("Adresa elementului urmator: %p\n",c->next);
c=c->next;
i++;
}
}

void show_search(char* s)
{
film *c=head;
int i=0,k=0;
while(c)
{
if((strcmp(s,c->denumire)==0) || (strcmp(s,c->durata)==0 ) || (strcmp(s,c-
>origine)==0))
{
printf("****************************************\n\n");
printf("Datele filmului: %d\n",i+1);
printf("Denumire: %s\n",c->denumire);
printf("Durata: %s\n",c->durata);
printf("Originea: %s\n",c->origine);
printf("Anul de productie: %d\n",c->anu);
printf("Pretul($): %.2f\n\n",c->pret);
k++;
}
c=c->next;
i++;
}
if(k==0)
printf("Elementul nu a fost gasit!\n");
}

film* search(char* s)
{
film* c=head;
int k=0;
while(c)
{
if(strcmp(s,c->denumire)==0 || strcmp(s,c->durata)==0 || strcmp(s,c-
>origine)==0)
{
return c;
k++;
}
c=c->next;
}
if(k==0)
{
 printf("Nu exista asa film!\n");
}
return NULL;
}

void swap(film *a,film *b)

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

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

void sort()
{
film *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->pret < b->pret)
{
swap(a,b);
}
a=a->next;
b=b->next;
}
}
}

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

void modif(int id)

{
film* c=head;
int i=0;
while(c)
{
if(i+1 == id)
{
printf("Datele filmului %d pentru modificare:\n",i+1);
printf("Denumirea: ");
scanf("%s",&c->denumire);
printf("Durata: ");
scanf("%s",&c->durata);
printf("Originea: ");
scanf("%s",&c->origine);
printf("Anul de productie: ");
scanf("%d",&c->anu);
printf("Pretul($): ");
scanf("%f",&c->pret);
}
c=c->next;
i++;
}
}

void add_after_id(int id)

{
film *c=head,*p;
int i=0;
while(c){
if(i == id-1){
p=c;
c=(film*)malloc(sizeof(film));
printf("\n****************************************\n\n");
printf("Introdu datele filmului %d\n",i+2);
printf("Denumire: ");
scanf("%s",&c->denumire);
printf("Durata: ");
scanf("%s",&c->durata);
printf("Originea: ");
scanf("%s",&c->origine);
printf("Anul de productie: ");
scanf("%d",&c->anu);
printf("Pretul($): ");
scanf("%f",&c->pret);
c->next=p->next;
p->next=c;
 break;
}
i++;
c=c->next;
}
}

void add_before_id(int id){

film *c=head,*p;
int i=0;
while(c){
if(i == id-1){
p=c;
c=(film*)malloc(sizeof(film));
printf("\n****************************************\n\n");
printf("Introdu datele filmului %d\n",i-2);
printf("Denumire: ");
scanf("%s",&c->denumire);
printf("Durata: ");
scanf("%s",&c->durata);
printf("Originea: ");
scanf("%s",&c->origine);
printf("Anul de productie: ");
scanf("%d",&c->anu);
printf("Pretul($): ");
scanf("%f",&c->pret);
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(){
film *c=head,*p;
while(c){
if(c->next == NULL){
 p=c;
c=(film*)malloc(sizeof(film));
printf("\n****************************************\n\n");
printf("Introdu datele filmului\n");
printf("Denumire: ");
scanf("%s",&c->denumire);
printf("Durata: ");
scanf("%s",&c->durata);
printf("Originea: ");
scanf("%s",&c->origine);
printf("Anul de productie: ");
scanf("%d",&c->anu);
printf("Pretul($): ");
scanf("%f",&c->pret);
p->next=c;
c->next=NULL;
break;
}
c=c->next;
}
}

void delete_id(int id){

film *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,film** head2){

film *c=head;
int i=0;
while(c){
if(i == id-1){
*head2=c->next;
c->next=NULL;
break;
}
i++;
c=c->next;
}
}

void join(film** head2){

film *c=head;
while(c){
if(c->next == NULL){
c->next=*head2;
break;
}
c=c->next;
}
*head2=NULL;
}

void freem()
{
film *c=head,*p;
while(c)
{
p=c;
c=c->next;
free(p);
if(c == NULL)
{
break;
}
}
head=NULL;
}

void save(char* fname)

{
film*c=head;
FILE *txt=fopen(fname,"wt");
while(c)
{
fprintf(txt,"%s %s %s %d %.2f %p %p",c->denumire,c->durata,c->origine,c-
>anu,c->pret,c,c->next);
 if(c->next != NULL)
{
fprintf(txt, "\n");
}
c=c->next;
}
fclose(txt);
}

void load(char* fname)

{
film* c,*p;
int i=0;
FILE *txt=fopen(fname,"r");
if(!txt)
{
printf("Fisierul nu exista!\a\n");
}
while(!feof(txt))
{
c=(film*)malloc(sizeof(film));
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->denumire,&c->durata,&c->origine,&c->anu,&c-
>pret);
i++;
}
p->next=NULL;
fclose(txt);
}

Fisierul main.cpp
#include "function.cpp"
int main()
{
film *a=NULL;/*element pentru sortare/interschimbare*/
film *b=NULL;/*element pentru sortare/interschimbare*/
film *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;/*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*/
while(1)
{
while(m)
{
m=0;
system("cls");
printf("-----------------------Creare-----------------------\n");
printf("1.Crearea listei si introducerea datelor manual\n");
printf("2.Crearea listei si introduucerea datelor din
fisier\n\n");
printf("---------------------Preaucrare---------------------\n");
printf("3.Afisarea listei\n");
printf("4.Sortarea listei dupa pret\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("-----------------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("--------------------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();
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;
}
show(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;
}
show(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;
}
show(head);
printf("Dati numele primului element pentru
interschimbare\n>");
fflush(stdin);
gets(a1);
a=search(a1);
printf("Dati numele primului element pentru
interschimbare\n>");
fflush(stdin);
gets(b1);
b=search(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\\durata\\originea pentru
cautare\n>");
fflush(stdin);
gets(srch);
show_search(srch);
m=1;
system("pause");
break;
case 8:
system("cls");
if(!head)
{
printf("Lista nu exista!\a\n");
m=1;
system("pause");
break;
}
show(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");
show(head);
show(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;
}
show(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;
}
show(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;
}
show(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");
puts("GOOD BYE");
system("pause");
freem();
 exit(1);
}
break;

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

Concluzii:
1. Au fost obținute deprinderi de creare a unei baze de date abstractizate utilizînd
lista simplu înlănțuită în limbajul C.
2. Au fost obținute deprinderi de prelucrare a listei simplu înlănțuite, adaugarea
elementelor, stergerea, afisarea, sortarea, cautarea, interschimbarea etc.
3. Au fost obținute deprinderi de salvare a datelor în fișiere și citirea datelor din
ele.
4. Au fost obținute deprinderi de creare a fișierelor antet cu extensia .h, fișierelor
cu funcții cu extensia .c și includerea lor în proiect.
Bibliografie:
• Conspectul prelegerilor cursului Structuri de date și Algoritmi. Lector dr.,
conf. univ. M. Kulev. Chișinău: UTM, 2014.
• https://en.wikipedia.org/wiki/Linked_list accesat la 07.03.2015