Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Informatica Aplicată

RAPORT
Lucrarea de laborator nr.2&3
La Structuri de date si algoritmi

A efectuat:
st. gr. TI-15X Student Name

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

Chişinău -2016
0
 Lucrarea de laborator nr.2&3

Tema: Implementarea tipului de date abstract “Lista simplu inlanţuită” in limbajul C.

Scopul lucrării: obţinerea deprinderilor practice de implementare și de utilizare a unui tip de

date abstract (TDA) in limbajul C şi anume TDA “Lista simplu inlanţuită”.

Sarcina de lucru: De scris trei fişiere in limbajul C pentru implementarea (2 fişiere) si utilizarea
(1 fişier – program cu functia main) pentru TDA “Lista simplu inlanţuită”:
1. Fişierul antet cu extensia (h) care descrie structura de date a elementului listei simplu
inlanţuite (conform variantei din lucrare precedentă) şi prototipurile funcţiilor care asigură
operaţiunile de prelucrare a listei simplu inlanţuite.
2. Fişier cu extensia (cpp sau c) care conţine codurile (implementările) tuturor funcţiilor
declarate în fişierul antet.
3. Fişierul utilizatorului - programul cu funcţia main () pentru prelucrarea listei simplu inlanţuite
cu afişarea meniului de opţiuni pe ecran si anume:
pentru lucrare de laborator 2
1)crearea listei simplu inlanţuite cu n elemente în memoria dinamică,
2)întroducerea informaţiei despre elementele listei de la tastatură,
3)afişarea informaţiei despre elementele listei pe ecran (și a adreselor elementului current și
următor),
4)căutarea elementului listei dupa unui cîmp informaţional,
5)modificarea cîmpurilor elementului listei, interschimbarea a 2 elemente listei,
6)determinarea lungimei listei,
7)sortarea elementelor listei după unui cimp,
8)eliberarea memoriei dinamice,
9)ieşire din program;
pentru lucrare de laborator 3
1)adaugarea unui element nou la sfirşitul listei,
2)adaugarea unui element nou la începutul listei,
3)inserarea unui element nou în lista după elementul indicat,
4)inserarea unui element nou în lista înainte elementul indicat,
5)stergerea unui element al listei,
6)divizarea listei simplu inlanţuite in două liste separate,
7)unirea a 2 liste simlu inlanţuite intr-o listă,
8)scrierea informaţiei despre elementele listei în fişier,
9)citirea informatiei despre elementele listei din fişier.

Varianta 10. Stat

Noţiuni teoretice

