Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra Informatic Aplicat

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

A efectuat:
st. gr. SI-141

E. Cucu

A verificat:
dr., conf.univ., catedra IA

M. Kulev

Chiinu 2015

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. Fiierul antet cu extensia .h care descrie structura de date a elementului
listei simplu inlantuite (conform variantei din lucrare precedenta) i
prototipurile funciilor care asigur operaiunile de prelucrare a listei simplu
inlantuite.
2. Fiier cu extensia .cpp (sau .c) care contine codurile (implementarile)
tuturor functiilor declarate n fiierul antet.
3. Fiierul utilizatorului - programul cu funcia 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, ieire 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 fiier, ieire din program.

Mersul lucrrii:
Noiuni principale din teorie i metode folosite:
O list simplu nlnuit este o colecie de noduri aezate ntr-o ordine liniar (dar
NU n locaii succesive din memorie - aa cum se ntmpl la vectori). Fiecare nod
are cel puin un pointer ctre urmtorul nod, pe care l vom numi next. Primul nod
se numete head,. Lista se numete simplu nlnuit deoarece fiecare nod
memoreaz un singur pointer ctre urmtorul nod. Spre deosebire de vectori, lista
nu are o mrime fix. Poate fi redimensionat prin adugarea sau tergerea
nodurilor. Un nod este ca un obiect (item) care conine att informaia pe care vrei
s-o stocai ct i legtura ctre urmtorul obiect.
Datorit faptului ca elementele listei sunt stocate n diferite pri ale memoriei
calculatorului sunt uurate anumite operaii cu lista, de exemplu inserarea sau
tergerea unui element al listei nu necesit micarea celorlalte elemente pentru a
face loc sau pentru a strnge lista, aa cum se ntmpl la vectori de exemplu.
Exemplu de baz de date n form de list simplu nlnuit:
typedef struct masina
{
char marca[40];
char model[40];
char origine[40];
int anu;
float pret;
struct masina *next;
}masina;
masina* head=NULL;

Fisierul masina.h

typedef struct masina

