MINISTERUL EDUCAŢIEI REPUBLICII MOLDOVA

UNIVERSITATEA TEHNICĂ A MOLDOVEI

Facultatea „Calculatoare, Informatică şi
Microelectronică”

RAPORT
Lucrare de laborator nr. 2-3
la Structuri de Date si Algoritmi

A efectuat:
st. gr. AI-182 Croitoru Tudor

A verificat:
dr., conf. univ. Sorin Botnaru

2019

1
 Laborator 2-3

Subiect: Un tip de date abstract "simplu listă". Crearea, intrarea și ieșirea, elementul de
căutare, editarea elementului, schimbarea a două elemente, sortarea, ștergerea memoriei.
Sarcină: Creați trei fișiere în limba C pentru implementarea și utilizarea ADT «pur și simplu»
la tema specificată în laboratorul operațiilor de procesare.

1. Un fișier de rubrică .h pentru a descrie elementul structurii de date a listei (în variante) și,
de asemenea, pentru prototipurile de funcții care furnizează operațiuni de bază pentru
procesarea listei.
2. Un fișier cu extensie .cpp pentru o anumită funcție (funcții de text), declarată în fișierul
antet.
3. Un fișier de utilizator - funcția principală () pentru procesare prin lista specificată în
subiectul operațiilor de laborator, afișând meniul pe ecran pentru acele operații.
Varianta Nr. 5 :
Structura Marfa
(Aleg :Nume,masa,pret,cantitate)

Set de operațiuni pe o listă inlantuita.

  
Un dezavantaj al utilizării matricelor pentru stocarea datelor este faptul că matricele sunt
structuri statice și, prin urmare, nu pot fi ușor extinse sau reduse pentru a se potrivi cu setul de
date. Arrays sunt, de asemenea, costisitoare pentru a menține inserții și ștergeri noi. În acest
capitol considerăm o altă structură de date numită Liste de legături care abordează unele
dintre limitările matricelor.

O listă legată este o structură de date liniară unde fiecare element este un obiect separat.

Fiecare element (îl vom numi nod) dintr-o listă cuprinde două elemente - datele și o referință
la nodul următor. Ultimul nod are o referință la nul. Punctul de intrare într-o listă legată este
numit capul listei. Trebuie remarcat faptul că capul nu este un nod separat, ci referința la
primul nod. Dacă lista este goală atunci capul este o referință nulă.

O listă legată este o structură de date dinamică. Numărul de noduri dintr-o listă nu este fix și
poate să crească și să se micșoreze la cerere. Orice aplicație care are de a face cu un număr
necunoscut de obiecte va trebui să utilizeze o listă legată.

Un dezavantaj al unei liste asociate cu o matrice este că nu permite accesul direct la

elementele individuale. Dacă doriți să accesați un anumit element, atunci trebuie să începeți la
cap și să urmați referințele până când ajungeți la elementul respectiv.

2
Un alt dezavantaj este că o listă legată utilizează mai multă comparație de memorie cu o
matrice - avem 4 octeți suplimentari (pe procesor pe 32 de biți) pentru a stoca o referință la
următorul nod.
Tipuri de liste inlantuite

O lista simpla inlantuita este descrisă mai sus

O listă dubla inlantuita este o listă care are două referințe, unul la nodul următor și altul la
nodul anterior.

Un alt tip important de listă legată este numit listă circulară în care ultimul nod al listei revine
la primul nod (sau capul) listei.

Listele inlantuite au câteva avantaje față de matrice:

• Elementele pot fi adăugate sau eliminate din mijlocul listei

• Nu este nevoie să definiți o dimensiune inițială
• Cu toate acestea, listele legate au, de asemenea, câteva dezavantaje:
• Nu există acces "aleatoriu" - este imposibil să ajungeți la cel de-al treilea element din
matrice fără a mai itera mai întâi toate elementele până la acel element. Aceasta înseamnă că
trebuie să începem de la începutul listei și să numărăm de câte ori avansăm în listă până când
ajungem la elementul dorit.
• Este necesară alocarea dinamică a memoriei și indicatorii, ceea ce complică codul și
crește riscul de scurgeri de memorie și de defecțiuni în segment.
• Listele conectate au o atitudine mult mai mare decât arrays, deoarece elementele
listate legate sunt alocate dinamic (ceea ce este mai puțin eficient în utilizarea memoriei) și
fiecare articol din listă trebuie să stocheze și un indicator suplimentar.

