Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra Informatic Aplicat

Raport
Lucrare de laborator Nr.2-3
La Structuri de Date si Algoritmi

A efectuat:

Chiinu 2011

1 Tema: Implementarea TDA Lista simplu nlnuit

2 Sarcina: De implementat tipul abstract de date lista simplu nlnuit.
3 Structura data:Structura stat cu 5 cimpuri.
1)nume
2)Capitala
3)Suprafata
4)Populatia
5)PIB
4 Analiza datelor:
Cmpurile structurii stat :
nume un tablou de 20 caractere in care se va pstra denumirea fiecarui stat ;
capitala un tablou de 20 caractere n care se va pstra denumirea capitalei
statului;
suprafata variabila de tip integer in care se va pstra valoarea suprafetei;
populatia - variabila de tip integer n care se va stoca numarul de populatie a
statului;
pib un tablou de 20 caractere in care se va pstra pib-ul;
5 Descrierea scurta a teoriei
Un Tip Abstract de Date (TAD) este un tip de date cu urmtoarele proprieti:
specificarea obiectelor din domeniu este independent de reprezentarea lor;
specificarea operaiilor este independent de implementarea lor.
Mulimea operaiilor Tipului Abstract de Date definesc interfaa (contractul)
su.
Cu alte cuvinte, un TAD este o entitate specificat matematic, care definete o
mulime a instanelor sale, avnd o interfa specific o colecie de signaturi ale
operaiilor care pot fi aplicate pe o instan a tipului de dat. Precizm faptul c
signatura
unei operaii conine numele operaiei, lista parametrilor ei, mpreun cu tipul lor i
eventual tipul rezultatului dac este o operaie de tip functie.
Domeniul unui tip (abstract) de dat poate fi definit fie prin enumerarea
elementelor sale, n cazul n care este finit, fie printr-o regul cared descrie
elementele
sale.
Dup definirea domeniului unui tip (abstract) de dat, este necesar specificarea
operaiilor. n acest sens sunt necesari doi pai:
1. precizarea sintaxei operaiilor (denumirea operatorilor, tipurile valorilor pe care
acetia opereaz, tipul rezultatului operaiei);

2. descrierea funcionalitii operatorilor, cu alte cuvinte a semanticii operaiilor.

Sunt mai multe modaliti de de a preciza semantica operaiilor, i anume:
dnd o descriere textual a comportamentului;
specificarea operaional;
specificarea algebric.
6 Rezultatele obtinute:
Meniul programului

7 Concluzie:
In cadrul acestei lucrari de laborator am insusit implementarea tipului abstract de
date lista simplu nlnuit. Acestea pot fi cu usurinta folosite la crearea bazelor de
date, arborilor binari, cozilor, stivelor etc., asfel reducind timpul necesar pentru
eleborare programelor.
Bibliografia folosita:
-Conspect dat la prelegeri de catre M.Kulev pentru studentii grupelor calculatoare
pe tema Prelucrarea tablourilor de structure.Implimentarea tipului abstract de date
lista simplu inlantuita.
-Gabriela Serban- Tipuri Abstracte de Date- in forma electronica, format pdf.

ANEXA
Listingul programului :
1)Fisierul antet stat.h :
typedef struct stat
{
char nume[30];
char capitala[20];
int suprafata;
int populatie;
char PIB[20];
struct stat *next;
} stat;
void antet(void);
void afisare(stat * c,int i);
stat* create(int n);
void afisare1(void);
void afisare2(stat*head,int i);
void introducere(stat *head);
void input(stat*head);
void output(stat*head);
stat* elib(stat*head);
stat* search1(stat*head,char num[]);
stat*search2(stat*head,char cap[]);
stat*search3(stat*head,int s);
stat*search4(stat*head,int pop);
stat*search5(stat*head,char pib[]);
void swap(stat*a,stat*b);
int length(stat*head);
void sort1(stat*head,int n);
void sort11(stat*head,int n);
void sort2(stat*head,int n);
void sort22(stat*head,int n);
void sort3(stat*head,int n);
void sort33(stat*head,int n);
void sort4(stat*head,int n);
void sort44(stat*head,int n);
void sort5(stat*head,int n);
void sort55(stat*head,int n);
void modify(stat*a);
int addtoend(stat *head,stat a,int *n);
stat* addathead(stat *head,stat v);
int insertafter(stat *b,stat a,int *n);
stat* insertbefore(stat* head,stat *a,stat b,int *n);
stat *delete1(stat *head,stat* a,int *n);
stat *devide(stat* head1, int k);
int concat(stat* head1,stat** head2);
stat *last(stat*head);
int save(stat*head,char*fname);
int load(stat*head,char*fname);

