Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnica a Moldovei

Catedra Informatică Aplicată

Raport
Lucrare de laborator Nr.2-3
Tema: Prelucrarea tipului abstract de date.
Liste simplu înlănțuite

A efectuat: st. gr. SI-121 D.Stratan

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

Chișinău 2013
 1. Lucrare de laborator Nr. 2-3

Tema: Prelucrarea tipului abstract de date. Liste simplu înlănțuite

2. Scopul lucrării: Implementarea tipului abstract de date. Scrierea programului destinat

prelucrării listei simplu înlănțuite.
3. Formularea problemei.

Având data structura „Obiect” cu câmpurile:

 Denumirea
 Catedra
 Facultatea
 Anul
 Numărul de ore
De efectuat un program care va fi menit sa alcătuiască o lista simpla înlănțuită ce va conține
aceste câmpuri si le va putea procesa după diferiți parametri.

4. Mersul lucrării
4.1 Descrierea scurta a teoriei care se refera la tema lucrării de laborator si metode
folosite.
Structura de date listă
În cadrul structurilor avansate de date, structura listă ocupă un loc important. O listă,
este o structură dinamică, care se defineşte pornind de la noţiunea de vector.
Elementele unei liste sunt toate de acelaşi tip şi sunt înregistrate în memoria centrală a
sistemului de calcul. Spre deosebire de structura statică tablou la care se impune ca
numărul componentelor să fie constant, în cazul listelor acest număr poate fi variabil,
chiar nul. Listele sunt structuri flexibile particulare, care funcţie de necesităţi pot c r e ş t e
sau descreşte şi ale căror elemente pot fi referite, inserate sau şterse î n o r i c e poziţie
din cadrul listei. Două sau mai multe liste pot fi concatenate sau scindate în subliste. În
practica programării listele apar în mod obişnuit în aplicaţii referitoare la regăsirea
informaţiei, implementarea translatoarelor de programe, simulare etc.
TDA Listă
Din punct de vedere matematic, o listă este o secvenţă de zero sau mai multe
elemente numite noduri aparţinând unui anumit tip numit tip de bază, care se
reprezintă de regulă astfel : a1, a2,...,an Unde n ≥ 0 şi fiecare ai aparţine tipului de bază.
Numărul n al nodurilor se numeşte lungimea l istei. Presupunând că n ≥ 1, se
spune că a1 est e primul nod al listei iar an est e ultimul nod. Dacă n = 0 avem de-a
face cu o listă vidă. O proprietate importantă a unei liste este aceea că nodurile sale pot fi
ordonate liniar funcţie de poziţia lor în cadrul listei. Se spune că ai precede pe ai+1
pentru i=1,2,...,n-1 ş i c ă ai succede (urmează) lui ai-1 pentru i=2,3,4, ...,n. De regulă se
spune că nodul ai se află pe poziţia i. Este de asemenea convenabil să se postuleze
existenţa poziţiei următoare ultimului element al listei. În această idee se introduce
 funcţia FIN(L):Tip Poziție care returnează poziţia următoare poziţiei n în l ista L având n
elemente. Se observă că FIN(L) are o distanţă variabilă faţă de începutul listei, funcţie
de faptul că lista creşte sau se reduce, în timp ce alte poziţii au o distanţă fixă faţă de
începutul listei. Pentru a defini un tip de date abstract, în cazul de faţă TDA Listă,Pe
lângă definirea din punct de vedere matematic a modelului asociat (mai sus
precizată)Este necesar să se definească şi un set de operatori aplicabili obiectelor de tip l
istă. Din păcate, pe de o parte este relativ greu de definit un set de operatori valabil în
toate aplicaţiile, iar pe de altă parte natura setului depinde esenţial de maniera de
implementare a listelor. În continuare se prezintă două seturi reprezentative de operatori
care acţionează asupra listelor, unul restrâns şi altul extins.

4.4 Textul programului in limbajul C

Prima parte salvată in extensia .h
typedef struct obiect
{
char den[50],cat[50],fac[50];
int an,nr_ore;
struct obiect *next;
}obiect;

obiect *aloc(int n);

void in(obiect *head,obiect *o);
void out(obiect head);
obiect *search(obiect *head,char a);
int sort(obiect **head);
void modific(obiect *head,char *num);
obiect *addtoend(obiect *head,char v);
int swapp(obiect **head,int k1,int k2);
int lenght(obiect *head);

int addtohead(obiect *head);

int insert(obiect **head,obiect *p,obiect *el);
void delet(obiect **head,obiect *a);
void devide(obiect *head,obiect *head2,int n1);
obiect *connect(obiect *head,obiect **head2);