Analiza datelor
Date de intrare:
a, b, k, - pointer la elementul de structură;
p - simple variabile, pointeri,
B, Marfa - indicatorul elementelor de structură, indicând adresa cărții
 num_menu - simplu var de integer tip, numărul de opțiune
n - simplu var de tip întreg, lungimea listei legate
t, nr, value - variabilă simplă a tipului de date întreg, pentru schimbul de date
i - tipul de date întreg, variabila intermediară
k, k1, k2 variabile simple de tip întreg, pentru schimbul de date
v [40], fname [25], u [30], o [20], z [20] - variabile compuse de tip char

3
Functiile: (declaratia)

int create(int n) – creeaza lista inlantuita, ia un parametru intreg si returneaza un numar (un
intreg) care reprezinta numarul elementelor din lista inlantuita

n- variabila simpla a intregului tip, numar de elemente ale listei legate

void readinfo(void) – funcția de a pune informații în elementele listării de link-uri, nu are o

valoare de returnare (returnează void), doar ia informația de la tastatură

void show(void) – funcția de afișare a datelor pe ecran. Valoarea returnată este nulă

book *search(char *v) - căutarea unui element în matrice după numele lui. Adresa de retur a
cărții respective
v – indicatorul tipului de caractere care stochează numele cărții

void swap(marfa *a, book *b) – schimbarea a două elemente (cărți) ale listei legate care sunt
indicate de utilizator.
a, b – indicatorul care indică o adresă a linkului

void sort (void) – sortarea elementelor (cărții) a listelor asociate după nume.

void modify(marfa *B) – modificați un element / marfa listei legate, care este indicată de
utilizator.
a – pointer, adresa elementului care urmează să fie modificat

void append() - adaugă o marfa la sfârșitul listei legate, returnând valoarea void

void prepend() – prependent un element, îl pune la început; valoarea de returnare este

nevalidă
int insertafter(book *a, int value) – introduce o marfa nouă după una indicată. Returnează
un număr întreg.
marfa *insertbefore(marfa *a, int value) – introduce o marfa nouă după una indicată.
Returnați adresa cărții.
marfa *delet(marfa *a) - ștergerea unei marfe din lista asociată; returnează adresa cărții.
int write(marfa * B,int n,char *fname) – scrierea / salvarea elementelor dintr-o listă într-un
fișier. Returnează un număr întreg (0 dacă codul este executat cu succes, altfel 1)
fname - pointer de tip char pentru stocarea numelui elementului.

int read(char *fname) – citirea / încărcarea elementelor dintr-o listă într-un fișier.
Returnează un număr întreg
int length(void) – returnează un număr întreg, lungimea listei legate

marfa *end(void) – determină ultimul element al listei legate; returnează adresa elementului
respectiv
void freemem(void) –funcția de eliberare a memoriei. Returnează nimic, este vid.

void readItem(int,marfa *) – citește informațiile despre marfa din tastatură. Valoarea

returnată este nulă. Utilizează două parammetre: un număr întreg, indică numărul cărții și un
indicator, adică adresa elementului nou
void dividel(marfa **head1, book **head2,int p)– Avem câteva date, această comandă face
2 liste diferite.
4
void joinl(marfa **head1,book **head2)- Am făcut 2 liste diferite, după care se alăture
două liste.

Implemmentation of program in C :

Fișier de antet care constă în descrierea proprietăților reale ale obiectelor și a

prototipurilor de funcții care funcționează și care au aceste proprietăți (date):
header.h_____________________________________________

#ifndef HEADER_FILE
#define HEADER_FILE

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

///Structure///
typedef struct marfa
{
char nume[20];
float pret;
float masa;
int cantitate;
struct marfa *next;
} marfa;