2)Fisierul STAT1.CPP
#include "stat.h"
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
//--------------------------------------------------------------------------------------//functia pentru afisarea listei simplu inlantuite
void antet(void)
{
puts("Nr.|Nume
|Capitala |Suprafata |Populatie(mln)|PIB(mln) |adr |next|");
}
//----------------------------------------------------------------------------------------//functia pentru afisarea listei simplu inlantuite
void afisare(stat * c,int i)
{
printf("%-3d|%-13s|%-10s|%-10d|%-14d|%-10s|%-4p|%-4p|\n",i,c->nume,c->capitala,c->suprafata, c>populatie,c->PIB,c,c->next);
}
//--------------------------------------------------------------------------------------------------------//functia pentru crearea listei simplu inlantuite
stat* create(int n)
{
stat*c,*head,*p;
int i;
for(i=0;i<n;i++)
{
c=(stat*)malloc(sizeof(*c));
if(!c)
return NULL;
if(i==0)
{head=c;}
else
{p->next=c;}
c->next=NULL;
p=c;
}
return head;
}
//-------------------------------------------------------------------------------------------------------//functia de citire a informatiei
void introducere(stat *head)
{
printf("Nume:");
fflush(stdin);
gets(head->nume);
printf("Capitala:");
fflush(stdin);
gets(head->capitala);
printf("Suprafata:");
scanf("%d",&head->suprafata);
printf("Populatie:");
scanf("%d",&head->populatie);
printf("PIB:");
fflush(stdin);
gets(head->PIB);
}
//-------------------------------------------------------------------------------------------------------//functia care introduce informatii in lista simplu inlantuita
void input(stat*head)
{

stat*c;
int i=1;
c=head;
while(c)
{
printf("
Stat Nr.%d\n",i++);
introducere(c);
c=c->next;
// if(c==head)
// break;
}
}
//-------------------------------------------------------------------------------------------------------//fuctia de afisare a informatiei in lista simplu inlantuita
void output(stat*head)
{
stat*c;
int i=0;
c=head;
antet();
while(c)
{
afisare(c,i+1);
i++;
c=c->next;
// if(c==head)
// break;
}
}
//------------------------------------------------------------------------------------------------------//functia pentru eliberarea memoriei
stat* elib(stat* head)
{
stat*c,*p;
if(head==NULL)
return NULL;
c=head;
while(c)
{
p=c;
c=c->next;
free(p);
if(c==head)
break;
}
head=NULL;
return NULL;
}
//-------------------------------------------------------------------------------------------------------//functia de cautare a unui element dupa nume
stat*search1(stat*head,char num[])
{
stat *c;
c=head;
while(c)
{
if(strcmp(c->nume,num)==0)
{return c;}
c=c->next;
}
return NULL;
}
//--------------------------------------------------------------------------------------------------------

//functia de cautare a unui element dupa capitala

stat*search2(stat*head,char cap[])
{
stat *c;
c=head;
while(c)
{
if(strcmp(c->capitala,cap)==0)
{return c;}
c=c->next;
}
return NULL;
}
//-------------------------------------------------------------------------------------------------------//functia de cautare a unui element dupa suprafata
stat*search3(stat*head,int supr)
{
stat *c;
c=head;
while(c)
{
if(c->suprafata==supr)
{return c;}
c=c->next;
}
return NULL;
}
//-------------------------------------------------------------------------------------------------------//functia de cautare a unui element dupa populatie
stat*search4(stat*head,int populatia)
{
stat *c;
c=head;
while(c)
{
if(c->populatie==populatia)
{return c;}
c=c->next;
}
return NULL;
}
//-------------------------------------------------------------------------------------------------------//functia de cautare a unui element PIB
stat*search5(stat*head,char p[])
{
stat *c;
c=head;
while(c)
{
if(strcmp(c->PIB,p)==0)
{return c;}
c=c->next;
}
return NULL;
}
//-------------------------------------------------------------------------------------------------------//functia pentru interschimbarea a doua elemente in lista simplu inlantuita
void swap(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;
}
//-------------------------------------------------------------------------------------------------------//functia pentru determinarea lungimii listei simplu inlantuita
int length(stat*head)
{
stat *c;
int n=0;
c=head;
while(c)
{
n++;
c=c->next;
if(c==head)
break;
}
return n;
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa nume(crescator)
void sort1(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head; b=a->next;
for (k=0;k<n-i-1;k++)
{
if (strcmp(a->nume,b->nume)>0)
{
swap (a,b);
}
a=a->next; b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa nume(descrescator)
void sort11(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head; b=a->next;
for (k=0;k<n-i-1;k++)
{
if (strcmp(a->nume,b->nume)<0)
{
swap (a,b);
}
a=a->next; b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa capitala(crescator)

void sort2(stat *head, int n)

{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head; b=a->next;
for (k=0;k<n-i-1;k++)
{
if (strcmp(a->capitala,b->capitala)>0)
{
swap (a,b);
}
a=a->next; b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa capitala(descrescator)
void sort22(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head; b=a->next;
for (k=0;k<n-i-1;k++)
{
if (strcmp(a->capitala,b->capitala)<0)
{
swap (a,b);
}
a=a->next; b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa suprafata(crescator)
void sort3(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head;
b=a->next;
for (k=0;k<n-i-1;k++)
{
if (a->suprafata>b->suprafata)
{
swap (a,b);
}
a=a->next;
b=b->next;
}
}
}
//---------------------------------------------------------------------------------------------------------

//functia pentru sortarea listei dupa suprafata(descrescator)

void sort33(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head;
b=a->next;
for (k=0;k<n-i-1;k++)
{
if (a->suprafata<b->suprafata)
{
swap (a,b);
}
a=a->next;
b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa populatie(crescator)
void sort4(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head;
b=a->next;
for (k=0;k<n-i-1;k++)
{
if (a->populatie>b->populatie)
{
swap (a,b);
}
a=a->next;
b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa populatie(descrescator)
void sort44(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head;
b=a->next;
for (k=0;k<n-i-1;k++)
{
if (a->populatie<b->populatie)
{
swap (a,b);
}
a=a->next;

b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa PIB(crescator)
void sort5(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head; b=a->next;
for (k=0;k<n-i-1;k++)
{
if (strcmp(a->PIB,b->PIB)>0)
{
swap (a,b);
}
a=a->next; b=b->next;
}
}
}
//--------------------------------------------------------------------------------------------------------//functia pentru sortarea listei dupa PIB(descrescator)
void sort55(stat *head, int n)
{
int i,k;
stat *a,*b;
a=(stat*)malloc(sizeof(stat));
b=(stat*) malloc (sizeof(stat));
for (i=0; i<n-1;i++)
{
a=head; b=a->next;
for (k=0;k<n-i-1;k++)
{
if (strcmp(a->PIB,b->PIB)<0)
{
swap (a,b);
}
a=a->next; b=b->next;
}
}
}
//------------------------------------------------------------------------------------------------------//functia pentru modificarea unui element in lista simplu inlantuita
void modify(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 suprafata?(1/0)");
scanf("%d",&t);
if(t)
{
printf("Dati suprafata noua:");
scanf("%d",&a->suprafata);
}
printf("Doriti sa modificati populatia?(1/0)");
scanf("%d",&t);
if(t)
{
printf("Dati numarul nou de populatie:");
scanf("%d",&a->populatie);
}
printf("Doriti sa modificati PIB?(1/0)");
scanf("%d",&t);
if(t)
{
printf("Dati PIB-ul nou:");
fflush(stdin);
gets(a->PIB);
}
}
//------------------------------------------------------------------------------------------------------//functia de adaugare a unui element la sirsit
int addtoend(stat *head,stat a,int *n)
{
stat *c, *p;
if (head==NULL)
return 0;
p=head;
while(p->next)
{
p=p->next;
if(p==head)
break;
}
c=(stat *)malloc (sizeof(stat));
if (c==NULL)
return -1;
*c=a;
p->next=c;
c->next=NULL;
*n=*n+1;
return 1;
}
//------------------------------------------------------------------------------------------------------//functia de adaugare a unui element la inceput
stat* addathead(stat *head,stat v)
{
stat*c;
c=(stat*)malloc(sizeof(*c));
if(!c)
return 0;
if(head==NULL)
{
head=c;
*c=v;

c->next=NULL;
}
else
{
*c=v;
c->next=head;
head=c;
}
return head;
}
//-------------------------------------------------------------------------------------------------------//functia de inserare dupa elementul indicat
int insertafter(stat *b,stat a,int *n)
{
stat *c;
c=(stat *) malloc (sizeof (stat));
if (c==NULL)
return -1;
*c=a;
if(b->next==NULL)
{
c->next=NULL;
b->next=c;
}
else
{
c->next=b->next;
b->next=c;
}
*n=*n+1;
return 1;
}
//----------------------------------------------------------------------------------------------------------//functia de inserare inainte de elementul indicat
stat* insertbefore(stat* head,stat *a,stat b,int *n)
{
stat *c, *p;
c=(stat *) malloc (sizeof (stat));
if (c==NULL)
return c;
if (a==head)
{
*c=b;
c->next=a;
head=c;
return head;
}
p=head;
while (p->next!=a)
{p=p->next;}
*c=b;
p->next=c;
c->next=a;
*n=*n+1;
return head;
}
//--------------------------------------------------------------------------------------------------------//functia de stergere a unui element din lista
stat *delete1(stat *head,stat* a,int *n)
{
stat *c;
c=head;
if (c->next==NULL)
{

head=NULL;
free(c);
return head;
}
if(c==a)
{
head=c->next;
free(c);
}
else
{
while(c->next!=a)
{c=c->next;}
c->next=a->next; free(a);}
*n=*n-1;
return head;
}
//-------------------------------------------------------------------------------------------------------//functia de divizare a listei
stat *devide(stat* head1, int k)
{
stat* head2, *c;
int i;
if(!head1)
return NULL;
c=head1;
i=0;
while ((i+1)!=k)
{
c=c->next;
i++;
}
head2=c->next;
c->next=NULL;
return head2;
}
//-----------------------------------------------------------------------------------------------------//fuctia de cocatenare a doua liste
int concat(stat* head1,stat** head2)
{
stat *c;
if(!head1||!*head2)
return 0;
if(!head1)
return 0;
c=head1;
while(c->next)
{
c=c->next;
}
c->next=*head2;
*head2=NULL;
return 1;
}
//------------------------------------------------------------------------------------------------------//fuctia de determinare a adresei ultimului element din lista
stat *last(stat*head)
{
stat* p;
p=head;
while(p->next)
{
p=p->next;
if(p->next==head)

break;
}
return p;
}
//----------------------------------------------------------------------------------------------------//fuctia de inscriere in fisier
int save(stat*head,char*fname)
{
stat*c;
FILE*fp;
fp=fopen(fname,"w");
if(!fp)
return 0;
c=head;
while(c)
{
fprintf(fp,"%s %s %d %d %s\n",c->nume,c->capitala,c->suprafata,c->populatie,c->PIB);
c=c->next;
if(c==head)
break;
}
fclose(fp);
return 1;
}
//-----------------------------------------------------------------------------------------------------//functia citirii continutului unui fisier
int load(stat*head,char*fname)
{
stat*c;
FILE *fp;
int i,l;
l=length(head);
fp=fopen(fname,"r");
c=head;
for(i=0;i<l;i++)
{
fscanf(fp,"%s%s%d%d%s",c->nume,c->capitala,&c->suprafata,&c->populatie,c->PIB);
c=c->next;
}
fclose(fp);
return 1;
}
void Prezt()
{
clrscr();
_setcursortype(_NOCURSOR);
printf("\n\n\n\n\t\t");
textcolor(2);
cprintf(" Lucrare de laborator Nr.2-3 la SDA:");
printf("\r\n\n\t\t");
cprintf(" Efectuat de Stegarescu Vasile:");
printf("\r\n\n\t\t");
cprintf("
******Tema******");
printf("\r\n\n\t\t");
cprintf(" Lista simplu inlantuita.");
textcolor(12);
getch();
closegraph();
}

3)Fisierul functiei main STAT2.CPP

#include "stat.cpp"
int main()
{ Prezt();
stat*head=NULL,*head2=NULL;;
int n,nm,nm1,nm2,s1,s2,s3,s4,s5,l,k,k1,k2,g,i,id,f,rs,m,r;
id=0; m=0;
stat* cautat;
stat *v;
stat s;
stat *c;
stat*a,*b;
char num[40];
char cap[40],p[40];
char num1[40],num2[40];
// int graphdriver=DETECT,graphmode;
// initgraph(&graphdriver,&graphmode,"c:\\tc\\bgi");
while(1)
{
clrscr();
textcolor(95);
printf("\t\t\t"); cputs(" ****MENIU****"); printf("\n");
textcolor(8);
printf("\t\t");cputs("1. Crearea listei simplu inlantuite"); printf("\n");
printf("\t\t");cputs("2. Introducerea informatiei despre stat"); printf("\n");
printf("\t\t");cputs("3. Afisarea informatiei");
printf("\n");
printf("\t\t");cputs("4. Eliberarea memoriei"); printf("\n");
printf("\t\t");cputs("5. Cautarea unui element");
printf("\n");
printf("\t\t");cputs("6. Interschimbarea a doua elemente");
printf("\n");
printf("\t\t");cputs("7. Lungimea listei "); printf("\n");
printf("\t\t");cputs("8. Sortarea");
printf("\n");
printf("\t\t");cputs("9. Modificarea unui element");
printf("\n");
printf("\t\t");cputs("10.Adaugarea unui element");
printf("\n");
printf("\t\t");cputs("11.Stergerea unui element din lista");
printf("\n");
printf("\t\t");cputs("12.Divizarea listei in doua liste simplu inlantuite");
printf("\n");
printf("\t\t");cputs("13.Concatenarea a doua liste");
printf("\n");
printf("\t\t");cputs("14.Adresa ultimului element din lista");
printf("\n");
printf("\t\t");cputs("15.Salvarea listei in fisier");
printf("\n");
printf("\t\t");cputs("16.Deschiderea unui fisier");
printf("\n");
textcolor(6);
printf("\t\t");cputs("0.EXIT");printf("\n");
textcolor(12);
printf("\t\t\t");cputs("----Alegeti optiunea----"); printf("\n");
textcolor(10);
scanf("%d",&nm);
switch(nm)
{
case 1:
clrscr();
if(head)
{
puts("Memoria a fost deja alocata");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;

}
printf("Dati numarul de state:\nn=");
scanf("%d",&n);
head=create(n);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 2:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
if(!id)
{ input(head); id=1; }
else
puts("Datele au fost deja introduse");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 3:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
if(id)
{
printf("\t\t\t");
textcolor(12);
cputs("Lista de structuri");
printf("\n");
output(head);
}
else
{
puts("Trebuie mai intii de introdus informatia,introducem?(1-da,0-nu)");
scanf("%d",&g);
if(g)
{input(head);
id=1;
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista de structuri");
printf("\n");
output(head);
}
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 4:
clrscr();
head=elib(head);
if(head)
puts("Lista nu a fost eliberata") ;
if(!head)
id=0;

puts("Memoria a fost eliberata cu succes!!!");

puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 5:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
textcolor(12);
printf("\t\t");cputs("&&&&&Cautarea unui element&&&&&"); printf("\n");
textcolor(15);
cprintf("[1].Cautarea dupa nume"); printf("\n");
cprintf("[2].Cautarea dupa capitala");printf("\n");
cprintf("[3].Cautarea dupa suprafata");printf("\n");
cprintf("[4].Cautarea dupa populatie");printf("\n");
cprintf("[5].Cautarea dupa PIB");printf("\n");
scanf("%d",&nm2);
switch(nm2)
{
case 1:
{
clrscr();
printf("Dati nume:");
fflush(stdin);
gets(num);
cautat=search1(head,num);
if(cautat==0)
{
puts("Statul nu a fost gasita in baza de date");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Stat cautat");
printf("\n");
antet();
afisare(cautat,id);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;}
case 2:
clrscr();
printf("Dati capitala:");
fflush(stdin);
gets(cap);
cautat=search2(head,cap);
if(cautat==0)
{
puts("Statul nu a fost gasita in baza de date");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Statul cautat");

printf("\n");
antet();
afisare(cautat,id);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 3:
clrscr();
printf("Dati suprafata:\n");
scanf("%d",&k);
cautat=search3(head,k);
if(cautat==0)
{
puts("Statul nu a fost gasita in baza de date");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Statul cautat");
printf("\n");
antet();
afisare(cautat,id);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 4:
clrscr();
printf("Dati populatia:\n");
scanf("%d",&k);
cautat=search4(head,k);
if(cautat==0)
{
puts("Statul nu a fost gasita in baza de date");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Statul cautat");
printf("\n");
antet();
afisare(cautat,id);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 5:
clrscr();
printf("Dati PIB:");
fflush(stdin);
gets(p);
cautat=search5(head,p);
if(cautat==0)
{
puts("Statul nu a fost gasita in baza de date");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
clrscr();

printf("\t\t\t");
textcolor(12);
cputs("Statul cautata");
printf("\n");
antet();
afisare(cautat,id);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;}
break;
case 6:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
printf("Dati numele primului element de schimbat:\n");
fflush(stdin);
gets(num1);
a=search1(head,num1) ;
if(a==0)
{
puts("Elementul cu asa nume nu a fost gasit");
getch();
break;
}
printf("Dati numele la al doilea element de schimbat:\n");
fflush(stdin);
gets(num2);
b=search1(head,num2);
if(b==0)
{
puts("Elementul cu asa nume nu a fost gasit");
getch();
break;
}
swap(a,b);
puts("Interschimbarea elementelor a fost efectuata cu succes");
puts("Doriti sa fie afisata lista modificata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cprintf("Lista dupa interschimbare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 7:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
k=length(head);
printf("Lugimea listei este:<<");

textcolor(12);
cprintf("%d",k);
printf(">>\n");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 8:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
textcolor(10);
printf("\t\t");cputs("<>><><>Sortarea<><><>"); printf("\n");
textcolor(12);
cprintf("[1].Sortare dupa nume"); printf("\n");
cprintf("[2].Sortare dupa capitala");printf("\n");
cprintf("[3].Sortare dupa suprafata");printf("\n");
cprintf("[4].Sortare dupa populatie");printf("\n");
cprintf("[5].Sortare dupa PIB");printf("\n");
scanf("%d",&nm2);
switch(nm2)
{
case 1:
{clrscr();
puts("Sortare:");
puts("[1].Crescator");
puts("[2].Descrescator");
scanf("%d",&s1);
switch(s1)
{
case 1:
{
sort1(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(14);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();};
break;
case 2:
sort11(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");

printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;};
break;
case 2:
{clrscr();
puts("Sortare:");
puts("[1].Crescator");
puts("[2].Descrescator");
scanf("%d",&s2);
switch(s2)
{
case 1:
{
sort2(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();};
break;
case 2:
sort22(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;};
break;
case 3:
{clrscr();
puts("Sortare:");
puts("[1].Crescator");
puts("[2].Descrescator");
scanf("%d",&s3);
switch(s3)
{
case 1:

{
sort3(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();};
break;
case 2:
sort33(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;};
break;
case 4:
{clrscr();
puts("Sortare:");
puts("[1].Crescator");
puts("[2].Descrescator");
scanf("%d",&s4);
switch(s4)
{
case 1:
{
sort4(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();};

break;
case 2:
sort44(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;};
break;
case 5:
{clrscr();
puts("Sortare:");
puts("[1].Crescator");
puts("[2].Descrescator");
scanf("%d",&s5);
switch(s5)
{
case 1:
{
sort5(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();};
break;
case 2:
sort55(head,n);
clrscr();
puts("Tabloul a fost sortat");
puts("Doriti sa fie afisata lista sortata(1-da,0-nu)?");
scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("Lista dupa sortare");
printf("\n");
output(head);
}
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();

break;};
break;};
}}}}}
break;
case 9:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
printf("Dati numele statului care doriti sa-l modificati:");
fflush(stdin);
gets(num);
cautat=search1(head,num);
if(cautat==0)
{
puts("Statul nu a fost gasit in baza de date");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
modify(cautat);
clrscr();
puts("Modificarea a fost efectuata cu succes");
puts("Doriti sa fie afisat elementul modificat(1-da,0-nu)?");
scanf("%d",&g);
clrscr();
if(g)
{
printf("\t\t");
textcolor(12);
cputs("Elementul dupa modificare");
printf("\n");
antet();
afisare(cautat,id);
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
}
else break;
case 10:
clrscr();
textcolor(12);
printf("\t\t");cputs("<>><><>Adaugarea unui element<><><>"); printf("\n");
textcolor(11);
cputs("[1]. Adaugarea unui element la inceput"); printf("\n");
cputs("[2]. Adaugarea unui element la urma"); printf("\n");
cputs("[3]. Inserarea unui element dupa elementul dat");printf("\n");
cputs("[4]. Inserarea unui element inaintea elementului dat");printf("\n");
scanf("%d", &nm1);
switch(nm1)
{
case 1:
{puts("Introduce-ti informatia despre elementul de adaugat");
introducere(&s);
head=addathead(head,s);
if (!head)
{puts("Lista este vida");}
if (head) {puts("Elementul a fost adaugat cu succes");}
getch();
break;}
case 2:

clrscr();
puts("Dati numele elementului dupa care doriti sa inserati");
fflush(stdin); gets(num);
cautat=search1(head,num);
if (cautat==NULL)
{
puts("Acest element nu exista");
getch();
break;
}
puts("Introduceti datele despre elementul care doriti sa-l adaugati");
introducere(&s);
rs=insertafter(cautat, s,&n);
if (rs==-1) {puts("Elementul nu a fost adaugat");}
if (rs==1) {puts("Elementul a fost adaugat cu succes");}
getch();
break;
case 3:
clrscr();
puts("Dati numele elementului inaintea caruia doriti sa inserati");
fflush(stdin); gets(num);
cautat=search1(head,num);
if (cautat==NULL)
{
puts("Acest element nu exista");
getch();
break;
}
puts("Introduceti datele despre elementul care doriti sa-l adaugati");
introducere(&s);
head=insertbefore(head,cautat,s,&n);
puts("Elementul a fost adaugat cu succes");
getch();
break;
}break;
case 11:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
printf("\t\t\t");
textcolor(12);
cputs("Lista de structuri");
printf("\n");
output(head);
printf("/n");
puts("Dati numele elementului care doriti sa-l stergeti");
fflush(stdin);
gets(num);
clrscr();
cautat=search1(head, num);
if (cautat==NULL)
{
puts("Acest element nu exista");
getch();
break;
}
head=delete1(head,cautat,&n);
puts("Stergerea a fost efectuata cu succes");
getch();
break;

case 12:
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
clrscr();
puts("Dati numarul de elemente pastrate in prima lista");
scanf("%d",&nm1);
while (nm1>=n)
{
printf("Dati un numar mai mic decit %d",n);
scanf("%d",&nm1);
}
head2=devide(head,nm1);
n=n-nm1;
if (head2==NULL)
{
puts("Divizarea nu a fost facuta");
}
else
{
puts("Doriti sa fie afisate listele formate?(1-da,0-nu)");
scanf("%d",&g);
clrscr();
if(g)
{
printf("\t\t\t");
textcolor(12);
cprintf("Lista a fost divizata in:");
printf("\n");
printf("\t\t\t");
textcolor(11);
cprintf(" Lista Nr.1");
printf("\n");
output(head);
printf("\n");
printf("\t\t\t");
textcolor(11);
cputs(" Lista Nr.2");
printf("\n");
output(head2);
}
}
getch();
break;
case 13:
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
clrscr();
rs=concat(head, &head2);
n=length(head);
if (rs==0) {puts("Listele nu au fost concatenate");getch();break;}
if(rs==1) {puts("Listele au fost concatenate cu succes");}
puts("Doriti sa afiseze lista obtinuta? (1-da,0-nu)");
scanf("%d",&nm1);
clrscr();
if(nm1)
printf("\t\t\t");

textcolor(12);
cprintf("Lista obtinuta dupa concatenare");
printf("\n");
output(head);
getch();
break;
case 14:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
c=last(head);
if(c)
printf("Numele ultimului element este:<<");
textcolor(12);
cprintf("%p",c);
puts(">>");
puts("Pentru a continua apasa-ti tasta 'Enter'");
getch();
break;
case 15:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
puts("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;}
getch();
break;
case 16:
clrscr();
if(!head)
{
puts("Memoria nu a fost alocata");
getch();
break;
}
puts("Dati numele fisierului din care doriti sa incarcati lista");
fflush(stdin);
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");
getch();
clrscr();
puts("Doriti sa fie afisata lista incarcata(1-da,0-nu)?");

scanf("%d",&g);
if(g)
{
clrscr();
printf("\t\t\t");
textcolor(12);
cputs("
Lista incarcata");
printf("\n");
output(head);
}
}
getch();
break;
case 0:
clrscr();
if(head)
{if(!m)
{
printf("Informatia va fi pierduta...salvati?(0-da,1-nu)");
scanf("%d",&f);
if(!f)
{puts("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",&g);
if(g)
{
if(head)
{
free(head);
head=NULL;
}
return 0;
}
else
break;
default:
puts("Alegeti optiunea corect");
getch();
}
}
}