O lista este o colectie de elemente intre care este specificata cel putin o relatie de ordine. O lista
liniara simplu inlantuita este caracterizata prin faptul ca relatia de ordine definita pe multimea
elementelor este unica si totala. Ordinea elementelor pentru o astfel de lista este specificata
explicit printr-un cimp de informatie care este parte componenta a fiecarui element si indica
1
urmator, conform cu relatia de ordine definita pe multimea elementelor listei.
Aşadar, o mulţime dinamică de structuri de acelaşi tip, pentru care sunt definite una sau
mai multe relaţii de ordine cu ajutorul unor pointeri din compunerea structurilor respective, se
numeşte listă înlănţuită. În legătură cu listele înlănţuite se au în vedere următoarele aspecte: -
crearea unei liste înlănţuite; - accesul la un nod oarecare al unei liste înlănţuite; - inserarea unui
nod într-o listă înlănţuită; - ştergerea unui nod dintr-o listă înlănţuită; - ştergerea unei liste
înlănţuite. Elementele unei liste se numesc noduri. Dacă între nodurile unei liste există o singură
relaţie de ordine, atunci lista se numeşte simplu înlănţuită, iar dacă între nodurile listei sunt
definite 2 relaţii de ordine, atunci lista se numeşte dublu înlănţuită. Într-o listă simplu înlănţuită
de obicei relaţia de ordonare este cea de succesor, adică fiecare nod conţine un pointer a cărui
valoare reprezintă adresa nodului următor din listă. În mod analog se poate defini relaţia de
precedent. Într-o listă simplu înlănţuită pentru care nodurile satisfac relaţia de succesor există
totdeauna un nod şi numai unul care nu mai are succesor, precum şi un nod care nu este
succesorul nici unui alt nod. Aceste noduri formează capetele listei simplu înlănţuite. Pentru a
gestiona nodurile unei liste simplu înlănţuite, vom utiliza 2 pointeri spre cele 2 capete. Numim
prim pointerul spre nodul care nu este succesorul nici unui nod al listei şi cu ultim pointerul spre
nodul care nu are succesor. Aceşti pointeri pot fi definiţi fie ca variabile globale în cazul în care
nu se gestionează mai multe liste simplu înlănţuite în program, fie ca parametri pentru funcţiile
de prelucrare a listei în cazul în care programul gestionează mai multe liste simplu înlănţuite. În
cele ce urmează vom considera cazul în care pointerii prim şi ultim sunt variabile globale
typedef struct tnod {
declaraţii struct tnod *urm;
} TNOD;
Pointerii prim şi ultim se declară în afara oricărei funcţii prin: TNOD *prim, *ultim; De obicei ei
vor fi declaraţi înaintea definirii funcţiei main. Pointerul urm defineşte relaţia de succesor pentru
nodurile listei. Pentru fiecare nod el are ca valoare adresa nodului următor din listă cu excepţia
nodului spre care pointează variabila ultim (în acest caz urm are valoarea zero (pointerul nul)).
La crearea unei liste simplu înlănţuite se realizează următoarele:
1. Se iniţializează pointerii prim
şi ultim cu valoarea zero, deoarece lista la început este vidă.
2. Se rezervă zona de memorie în
memoria heap pentru nodul curent.
3. Se încarcă nodul curent cu datele curente,dacă există şi
apoi se trece la pasul
4. Altfel lista este creată şi se revine din funcţie. 4. Se atribuie pointerului
ultim->urm adresa din heap a nodului curent, dacă lista nu este vidă. Altfel se atribuie lui prim
această adresă.
5. Se atribuie lui ultim adresa nodului curent.
6. ultim->urm = 0
7. Procesul se
reia de la punctul 2 de mai sus pentru a adăuga un nod nou în listă

Analiza datelor
Fisierul stat.h :
typedef struct {
char nume[100];
char capitala[100];
char presedinte[100];
int populatia;
int suprafata;
struct stat* next;
}stat;
stat *head;
stat - este tipul structurii
2
stat – variabila de tip structura
Câmpurile structurii
nume- acest cimp este destinat pentru denumirea statului, avind lungimea de 100 caractere
capitala- acest cimp este destinat pentru denumirea capitalei statului , avind lungimea de 100 caractere
presedinte- acest cimp este destinat pentru denumirea presedintelui statului, avind lungimea de 100
caractere
populatia- acest cimp este destinat pentru numarul populatiei, si pastrarea datelor de tip int
suprafata- acest cimp este destinat pentru suprafata statului, si pastrarea datelor de tip int
next-variabila de tip stat care reprezinta adresa urmatorului element din lista
head – variabila globala de tip stat

stat* freem(stat* head);

Aceasta functie este de tip stat, returneza NULL
Functia elibereaza memoria prin utilizarea functiei free().
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista

void introducere(stat* head);

Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia introduce datele despre stat de la tastatura pentru adaugarea unui element nou in lista
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
Variabile locale
p – pointer de tip stat

int create(stat* head,int n);

Aceasta functie este de tip int, care returneaza head
Functia creaza lista simplu inlantuita
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
n- variabila de tip int care reprezinta numarul de elemente ale listei
Variabile locale
p – pointer de tip stat
q – pointer de tip stat

void read(stat *head,int n);

Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia introduce datele despre stat de la tastatura
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
n – variabila de tip int care reprezinta numarul de elemente ale listei
Variabile locale
p – pointer de tip stat
i – variabila intermediara simpla de tip int

void show2(stat *head);

Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia afiseza datele despre statul modificat
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
Variabile locale
p – pointer de tip stat

3
void show(stat *head);
Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia afiseza datele despre stat introduce de la tastatura
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
Variabile locale
p – pointer de tip stat
i – variabila intermediara simpla de tip int

stat* searchs(stat* head,char adr[]):

Aceasta functie este de tip stat , returneza NULL
Functia este destinata pentru cautarea in baza de date
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
adr – variabila de tip char care reprezinta adresa elementului gasit
Variabile locale
p – pointer de tip stat