marfa *head;

int create(int n);

void readinfo(void);
void show(void);
void readItem(marfa*,int i);
marfa *search(char *v);
void modify(marfa *B);
void swap(marfa *a, marfa *b);
int length(void);
void sort (void);
void append();
void prepend();
int insertafter(marfa * a, int value);
marfa * insertbefore(marfa *a, int value);
void delet(marfa *a);
void dividel(marfa **head1,marfa **head2,int p);
void joinl(marfa **head1,marfa **head2);
int write(marfa * B,int n,char *fname);
int read(char *fname);
void freemem(void);
marfa * end(void);
5
#endif

functions.c_________________________________________
#include "lista.h"

int length(void)
{
marfa *b;
int l;
b=head;
l=0;
while(b)
{
l++;
b=b->next;
if(b==head) break;
}
return l;
}

int create(int n)
{
marfa *b,*p;
int i;
for(i=0; i<n; i++)
{
b=(marfa*)malloc(sizeof(*b));
if (!b) return 0;
if (i==0){ head =b;}
else { p -> next =b;}
p=b;

}
b->next =NULL;
}

void readinfo(void)
{
marfa *b;
int i=0;
b=head;
puts("Introduce-ti informatie despre marfa:");
while(b){
readItem(b,i);
b=b->next;
if(b==head)
break;
i++;
}
}