int save(obiect *head,char *filename);

obiect *loadd(char *filename);
void free(obiect **head);

A doua parte salvata in extensia .cpp

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

obiect *aloc(int n)
{
obiect *head,*o=NULL;
int i=1;
o=(obiect*)malloc(sizeof(obiect));
head=o;
o->next=NULL;
if(!o){ puts("memoria nu a fost alocata");
return 0;
}
while(i<n)
{
o->next=(obiect*)malloc(sizeof(obiect));
o->next->next=NULL;
o=o->next;
i++;
}
return head;
}

void in(obiect *head)

{obiect *o=NULL;
int i=0;
o=head;
puts("dati informatie despre obiecte\n");
while(o)
{
printf("Numarul obiectului %d:\n",(i+1));
printf("Denumirea obiectului:");
fflush(stdin);
gets(o->den);
printf("Catedra:");
fflush(stdin);
gets(o->cat);
printf("Facultatea:");
fflush(stdin);
gets(o->fac);
printf("Anul:");
scanf("%d",&o->an);
printf("Numarul de ore:");
scanf("%d",&o->nr_ore);
o=o->next;
i++;
}
}

void out(obiect *head)

{
int i=0;
obiect *o;
o=head;
puts("Informatia despre obiect:");
while(o)
{
printf("%d Denumirea:%s Catedra:%s Facultatea:%s Anul:%d Nr de
ore:%d\n",i+1,
o->den,o->cat,o->fac,o->an,o->nr_ore);
o=o->next;
i++;
}}

obiect *search(obiect *head,char *a)

{obiect *o;
int i=0;
o=head;
while(o)
{
if (strcmpi(a,o->den)==0)
{return o;
}
o=o->next;
} return NULL;}

int sort(obiect **head)

{
obiect *o=*head, *m=NULL, *x;
int k1=1, k2;
if(!o) return 0;
while(o)
{ k2=k1+1;
m=o->next;
while(m)
{if(strcmpi(o->den,m->den)>0 )
{
swapp(head,k1,k2);
x=m;
o=m;
m=x;
}
k2++;
o=o->next;
}
k1++;
o=o->next;
}
return 1;
}

void modific(obiect *head,char *num)