void modify(stat *head,stat* a);

Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia este folosita pentru modificarea bazei de date
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
a – pointer de tip stat care reprezinta adresa de statului modificat
Variabile locale
t– variabila intermediara simpla de tip int

int lenght(stat* head);

Aceasta functie este de tip int, returneaza lungimea
Functia care determina lungimea listei
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
Variabile locale
p – pointer de tip stat
l– variabila intermediara simpla de tip int

void sorts(stat *head);

Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia sorteaza baza de date
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
Variabile locale
a – pointer de tip stat
b – pointer de tip stat
i,k,l– variabile intermediare simple de tip int

void swaps(stat *a,stat *b);

Aceasta functie este de tip void, care nu returneaza nici o valoare
Functia are rolul pentru a interschimba 2 elemente
Parametri
a – pointer de tip stat care reprezinta adresa elementului de interschimbare

4
b – pointer de tip stat care reprezinta adresa elementului de interschimbare
Variabile locale
na – pointer de tip stat, nb – pointer de tip stat, t – variabila intermediara de tip stat

int insertafter(stat* head,stat *b,stat a,int *n)

Aceasta functie este de tip int, returneaza 1
Functia data insereaza dupa elementul indicat
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
b – pointer de tip stat
a – variabila de tip stat
n – pointer de tip int
Variabile locale
p – pointer de tip stat

stat* insertbefore(stat* head,stat *a,stat b,int *n)

Aceasta functie este de tip stat , adresea lui head
Functia data insereaza inainte de elementul indicat
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
b – pointer de tip stat
a – variabila de tip stat
n – pointer de tip int
Variabile locale
p – pointer de tip stat
q – pointer de tip stat

int append(stat* head,stat a,int *n);

Aceasta functie este de tip int , returneaza 1
Functia data adauga la sfirsit informatii despre stat
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
a – variabila de tip stat
n – pointer de tip int
Variabile locale
p – pointer de tip stat
q – pointer de tip stat

int prepend();
Aceasta functie este de tip int ,returneaza 1
Functia data adauga la inceput informatii despre stat
Parametri
Variabile locale
p – pointer de tip stat

stat *deletes(stat* head,stat* a,int *n);

Aceasta functie este de tip stat, returneaza head
Functia sterge elemente din lista
5
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
a – pointer de tip stat
n – pointer de tip int
Variabile locale
p – pointer de tip stat

int save(stat* head,char*fname);

Aceasta functie este de tip int , returneaza 1
Functia salveaza informatiile in fisier
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
fname – pointer de tip char in care se pastreaza informatia despre locatia fisierului care urmeaza
a fi deschis si scris de functie
Variabile locale
p – pointer de tip stat
fp – pointer de tip fisier

int load(stat* head,char*fname);

Aceasta functie este de tip int , returneaza 1
Functia citeste informatiile din fisier
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
fname – pointer de tip char in care se pastreaza informatia despre locatia fisierului care urmeaza
a fi deschis si citit de functie
Variabile locale
p – pointer de tip stat
fp – pointer de tip fisier
i,l– variabile intermediare simple de tip int

void join(stat* head,stat **head1);

Aceasta functie este de tip void nu returneaza nici o valoare
Functia uneste lista care a fost despartita
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
head1 – dublu pointer de tip stat care reprezinta capul listei despartite
Variabile locale
p – pointer de tip stat

void split(stat *head,stat **head1, int n1);

Aceasta functie este de tip void nu returneaza nici o valoare
Functia desparte lista in 2 liste
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
head1 – dublu pointer de tip stat care reprezinta capul listei despartite
n1 – variabila de tip int
Variabile locale
p – pointer de tip stat
i – variabila intermediara de tip int

void showhead1(stat *head,stat *head1);

Aceasta functie este de tip void nu returneaza nici o valoare
6
Functia afiseaza lista dupa despartire
Parametri
head – pointer de tip stat care reprezinta capul listei contine adresa primului element din lista
head1 – dublu pointer de tip stat care reprezinta adresa primului element dim lista despartita
Variabile locale
p – pointer de tip stat
i – variabila intermediara de tip int