{
char marca[40];
char model[40];
char origine[40];
int anu;
float pret;
struct masina *next;
}masina;
masina* 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.
masina* 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(masina* head);
Funtia de afisarea tuturor elemente din lista simplu inlantuita
necirculara avind ca paramentru capul listei.
void swap(masina* a,masina* 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.
masina* 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,masina** 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(masina** 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
#include
#include
#include

<stdio.h>
<stdlib.h>
<string.h>
"masina.h"

int create(int n)
{
int i;
masina *c,*p;
for(i=0;i<n;i++)
{
c=(masina*)malloc(sizeof(masina));
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()
{
masina *c=head;
int i=0;
while(c)
{
printf("\n****************************************\n\n");
printf("Introdu datele masinii %d\n",i+1);
printf("Marca: ");
scanf("%s",&c->marca);
printf("Model: ");
scanf("%s",&c->model);
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(masina* head)
{
masina* c=head;
int i=0;
while(c)
{
printf("****************************************\n\n");
printf("Datele masinii:
%d\n",i+1);
printf("Marca:
%s\n",c->marca);
printf("Model:
%s\n",c->model);
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)
{
masina *c=head;
int i=0,k=0;
while(c)
{
if((strcmp(s,c->marca)==0) || (strcmp(s,c->model)==0 ) || (strcmp(s,c>origine)==0))
{
printf("****************************************\n\n");
printf("Datele masinii:
%d\n",i+1);
printf("Marca:
%s\n",c->marca);
printf("Model:
%s\n",c->model);
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");
}
masina* search(char* s)
{
masina* c=head;
int k=0;
while(c)
{
if(strcmp(s,c->marca)==0
||
strcmp(s,c->model)==0
>origine)==0)
{
return c;
k++;
}
c=c->next;
}
if(k==0)
{
printf("Nu exista asa masini!\n");
}
return NULL;
}
void swap(masina *a,masina *b)
{
masina t,*na,*nb;
na=a->next;
nb=b->next;
t=*a;
*a=*b;
*b=t;
a->next=na;
b->next=nb;
}
int lenght()
{
masina *c=head;
int i=0;
while(c)
{
i++;
c=c->next;
}
return i;

||

strcmp(s,c-

}
void sort()
{
masina *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;
}
}
}
masina* end()
{
masina* c;
c=head;
while(c->next)
{
c=c->next;
}
return c;
}
void modif(int id)
{
masina* c=head;
int i=0;
while(c)
{
if(i+1 == id)
{
printf("Datele masinii %d pentru modificare:\n",i+1);
printf("Marca: ");
scanf("%s",&c->marca);
printf("Model: ");
scanf("%s",&c->model);
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)
{
masina *c=head,*p;
int i=0;
while(c){
if(i == id-1){
p=c;
c=(masina*)malloc(sizeof(masina));
printf("\n****************************************\n\n");
printf("Introdu datele masinii %d\n",i+2);
printf("Marca: ");
scanf("%s",&c->marca);

printf("Model: ");
scanf("%s",&c->model);
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){
masina *c=head,*p;
int i=0;
while(c){
if(i == id-1){
p=c;
c=(masina*)malloc(sizeof(masina));
printf("\n****************************************\n\n");
printf("Introdu datele masinii %d\n",i-2);
printf("Marca: ");
scanf("%s",&c->marca);
printf("Model: ");
scanf("%s",&c->model);
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(){
masina *c=head,*p;
while(c){
if(c->next == NULL){
p=c;
c=(masina*)malloc(sizeof(masina));
printf("\n****************************************\n\n");
printf("Introdu datele masinii\n");
printf("Marca: ");
scanf("%s",&c->marca);
printf("Model: ");

scanf("%s",&c->model);
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){
masina *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,masina** head2){
masina *c=head;
int i=0;
while(c){
if(i == id-1){
*head2=c->next;
c->next=NULL;
break;
}
i++;
c=c->next;
}
}
void join(masina** head2){
masina *c=head;
while(c){
if(c->next == NULL){
c->next=*head2;
break;

}
c=c->next;
}
*head2=NULL;
}
void freem()
{
masina *c=head,*p;
while(c)
{
p=c;
c=c->next;
free(p);
if(c == NULL)
{
break;
}
}
head=NULL;
}
void save(char* fname)
{
masina*c=head;
FILE *txt=fopen(fname,"wt");
while(c)
{
fprintf(txt,"%s %s %s %d
>anu,c->pret,c,c->next);
if(c->next != NULL)
{
fprintf(txt, "\n");
}
c=c->next;
}
fclose(txt);
}

%.2f

%p

%p",c->marca,c->model,c->origine,c-

void load(char* fname)

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

Fisierul main.cpp
#include "functii.cpp"
int main()
{
masina *a=NULL;/*element pentru sortare/interschimbare*/
masina *b=NULL;/*element pentru sortare/interschimbare*/
masina *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

fflush(stdin);
gets(a1);
a=search(a1);
printf("Dati numele

pentru

interschimbare\n>");

primului

element

interschimbare\n>");
fflush(stdin);
gets(b1);
b=search(b1);
system("cls");
swap(a,b);
printf("Interschimbarea

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);
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
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;

cu

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

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;

cu

}
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

system("cls");
printf("Dati numele fisierului\n>");
fflush(stdin);
gets(savef);
save(savef);
printf("\aSalvarea
a
fost
efectuata

cu

succes!\a\n");
m=1;
system("pause");
break;
case 14:

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 obinute deprinderi de creare a unei baze de date abstractizate utiliznd
lista simplu nlnuit n limbajul C.
2. Au fost obinute deprinderi de prelucrare a listei simplu nln uite, adaugarea
elementelor, stergerea, afisarea, sortarea, cautarea, interschimbarea etc.
3. Au fost obinute deprinderi de salvare a datelor n fiiere i citirea datelor din
ele.
4. Au fost obinute deprinderi de creare a fiierelor antet cu extensia .h, fi ierelor
cu funcii cu extensia .c i includerea lor n proiect.
Bibliografie:
1 Conspectul prelegerilor cursului Structuri de date i Algoritmi. Lector dr.,
conf. univ. M. Kulev. Chiinu: UTM, 2014.
2 https://en.wikipedia.org/wiki/Linked_list accesat la 07.03.2015