{
obiect *pos=head;
clrscr();

while(pos)
{
if (!strcmpi(pos->den,num))
{
printf("Dati denumirea noua a obiectului:");
fflush(stdin);
gets(pos->den);
printf("Dati denumirea noua a catedrei");
fflush(stdin);
gets(pos->cat);
printf("Dati denumirea noua a facultatii");
fflush(stdin);
gets(pos->fac);
printf("Introduceti noul an");
scanf("%d",&pos->an);
printf("Introduceti numarul de ore nou");
scanf("%d",&pos->nr_ore);
}
pos=pos->next;
}

obiect *addtoend(obiect *head)

{obiect *o,*p=head;
o=(obiect*)malloc(sizeof(obiect));
o->next=NULL;
if(!o)
return o;
if(!head)
{ head=o;
}
else {
 while(p->next) p=p->next;
p->next=o;
}
puts("Itroduceti datele");
printf("Denumirea obiectului:");
fflush(stdin);
gets(o->den);
printf("Catedra:");
fflush(stdin);
gets(o->cat);
printf("Facultatea:");
fflush(stdin);
gets(o->fac);
printf("Anul:");
scanf("%d",&o->an);
printf("Numarul de ore:");
scanf("%d",&o->nr_ore);
return head;
}

int swapp(obiect **head,int k1,int k2)

{
obiect *o=*head,*a=NULL, *b=NULL, *x=NULL;
int i=0;
if(k1<=0 || k2<=0) return 0;
else if(k2<k1)
{
k1 ^= k2;
k2 ^= k1;
k1 ^= k2;
}
else if(k1==k2) return 1;

while(o)
{
i++;
if(i+1==k1) a=o;
if(i+1==k2)
{
b=o;
if(!b->next) return 0;
break;
 }

o=o->next;
}

if( (!a && k1>1) || !b) return 0;

if(k1==1)
{
x=*head;
*head=b->next;
b->next=x;
x=b->next->next;
b->next->next=(*head)->next;
(*head)->next=x;
}
else
{
x=a->next;
a->next=b->next;
b->next=x;

x=b->next->next;
b->next->next=a->next->next;
a->next->next=x;
}

return 1;
}

int lenght(obiect *head)

{int n=0;
obiect *o;
o=head;
while(o)
{ n++;
o=o->next;
}
return n;
}

int addtohead(obiect **head)

{obiect *o;
o=(obiect*)malloc(sizeof(*o));
if(!o)
{puts("memoria nu a fost alocata");
return 0;
}
if(*head==NULL)
{
*head=o;
o->next=NULL;
}
else
{o->next=*head ;
*head=o;
}
puts("Itroduceti datele");
printf("Denumirea obiectului:");
fflush(stdin);
gets(o->den);
printf("Catedra:");
fflush(stdin);
gets(o->cat);
printf("Facultatea:");
fflush(stdin);
gets(o->fac);
printf("Anul:");
scanf("%d",&o->an);
printf("Numarul de ore:");
scanf("%d",&o->nr_ore);
return 1;
}

int insert(obiect **head, obiect *p, obiect *el)

{
obiect *o=*head;
if(!p || !o) return 0;
if(p==o)
{
el->next=*head;
*head=el;
return 1;
}
while(o)
{
if(o->next==p)
{
el->next=o->next;
o->next=el;
return 1;
}
o=o->next;
 }

return 0;

int delet(obiect **head,char *num)

{ obiect *p=NULL,*o=*head;
if(0==strcmpi(o->den,num))
{
p=*head;
*head=(*head)->next;
free(p);
return 1;
}
while(o)
{ if(strcmpi(o->den,num))
{
p=o->next;
o->next=o->next->next;
free(p);
return 1;
}
o=o->next;}
return 0;}

int devide(obiect **head,obiect **head2,int n1)

{
int i=0;
obiect *o;
if(n1<0) return 0;
*head2=*head;
if(n1==0) *head=NULL;
else while(*head2 && ++i<=n1)
{
o=*head2;
*head2=(*head2)->next;
}
if(n1>i) return 0;
o->next=NULL;
return 1;
}

obiect *connect(obiect *head,obiect **head2)

{
obiect *o;
o=head;
while(head && head->next) head=head->next;
head->next=*head2;
return o;
}

int save(obiect *head, char *filename)

{
FILE *fp;

if( !(fp=fopen(filename,"w")) ) return 0;

while(head)
{
fprintf(fp,"%s,%s,%s,%d,%d",head->den,
head->fac,
head->cat,
head->an,
head->nr_ore);
head=head->next;
if(head) fprintf(fp,"\n");
}
fclose(fp);
return 1;
}

obiect *loadd(char *filename)

{
FILE *fp;
obiect *head=NULL, *o=NULL, *x=NULL;

if( !(fp=fopen(filename,"r")) ) return NULL;

while(!feof(fp))
{
o=(obiect *)malloc(sizeof(obiect));
if(!o) return NULL;
o->next=NULL;
fscanf(fp,"%[^,]%*c%[^,]%*c%[^,]%*c%d*c%d%*c",o->den,
o->cat,
o->fac,
&(o->an),
&(o->nr_ore) );
 if(!head) x=head=o;
else
{
x->next=o;
x=o;
}
}
fclose(fp);
return head;
}

void free(obiect **head)

{
obiect *o;
while(*head)
{
o=*head;
*head=(*head)->next;
free(o);
}
*head=NULL;
}

A treia parte salvata in extensia .cpp(int main-ul)

#include"petea1.cpp"
int main()
{
obiect *buff;
obiect *head=NULL,*o=NULL,*head2=NULL,*head1=NULL;
int n,nm,y,k1,k2,n1;
char fisier[50];
char den[50],f[50];
while (1)
{puts("/t Meniu /n");
puts("1.Alocare dinamica a listei");
puts("2.Introducerea elementelor");
puts("3.Afisarea listei");
puts("4.Cautarea unu element");
puts("5.Sortarea listei");
puts("6.Modificarea listei");
puts("7.Adaugarea unui element la sfirshitul listei");
puts("8.Interschimbarea a doua elemente");
puts("9.Determinarea lungimei listei");
puts("10.Adaugarea unui element la capul listei");
puts("11.Inserarea unui element");
puts("12.Stergerea unui elemnt");
puts("13.Impartirea listei in doua");
puts("14.Alipirea a doua liste");
puts("15.Salvarea listei");
puts("16.Citirea listei");
puts("0.Eliberarea memoriei si exit");
printf("dati nm:");
scanf("%d",&nm);
clrscr();
switch(nm)
{
case 1:{
printf("dati numaru de elemente:");
scanf("%d",&n);
head=aloc(n);
getch();
break;}
case 2:{
in(head);
getch();
break; }
case 3:{
out(head);
getch();
break; }
case 4: {
printf("dati denumirea:");
fflush(stdin);
gets(f);
o=search(head,f);
printf("Denumirea %s,facultatea %s,catedra %s,Anul %d,Numaru de
ore%d",o->den,
o->fac,o->cat,o->an,o->nr_ore);
getch();
break;
}
case 5:{
if(n>1)
{sort(&head);
puts("Tabloul o fost sortat"); }
else puts("nu ajung elemnte");
getch();}
break;
case 6:{
printf("doriti sa modificati(1/0)");
scanf("%d",&y);
if(y)
{printf("dati denumierea obiectului");
 fflush(stdin);
gets(den);
modific(head,den);
}
getch();
break; }
case 7:{
head=addtoend(head);
getch();
break;}
case 8: {
printf(" Introduceti termenii care doriti sa fie skimbati");
scanf("%d%d",&k1,&k2);
swapp(&head,k1,k2);
getch();
break;}
case 9:
{
n=lenght(head);
printf("%d",n);
getch();
break;
}

case 10:{
addtohead(&head);
getch();
break;
}
case 11:
if(!head)
{puts(" Eroare: Nu a fost introdus nici un element.");
getch();
break;
}
printf("Introduceti destinatia unde doriti sa faceti inserarea:");
fflush(stdin);
gets(den);
buff=aloc(1);
if(insert(&head,search(head,den),buff))
{
puts("introduceti denumirea:");
fflush(stdin);
gets(buff->den);

puts("Introduceti facultatea");
fflush(stdin);
 gets(buff->fac);
printf("Introduceti catedra");
fflush(stdin);
gets(buff->cat);

printf("Introduceti anul");
scanf("%d",&(buff->an));
printf("Introduceti numarul de ore");
scanf("%d",&(buff->nr_ore));
}

else
{
puts("Elementul nu a putut fi inserat.");
free(buff);
}
getch();
break;

case 12:
printf("itnroduceti ce doriti sa stergeti");
fflush(stdin);
gets(den);
delet(&head,den);
getch();
break;

case 13:if(!head)
{
puts(" Eroare: Nu a fost introdus nici un element.");
getch();
break;
}
printf(" Nr. de elemente de lasat in prima lista:");
scanf("%d",&n1);
if(devide(&head,&head2,n1) );
{
puts("Lista a fost divizata.Tastati 1 pentru a afisa a 2a
lista...");
if(getch()=='1')
{
int i=0;
clrscr();
 printf("\n Nr | Denumirea | Fac | Cat | An | Nr_ore
|\n");
while(head)
{
i++;
printf(" %-3d|%-15s|%-19s|%-16s|%-9d|%-10d|\n",i,head->den,
head->cat,head->fac,head->an,head->nr_ore );
head=head->next;
}
}
else
{puts(" Eroare: Ati introdus un numar gresit");
} }
getch();
break;

case 14:
if(!head && !head2)
{
puts(" Eroare: Nu a fost introdus nici un element.");
getch();
break;
}
head=connect(head1,&head2);
puts(" Listele au fost reunite");
getch();
break;

case 15:if(!head)
{
puts(" Eroare: Nu a fost introdus nici un element.");
getch();
break;
}
printf("Introdu denumirea fisierului:");
fflush(stdin);
gets(fisier);
if(save(head,fisier)) puts("Lista a fost salvata");
else puts("Lista nu a putut fi salvata.");
getch();
break;
case 16:{ if(head)
{
puts(" Lista contine date.");
getch();
break;
}
 printf("Introdu denumirea fisierului:");
fflush(stdin);
gets(fisier);
head=loadd(fisier);
if (head)
puts("Lista a fost citita.");
else puts("Fisierul dat nu a fost gasit.");
getch();
break;
}

case 0: {
free(&head);
return 0; }
Default: puts("Alegeti corect obtiunea");
getch();
} }}

5.5 Verificarea si analiza rezultatelor,concluzii

Verificarea datelor ne demonstrează ca algoritmul merge fără defecte ca si in programul făcut
precedent in lab.7
Meniul :

Introducerea datelor :
Afișarea datelor :

Inserarea unui obiect ;

Concluzii: 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.
Deasemenea verificarea rezultatelor demonstreaza ca valoariile primite sunt adevarate ceea
ce arata ca programul lucreaza .
7. Bibliografie
1.Conspectul prelegerilor la structuri de date si algoritm pentru studentii anului I,
specialitatea Calculatoare, anul de studii 2011 ( lector dr., conf.univer. M.Kulev).
2.V. Creţu, "Structuri de date şi tehnici de programare", Litografia Institutului Politehnic
"Traian Vuia" Timişoara, 1987