int main();
head1 – pointer de tip stat care reprezinta capul listei adresa primului element dim lista
despartita
i,l,k,n1,m,id,f,rs– variabile intermediare simple de tip int
n – variabila intermediara simpla de tip int care reprezinta numarul de elemente ale listei
a,b,p,v – pointeri de tip stat
cautat – pointer de tip stat care reprezinta adresa elementului cautat
s,y – variabile de tip stat
fname – pointer de tip char in care se pastreaza informatia despre locatia fisierului care urmeaza
a fi deschis si citit de functie
adr,adr1,adr2,num – variabile simple de tip char avind lungimea de 100 caractere
optiune – variabila simpla de tip integer , utilizata pentru a stoca decizia utilizatorului in privinta
optiunii

Fisierul stat.h
#ifndef ONE
#define ONE
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

struct stat{
char nume[100];
char capitala[100];
char presedinte[100];
int populatia;
int suprafata;
struct stat* next;
};
typedef struct stat stat;
stat *head;

void show2(stat *head);

void introducere(stat* head);
int create(stat* head,int n);
void read(stat* head,int n);
void show(stat* head);
stat* searchs(stat* head,char adr[]);
void modify(stat *head,stat* a);
int lenght(stat* head);
void sorts(stat* head);

7
void swaps(stat* a,stat* b);
stat* freem(stat* head);
stat* insertbefore(stat* head,stat *a,stat b,int *n);
int insertafter(stat* head,stat *b,stat a,int *n);
int prepend();
int append(stat* head,stat a,int *n);
stat *deletes(stat* head,stat* a,int *n);
int save(stat* head,char*fname);
int load(stat* head,char*fname);
void join(stat* head,stat **head1);
void split(stat* head,stat **head1,int n1);
void showhead1(stat *head,stat *head1);
#endif // ONE

Fisierul functions.h
#include "stat.h"
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

void show2(stat *head){

stat *p;
p=head;
printf(" Nume: %s\n ",p->nume);
printf(" Capitala: %s\n ",p->capitala);
printf(" Presedinte: %s\n ",p->presedinte);
printf(" Populatia: %d\n ",p->populatia);
printf(" Suprafata: %d\n ",p->suprafata);
}
void introducere(stat* head)
{
stat *p;
p=head;
if(!p)
p = (stat*)malloc(sizeof(*p));
printf(" Nume: ");
fflush(stdin);
gets(p->nume);
printf(" Capitala: ");
fflush(stdin);
gets(p->capitala);
printf(" Presedinte: ");
gets(p->presedinte);
printf(" Populatia: ");
scanf("%d",&p->populatia);
printf(" Suprafata: ");
fflush(stdin);
scanf("%d",&p->suprafata);
p=p->next;
}