6
void readItem (marfa *b,int i)
{
printf("\nMarfa %d:\n",i+1);
printf("Denumirea:");
fflush(stdin);
gets(b->nume);
printf("Pretul:");
scanf("%f",&b->pret);
printf("Masa:");
scanf("%f",&b->masa);
printf("Cantitatea:");
scanf("%d",&b->cantitate);

void show(void)
{
marfa *b;
int i=0;
b=head;
puts("Informatia despre marfa :");
while(b){
printf("\tMarfa%d\n\t\n \tDenumirea: %s\n\tPretul:
%f\n\tMasa: %f\n\tCantitate:%d\n\t ", i+1, b->nume,b->pret, b-
>masa,b->cantitate);
b=b->next;
if(b==head)break;
i++;
}
}

marfa *search(char *v)

{
marfa *b=head;
while(b)
{
if(strcmp(b->nume,v)==0)
{return b;}
b=b->next;
if(b==head)
break;
}
return NULL;
}

void swap(marfa *a, marfa *b)

{
marfa *na, *nb;
marfa t;
na = a-> next;
nb = b->next;
t = *a;
7
 *a = *b;
*b = t;
a -> next = na;
b->next = nb;

}
void sort(void)
{marfa *a,*b;
int i,k; int l;
l=length();
for(i=0;i<l-1;i++)
{
a=head;
b=a->next;
for(k=0;k<l-1-i;k++)
{if(strcmp(a->nume,b->nume)>0)
{swap(a,b);}
a=a->next;
b=b->next;}
}
}

void modify(marfa *B)

{ char ans;
puts(" \nDoriti sa modificati numele ?: Yes(y) or No(n)
");
ans = getch();
if (ans == 'y')
{ printf(" Numele nou: ");
fflush(stdin);
gets(B->nume);
}
puts(" \nDoriti sa modificati pretul ? : Yes(y) or No(n)
");
ans = getch();
if (ans == 'y')
{
printf(" Pretul nou: ");
fflush(stdin);
scanf("%f",&B->pret);
}

puts(" \nDoriti sa modificati masa marfei ? : Yes(y) or

No(n) ");
ans = getch();
if (ans == 'y')
{
printf(" Masa noua a marfei este : ");
scanf("%f", &B->masa);
}
puts(" \nDoriti sa modificati cantitatea ?: Yes(y) or
No(n) ");
ans = getch();
8
 if (ans == 'y')
{
printf(" Cantitatea noua este : ");
scanf("%d", &B->cantitate);
}
return;
}

void delet(marfa *a)

{
marfa *p;
if (head == a)
{
head = head->next;
}
else{

p = head;
while (p->next !=a)
{
p = p->next;
}
p->next = a->next;
}
free(a);

}
int savels(char *fname)
{
FILE *fp;
int i,n;
n = length();
printf("n=%d\n",n);
marfa *B;
fp = fopen(fname, "w");
if (!fp)
{
return 0;
}
B = head;
printf("B=%p\n",B);
for(i=0; i<n; i++)
{
// printf("B=%p\n",B);
// printf("i=%d\n",i);
fprintf(fp,"\tMarfa%d\n\t\n \tDenumirea:
%s\n\tPretul: %f\n\tMasa: %f\n\tCantitate:%d\n\t ", i+1, B-
>nume,B->pret, B->masa,B->cantitate);
B = B->next;
printf("B=%p\n",B);
if (B == head);
}
fclose(fp);
9
 return 1;
}

int loadl1(char *fname)

{
FILE *fp;
int n,i;
char ch;
marfa *b;
n = length();
fp = fopen(fname, "r");
if (!fp) return 0;
b = head;
printf("\nDatele din file %s este :\n\n", fname);
while( ( ch = fgetc(fp) ) != EOF )
printf("%c",ch);
fclose(fp);
return 1;
}

void append()
{
int i;
marfa *b;
marfa *last;
b = (marfa*)malloc (sizeof(marfa));
if (!b) return ;
last = end();
readItem(b,i);
last->next = b;
b->next = NULL;

void prepend()
{
int i;
marfa *b;
b = (marfa*)malloc (sizeof(marfa));
if (!b) return ;
readItem(b,i);
b->next = head;
head = b;

marfa * end(void)
{
marfa *e;
e = head;
while(e-> next && e ->next != head){
e = e->next;
}
10
 return e;
}

int insertafter(marfa * a, int value)

{ int i;
marfa *b;
b = (marfa *) malloc(sizeof(*b));
if (!b) return 0;
readItem(b,i);
b->next = a->next;
a->next = b;
return 1;
}

marfa * insertbefore(marfa *a, int value)

{ int i;
marfa *b, *p;
b = (marfa *)malloc(sizeof(*b));
if (!b) return 0;
readItem(b,i);
if (head ==a){
b->next = a;
head;
}
else{
p = head;
while (p->next !=a)
{
p = p->next;
}
b->next = a;
p->next = b;
}
return head;
}
void dividel(marfa **head1,marfa **head2,int p)
{
int i=0;

marfa *current=head;
while(i<p-1)
{

i++;
current=current->next;}
*head1=head;
*head2=current->next;
head=NULL;
current->next=NULL;

11
void joinl(marfa **head1,marfa **head2)
{
marfa *c;
c=*head1;
while(c->next!=NULL)
{c=c->next;
}
c->next=*head2;
*head2=NULL;
head=*head1;
*head1=NULL;

}
void freemem(void)
{
marfa *e, *p;
e = head;
while (e)
{
p = e;
e= e->next;
free(p);
if(e ==head)
break;
}
}
main.c_______________________________________________

#include "marfa.c"

int main ()
{
int num_menu;
int n, t, nr,i, value,l;
marfa *b, *p, *a, *pr, *k ,*head2 ,*head1;
char v[50], fname[25], ch, u[30], z[30];
FILE *fp;
marfa *Marfa;
char o [30];
while (1)
{
system("cls");
system (" color e");
puts("\n\t\t MENU:\n");
puts(" \t\n1.Crearea listei inlantuite");
puts(" \t\n2.Introduce-ti informatia despre marfa") ;
puts(" \t\n3.Partaja-ti lista");
puts(" \t\n4.Cautarea unui element");
puts(" \t\n5.Interschimbarea a doua elemente");
puts(" \t\n6.Sortarea marfurilor");
puts(" \t\n7.Modificarea unui element");

12
puts(" \t\n8.Stergerea unui element");
puts(" \t\n9.Salvarea datelor curente intr-un fisier");
puts(" \t\n10.Citirea fisierului");
puts(" \t\n11.Adaugarea unui element nou la sfarsit de lista");
puts(" \t\n12.Adaugarea unui element la inceput de lista");
puts(" \t\n13.Introducerea unui element dupa alt element");
puts(" \t\n14.Introducerea unui element inainte altui
element");
puts(" \t\n15.Lungimea listei(numarul de elemente)");
puts(" \t\n16.Divizarea listei in doua subliste");
puts(" \t\n17.Unirea celor doua subliste");
puts(" \t\n18.Eliberarea memoriei");
puts(" \t\n0. Exit\n");
scanf(" %d", &num_menu);

switch(num_menu)
{
case 0:
free(p);
p = NULL;
return 0;

case 1:
system("cls");
system (" color a");
printf( " Cate marfe sunt ? : \t");
scanf ( " %d", &n);
create(n);
puts("\nMemoria a fost alocata cu succes\n");
puts("Pentru a continua tastati enter");
getch();
break;
getch();
break;

////////////////////////////////////////////
case 2:
system("cls");
system("color b");

readinfo();
puts("\nPentru a continua tastati enter");
getch();
break;
////////////////////////////////////////////
case 3:
system("cls");
system("color c");

show();
puts("\nPentru a continua tastati enter");
getch();
break;
13
case 4:
system("cls");
system (" color c");
printf(" \nIntroduce-ti marfa care doriti sa o cautati:");
fflush(stdin);
gets(v);
Marfa = search(v);
if( Marfa ) {
puts("\n\t Informatie despre marfa : \n ");
printf("\tMarfa\n\t\n \tDenumirea: %s\n\tPretul: %f\n\tMasa:
%f\n\tCantitate:%d\n\t ",Marfa->nume,Marfa->pret, Marfa-
>masa,Marfa->cantitate);
}

else {
printf(" Marfa: %s nu a fost gasita", v);
}

puts("\nPentru a continua tastati enter");

getch();
break;

case 5:
{

system("cls");
system (" color c");
printf("Da-ti denumirea la prima marfa: ");
fflush(stdin);
gets(v);
a=search(v);

if(!a) {
printf("\nAsa marfa nu exista");
break;
}

printf("Da-ti denumirea la a doua marfa: ");

fflush(stdin);
gets(v);
b=search(v);

if(!b) {
printf("\nAsa marfa nu exista");
break;
}

swap(a,b);

printf("\nMarfele au fost interschimbate cu succes");

puts(" \n\nPentru a le vedea tastati :\n Da(y) or Nu(n)");
char o = getch();

14
if (o=='y') {
show();
}

getch();
break;
}
case 6:
{
system("cls");
system("color c");

sort();
printf("Marferele au fost sortate cu succes\n");
puts("\nPentru a afisa noua lista tastati :\nYes(y) or NO(n)");
char z = getch();

if (z=='y') {
show();
}

puts("\nPentru a continua tastati ENTER...");

getch();
break;
}

case 7:
system("cls");
system("color c");
printf("Introduce-ti numele la marfa care doriti sa-l
modificati:");
fflush(stdin);
gets(v);
a=search(v);
modify(a);
puts("Modificarea a fost efectuata cu succes");
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 8:
system("cls");
system("color c");
printf("Introduce-ti elementul ce doriti sa-l stergeti:");
fflush(stdin);
gets(v);
a=search(v);
delet(a);
puts("\n\t\tElementul a fost cu succes stearsa din lista");
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 9:
system("cls");
15
system("color a");

printf("Da-ti un nume pentru file:\n");

fflush(stdin);
gets(fname);
savels(fname);
puts("\nPentru a continua tastati ENTER...");
getch( );
break;
case 10 :
system("cls");
printf("Da-ti numele la fisier ce doriti sa-l cititi :\n");
fflush(stdin);
gets(fname);
loadl1(fname);
puts("\nPentru a continua tastati ENTER...");
getch();
break;

case 11 :
system("cls");
append();
puts("\nPentru a continua tastati ENTER...");
getch();
break;

case 12 :
system("cls");
prepend();
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 13:
system("cls");
if (head!= NULL) {
printf("Introduceti numele la marfa dupa care doriti sa fie
introdusa marfa noua: ");
fflush(stdin);
gets(u);
a=search(u);
insertafter(a,value);
} else {
printf("Lista e goala");
}
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 14:
system("cls");

if (head!= NULL) {
printf("Introduceti numele la marfa inaintea caruia doriti sa
fie introdusa marfa noua: ");
16
fflush(stdin);
gets(u);
a=search(u);
insertbefore(a,value);
} else {
puts("\nLista este goala");
}
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 15:
system("cls");
l = length();
printf("\n\n\tLungimea listei este: %d", l);
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 16 :
system("cls");
int divide_p;
puts("Introduce-ti pozitia de unde sa se divida lista");
scanf("%d", &divide_p);
dividel(&head1,&head2,divide_p);
puts("Lista a fost divizata .Sublistele sunt :");
puts("\n\n*********Sublista 1**********");
head=head1;
show();
puts("\n\n*********Sublista 2***********");
head=head2;
show();
getch();
head=NULL;
break;
case 17 :
system("cls");
joinl(&head1,&head2);
show();
puts("\nPentru a continua tastati ENTER...");
getch();
break;
case 18:
system("cls");
freemem();
puts("\n\tMemoria a fost eliberata cu succes");
puts("\nPentru a continua tastati ENTER...");
getch();
break;
default :
puts("\n Asa optiune nu exista");
getch();
break;
}
}
17
}
Screenshots(rezultatul si rularea programului)

- Menu central:

- Crearea liste inlantuite:

- Introducerea informatiei despre marfe:

18
-Partajarea datelor :

- Cautarea elementului in lista:

19
- Interschimbarea a doua elemente:

- Sortarea elementelor dupa nume:

20
 - Modificarea elementului

//Lista schimbata

21
- Stergerea unui element:

- Salvarea in fisier:

- Citirea dintr-un fisier:

- Adaugarea unui element(inceput):

22
 - Adaugarea unui element(sfarsit):

- Introducerea unui element dupa altuia:

- Introducerea unui element inaintea altuia:

- Lungimea listei (numarul de elemente):

//Alegem functia 3(partajarea listei) pentru a ne convinge

23
 - Divizarea in doua subliste:

- Unirea a doua subliste:

24
 - Eliberarea memoriei:

-Exit:

25
File lab23.txt_______________________________

Conclusia:

Acest program vă permite să editați toate datele din baza de date: să adăugați cărți noi, să le
editați, să le adăugați, să le ștergeți, să le sortați și în final aveți posibilitatea să salvați toate
informațiile într-un fișier și să le citiți dintr-un fișier . A fost o practică bună pentru structuri și
fișiere.
Am folosit lista legată și am putut observa câteva avantaje ale acestora, cum ar fi:
• Nu este necesar să cunoașteți în avans numărul de elemente care trebuie stocate în listă și,
prin urmare, nu trebuie alocat. d și când este necesar.
• Într-o listă legată, inserările și ștergerile pot fi manipulate eficient fără a fixa dimensiunea
memoriei în avans.
• Un avantaj important al listelor conectate prin intermediul rețelelor este faptul că lista
conectată utilizează exact aceeași memorie de care are nevoie și poate fi extinsă pentru a
umple toate locațiile de memorie disponibile dacă este necesar.
De asemenea, am observat unele dezavantaje ale acestora, ca:
• Traversarea este secvențială.
• Creșterea cheltuielilor pentru stocarea indicatorilor pentru conectarea elementelor de date.

Bibliography

1. http://cprogramminglanguage.net/
2. „The C programming language” By Brian W. Kernighan and Dennis M. Ritchie
3. Conspects on Computer Programming of Lector dr., conf. univ. M.Kulev. Chișinău:
UTM, 2014.
4. http://www.programiz.com/c-programming/c-file-input-output
5. http://www.programiz.com/c-programming/c-structures
6. http://www.cprogramming.com/tutorial/c/lesson7.html
7. http://www.codingunit.com/c-tutorial-structures-unions-typedef
8. https://www.youtube.com/watch?
v=38I_AUMpKpQ&index=50&list=PL6gx4Cwl9DGAKIXv8Yr6nhGJ9Vlcjyymq

26