int create(stat* head,int n) {

stat *p,*q;
8
int i;
for(i=0;i<n;i++){
p=(stat*)malloc(sizeof(*p));

if(!p)
return NULL;
if(i==0)
{head=p;}
else
{q->next=p;}
p->next=NULL;
q=p;
}
puts(" Memoria a fost alocata cu succes!!!");
return head;

void read(stat* head,int n){

stat *p;
int i=1;
printf(" Dati informatia despre stat\n");
p=head;
while(p){
printf("\nSTAT %d\n",i++);
printf(" Nume: ");
fflush(stdin);
gets(p->nume);
printf(" Capitala: ");
fflush(stdin);
gets(p->capitala);
printf(" Presedinte: ");
fflush(stdin);
gets(p->presedinte);
printf(" Populatia: ");
scanf(" %d",&p->populatia);
printf(" Suprafata: ");
scanf(" %d",&p->suprafata);
p=p->next;
if(p==head){
break;}
}
}
void show(stat* head){
int i=1;
stat *p;
p=head;
while(p){
printf("STAT %d\n ",i++);
printf(" Nume: %s\n ",p->nume);
printf(" Capitala: %s\n ",p->capitala);
printf(" Presedinte: %s\n ",p->presedinte);
printf(" Populatia: %d\n ",p->populatia);
printf(" Suprafata: %d\n ",p->suprafata);
9
 p=p->next;

}
}

stat* searchs(stat* head,char adr[]){

stat *p;
p=head;
while(p){
if(stricmp(p->nume,adr)==0){return p;}
p=p->next;
}
return NULL;
}
void modify(stat *head,stat* a){
int t;
printf(" Doriti sa modificati numele?(1/0): ");
scanf("%d",&t);
if(t){
printf(" Dati numele nou: ");
fflush(stdin);
gets(a->nume);
}
printf(" Doriti sa modificati capitala?(1/0): ");
scanf("%d",&t);
if(t){
printf(" Dati capitala noua: ");
fflush(stdin);
gets(a->capitala);
}
printf(" Doriti sa modificati presedintele?(1/0): ");
scanf("%d",&t);
if(t){
printf(" Dati presedintele nou: ");
fflush(stdin);
gets(a->presedinte);
}

printf(" Doriti sa modificati populatia?(1/0): ");

scanf("%d",&t);
if(t){
printf(" Dati numarul nou al populatiei: ");
fflush(stdin);
scanf("%d",&a->populatia);
}
printf(" Doriti sa modificati suprafata?(1/0): ");
scanf("%d",&t);
if(t){
printf(" Dati numarul nou al suprafetei: ");
fflush(stdin);
scanf("%d",&a->suprafata);
}
}
int lenght(stat* head){
10
 stat *p;
int l=0;
p=head;
while(p){
l++;
p=p->next;
if(p==head)break;
}
return l;
}
void sorts(stat* head){
stat *a,*b;
int i,k,l;
a=(stat*)malloc(sizeof(stat));
if(!a){puts(" Memoria nu a fost alocata");
exit(1);}
b=(stat*)malloc(sizeof(stat));
if(!b){puts(" Memoria nu a fost alocata");
exit(1);}
l=lenght(head);
for(i=0;i<l-1;i++){
a=head;
b=a->next;
for(k=0;k<l-1-i;k++){
if(stricmp(a->nume,b->nume)>0){
swaps(a,b);
}
a=a->next;
b=b->next;
}
}
}
void swaps(stat* a,stat* b){
stat *na,*nb;
stat t;
na=a->next;
nb=b->next;
t=*a;
*a=*b;
*b=t;
a->next=na;
b->next=nb;
}
stat *freem(stat* head){
stat*p,*q;
if(head==NULL)
return NULL;
p=head;
while(p){
q=p;
p=p->next;
free(p);
if(p==head)
break;
11
 }
head=NULL;
return NULL;
}

int insertafter(stat* head,stat *b,stat a,int *n)

{
stat *p;
p=(stat *) malloc (sizeof (stat));
if (p==NULL)
return -1;
*p=a;
if(b->next==NULL)
{
p->next=NULL;
b->next=p;
}
else
{
p->next=b->next;
b->next=p;
}
*n=*n+1;
return 1;
}
stat* insertbefore(stat* head,stat *a,stat b,int *n)
{
stat *p, *q;
p=(stat *) malloc (sizeof (stat));
if (p==NULL)
return p;
if (a==head)
{
*p=b;
p->next=a;
head=p;
return head;
}
q=head;
while (q->next!=a)
{q=q->next;}
*p=b;
q->next=p;
p->next=a;
*n=*n+1;
return head;
}

int prepend()
{
stat *p;
p=(stat*)malloc(sizeof(*p));
if(!p) return 0;
12
 printf(" Nume: ");
fflush(stdin);
gets(p->nume);
printf(" Capitala: ");
fflush(stdin);
gets(p->capitala);
printf(" Presedinte: ");
fflush(stdin);
gets(p->presedinte);
printf(" Populatia: ");
scanf("%d",&p->populatia);
printf(" Suprafata: ");
fflush(stdin);
scanf("%d",&p->suprafata);
if(head!=NULL)
{p->next=head;}
else
{p->next=NULL;}
head=p;
return 1;
}

int append(stat* head,stat a,int *n)

{
stat *p, *q;
if (head==NULL)
return 0;
q=head;
while(q->next)
{
q=q->next;
if(q==head)
break;
}
p=(stat *)malloc (sizeof(stat));
if (p==NULL)
return -1;
*p=a;
q->next=p;
p->next=NULL;
*n=*n+1;
return 1;

stat *deletes(stat* head,stat* a,int *n)

{
stat *p;
p=head;
if (p->next==NULL)
{
head=NULL;
free(p);
13
 return head;
}
if(p==a)
{
head=p->next;
free(p);
}
else
{
while(p->next!=a)
{p=p->next;}
p->next=a->next; free(a);}
*n=*n-1;
return head;
}

int save(stat* head,char*fname)

{
stat*p;
FILE*fp;
fp=fopen(fname,"w");
if(!fp)
return 0;
p=head;
while(p)
{
fprintf(fp,"%s %s %s %d %d",p->nume,p->capitala,p->presedinte,p->populatia,p-
>suprafata);
p=p->next;
if(p==head)
break;
}
fclose(fp);
return 1;
}

int load(stat* head,char*fname)

{
stat*p;
FILE *fp;
int i=1,l;
l=lenght(head);
fp=fopen(fname,"r");
p=head;
for(i=0;i<l;i++){
fscanf(fp,"%s%s%s%d%d",p->nume,p->capitala,p->presedinte,&p-
>populatia,&p->suprafata);
p=p->next;
}
fclose(fp);
return 1;
}
void join(stat* head,stat **head1){
14
 stat *p;
p=head;
while(p){
if(p->next==NULL){
p->next=*head1;
break;
}
p=p->next;
}
*head1=NULL;
}
void split(stat *head,stat **head1, int n1){
stat *p;
p=head;
int i=0;
while(p){
if(i==n1-1){
*head1=p->next;
p->next=NULL;
break;
}
i++;
p=p->next;
}
return;
}
void showhead1(stat *head,stat *head1){
int i=1;
stat *p;
p=head1;
while(p){
printf("STAT %d\n ",i++);
printf(" Nume: %s\n ",p->nume);
printf(" Capitala: %s\n ",p->capitala);
printf(" Presedinte: %s\n ",p->presedinte);
printf(" Populatia: %d\n ",p->populatia);
printf(" Suprafata: %d\n ",p->suprafata);
p=p->next;

}
}

Fisierul main.c
#include "stat.h"
#include "functions.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
stat *head1;
int i=0,l=0,k,n,n1,m=0,id=0,f,rs;
stat *a,*b,*p,*cautat,*v;
stat s,y;
15
 char adr[100],adr1[100],adr2[100],num[100],*fname;
int optiune;
optiune=0;
do{
system("CLS");
printf("\t\t\tLucrarea de laborator 2 & 3\n\t\t\t\tla disciplina\n\t\t\tStructuri de date si
algoritmi \n\n");
puts(" >> MENU <<");
puts(" 1. Crearea listei.");
puts(" 2. Introducerea datelor.");
puts(" 3. Afisarea datelor.");
puts(" 4. Cautarea unui element.");
puts(" 5. Modificarea listei.");
puts(" 6. Determinarea lungimei listei.");
puts(" 7. Sortarea elementelor.");
puts(" 8. Interschimbarea a 2 elemente.");
puts(" 9. Eliberaraea memoriei.");
puts(" 10.Adaugarea unui element la inceputul listei.");
puts(" 11.Adaugarea unui element la sfirsitul listei.");
puts(" 12.Inserarea inainte de element.");
puts(" 13.Inserarea dupa element.");
puts(" 14.Stergerea unui element.");
puts(" 15.Pentru a desparti lista.");
puts(" 16.Pentru a uni lista.");
puts(" 17.Scrierea datelor in fisier.");
puts(" 18.Citirea datelor din fisier.");
puts(" 0. Iesire.");
printf("\n Alegeti optiunea: ");
scanf("%d",&optiune);
switch (optiune){
case 1: {
printf(" Dati numarul de state: ");
scanf("%d",&n);
head=create(head,n);
system("PAUSE");
break;
}
case 2: {
if(!head){
puts(" Memoria nu a fost alocata");
getch();
break;
}
if(!id)
{ read(head,n);
id=1;
}
else
puts(" Datele au fost deja introduse");
system("PAUSE");
break;
}
case 3: {
if(!head){puts(" Memoria nu a fost alocata");}
16
 if(id)
{
puts(" Lista de structuri");
show(head);
}
else
{
printf(" Doriti sa introduceti informatia?(1/0): ");
scanf("%d",&f);
if(f)
{read(head,n);
id=1;
puts(" Lista de structuri");
show(head);
}
}

system("PAUSE");
break;
}
case 4: {
printf(" Introduceti numele de cautat: ");
fflush(stdin);
gets(adr);
p=searchs(head,adr);
if(p==0){
puts(" Statul nu a fost gasit in baza de date");
puts(" Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
puts(" Statul cautat");
printf(" Nume: %s\n Capitala: %s\n Presedinte: %s\n Populatia: %d\n Suprafata: %d\n",p-
>nume,p->capitala,p->presedinte,p->populatia,p->suprafata);
system("PAUSE");
break;
}
case 5: {
printf(" Dati numele statului pe care doriti sa-l modificati: ");
fflush(stdin);
gets(adr);
cautat=searchs(head,adr);
if(cautat==0)
{
puts(" Statul nu a fost gasit in baza de date");
puts(" Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
modify(head,cautat);
printf(" Doriti sa afisati statul modificat?(1/0): ");
scanf("%d",&f);
if(f)
{
17
puts(" Statul dupa modificare");
show2(cautat);
puts("\n Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
else break;

system("PAUSE");
break;
}
case 6: {
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
k=lenght(head);
printf(" Lungimea listei este << ");
printf("%d",k);
printf(" >>\n");
system("PAUSE");
break;
}
case 7: {
sorts(head);
puts(" Lista a fost sortata");
printf(" Doriti sa afisati lista sortata(1/0): ");
scanf("%d",&f);
if(f)
{
puts(" Lista dupa sortare");
show(head);
}
puts("\n Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
system("PAUSE");
break;
}
case 8: {
printf(" Dati adresa primului element de schimbat: ");
fflush(stdin);
gets(adr1);
a=searchs(head,adr1) ;
if(a==0)
{
puts(" Elementul cu asa adresa nu a fost gasit");
getch();
break;
}
printf(" Dati adresa la al doilea element de schimbat: ");
fflush(stdin);
18
 gets(adr2);
b=searchs(head,adr2);
if(b==0)
{
puts(" Elementul cu asa adresa nu a fost gasit");
getch();
break;
}
swaps(a,b);
puts(" Interschimbarea elementelor a fost efectuata cu succes");
printf(" Doriti sa fie afisata lista modificata(1/0): ");
scanf("%d",&f);
if(f)
{
printf(" Lista dupa interschimbare\n");
show(head);
}
puts("\n Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;

system("PAUSE");
break;
}
case 9: {
head=freem(head);
if(head)
puts(" Lista nu a fost eliberata") ;
if(!head)
id=0;
puts(" Memoria a fost eliberata cu succes!!!");
system("PAUSE");
break;
}
case 10: {
puts(" Introduce-ti informatia despre elementul de adaugat");
rs=prepend();
if (rs==0)
{puts(" Lista este vida");}
if (rs==-1) {puts(" Elementul nu a fost adaugat");}
if (rs==1) {puts(" Elementul a fost adaugat cu succes");}
system("PAUSE");
break;
}
case 11: {
puts(" Introduce-ti informatia despre elementul de adaugat");
introducere(&s);
rs=append(head,s,&n);
if (rs==0)
{puts(" Lista este vida");}
if (rs==-1) {puts(" Elementul nu a fost adaugat");}
if (rs==1) {puts(" Elementul a fost adaugat cu succes");}
system("PAUSE");
break;
19
}
case 12: {
printf(" Dati numele elementului inaintea caruia doriti sa inserati: ");
fflush(stdin); gets(adr);
cautat=searchs(head,adr);
if (cautat==NULL)
{
puts(" Acest element nu exista");
getch();
break;
}
puts(" Introduceti datele despre elementul care doriti sa-l adaugati\n ");
introducere(&s);
head=insertbefore(head,cautat,s,&n);
puts(" Elementul a fost adaugat cu succes");
system("PAUSE");
break;
}
case 13: {
printf(" Dati numele elementului dupa care doriti sa inserati: ");
fflush(stdin); gets(adr);
cautat=searchs(head,adr);
if (cautat==NULL)
{
puts("Acest element nu exista");
getch();
break;
}
puts(" Introduceti datele despre elementul care doriti sa-l adaugati");
introducere(&s);
rs=insertafter(head,cautat,s,&n);
if (rs==-1) {puts("Elementul nu a fost adaugat");}
if (rs==1) {puts("Elementul a fost adaugat cu succes");}
system("PAUSE");
break;
}
case 14: {
if(!head)
{
puts(" Memoria nu a fost alocata");
getch();
break;
}
puts(" Lista de structuri");
printf("\n");
show(head);
printf(" Dati numele elementului care doriti sa-l stergeti: ");
fflush(stdin);
gets(adr);
cautat=searchs(head,adr);
if (cautat==NULL)
{
puts(" Acest element nu exista");
getch();
20
 break;
}
head=deletes(head,cautat,&n);
puts(" Stergerea a fost efectuata cu succes");
getch();
break;
system("PAUSE");
break;
}
case 15: {
printf(" Dati indicele statului de unde doriti sa impartiti lista in doua: ");
scanf("%d", &n1);
split(head,&head1, n1);
show(head);
puts("\n Lista dupa despartire");
showhead1(head,head1);
system("PAUSE");
break;
}
case 16: {
if(head1){
join(head,&head1);
puts(" Unirea a avut loc cu succes!");
}
else{puts(" Despartiti lista!"); }
system("PAUSE");
break;
}
case 17: {
if(!head)
{
puts(" Memoria nu a fost alocata");
getch();
break;
}
printf(" Dati numele fisierului in care doriti sa salvati lista: ");
fflush(stdin);
gets(num);
rs=save(head,num);
if(rs==0) {puts(" Salvarea nu a avut loc");}
if(rs==1) {puts(" Salvarea s-a efectuat cu succes");m=1;}
system("PAUSE");
break;
}
case 18:{
if(!head)
{
puts(" Memoria nu a fost alocata");
getch();
break;
}
else{
printf(" Dati numele fisierului din care doriti sa incarcati lista: ");
fflush(stdin);
21
 gets(num);
rs=load(head,num);
if(rs==0)
{
puts(" Deschiderea nu s-a efectuat");
getch();
break;
}
if(rs==1)
{
id=1;
puts(" Deschiderea a fost efectuata cu succes");
printf(" Doriti sa afisati lista incarcata?(1/0): ");
scanf("%d",&f);
if(f)
{
puts(" Lista incarcata");
printf("\n");
show(head);
}
}
}
system("PAUSE");
break;
}
case 0:{
if(head){
if(!m)
{
printf(" Informatia va fi pierduta...salvati?(1/0): ");
scanf("%d",&f);
if(f)
{printf(" Dati numele fisierului in care doriti sa salvati lista: ");
fflush(stdin);
gets(num);
rs=save(head, num);
if(rs==0) {puts(" Salvarea nu a avut loc");}
if(rs==1) {puts(" Salvarea a fost efectuata cu succes");}
} else
printf(" Pentru a iesi apasa-ti tasta 'ENTER'");
getch();
free(head);
head=NULL;
return 0;
}
}
printf(" Doriti sa iesiti?(1/0): ");
scanf("%d",&f);
if(f)
{
if(head)
{
free(head);
head=NULL;
22
 }
return 0;
}
else
break;
default:
puts(" Alegeti optiunea corect");
getch();
}
}
}
while(optiune!=0);
getch();
return 0;
}

Rezultatele obtinute

Meniul programului

23
 1. Crearea listei

1. Introducerea datelor

24
2. Afisarea datelor

3. Cautare unui element

25
4. Modificarea listei

5. Lungimea listei

26
6. Sortarea elementelor

7. Interschimbarea a 2 elemente

27
10.Adaugarea unui element la inceput

11. Adaugarea unui element la sfirsit

28
12. Inserarea inainte de elementul indicat

29
13.Inserarea dupa elementul indicat

30
31
14. Stergerea unui element

32
15.Despartirea liste in 2 liste

16. Unirea listei

33
17. Scrierea datelor in fisier

34
18.Citirea datelor din fisier

9.Eliberarea memoriei

0.Iesire din program

35
Analiza rezultatelor si concluzii:
In urma elaborarii acestei lucrari de laborator s-a ajuns la urmatoarele concluzii

Acest program este usor de folosit si necesita foarte putine resurse. Asigura cea
mai buna si mai rapida metoda de stocare a datelor, fisierul.

Dupa incheierea operatiilor, aplicatia salveaza agenda intr-un fisier, de unde poate
fi preluata mai apoi, si elibereaza zona de memorie ocupata. Aceste caracteristici
prezintă siguranță în funcționare si incredere.

Bibliografie:

1. http://curs.algoritmi.ro/2011/02/28/tp-02-structuri-uniuni/
2. http://devcentral.iftech.com/learning/tutorials/c-cpp/c/
3. http://www.cprogramming.com/tutorial/c/lesson15.html

36