Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică şi Microelectronică

Departamentul Informatica și Ingineria Sistemelor

RAPORT
la lucrarea de laborator nr. 4

la Programarea Calculatoarelor

Tema: Analiza prelucrării structurilor de date cu liste

Varianta I

A efectuat: st. gr.

A verificat: Marin Ştefan

Chişinău – 2019
Scopul lucrării:
1. de studiat şi însuşit materialul teoretic pentru evidenţierea esenţialului proiectarii structuri
pentru reprezentarea etapelor prelucrării structurilor de date cu liste în elaborarea modelelor
soluţiei, analizând exemplele din text;
2. să se selecteze problemele din compartimentul “3 şi Anexe” şi să se elaboreze
organigramele (pentru funcţiile principale) şi programele cu liste (declarări, parcurgeri, etc.),
pentru aprofundare şi rularea programelor în limbajul C să se elaboreze scenariile succinte de
soluţionare prin respectiva tehnică de prelucrare cu calculele de verificare şi explicaţii.
3. să se analizeze tehnica modelării şi programării eficiente pentru diverse
compartimente ale diferitor situaţii cu diverse argumentări şi modele de structuri abstracte,
incluzând fişiere cu teste de verificare şi vizualizări. Prezentarea succinta a utilizarii listelor, stivelor
si cozilor, explicand prin organigrame cum are loc apelul prin referință și parcurgerea nodurilor.

ÎNTREBĂRI ŞI EXERCIŢII
1. Definiţi noţiunea – tip abstract de date.
Tipul de date abstract este o entitate manipulata doar prin operatiile ce definesc acel tip. Avantajele utilizarii
tipurilor de date abstracte sunt:
- Programele devin independente de modul de reprezentare a datelor. Modul de reprezentare poate fi modificat,
fara însa a afecta restul programului (de exemplu, o multime poate fi implementata printr-un tablou sau printr-o
lista ordonata, dar partea de program ce foloseste operatorii tipului abstract rămâne neschimbata).
- Se previne violarea accidentala a datelor. Utilizatorul tipului abstract este forţat sa manipuleze datele doar prin
intermediul operatorilor ce compun tipul abstract, astfel reducându-se riscul unei distrugeri a datelor.
2. Cum se defineşte o structură?
O structură este o colecţie de valori eterogene ca tip, stocate într-o zonă compactă de memorie. Cu alte cuvinte,
o structură este un tip de date care permite gruparea unor date de tipuri diferite sub un singur nume.
Componentele unei structuri, denumite câmpuri, sunt identificate prin nume simbolice, denumite selectori.
Câmpurile unei structuri pot fi de orice tip, simplu sau derivat, dar nu void sau funcţie. Printr-o declaraţie struct
se defineşte un nou tip de date de tip structură, de către programator.
– in c typedef struct<nume>{ . . }. " , in c## struct<nume >{ . . . }
In structura este obligator sa fie indicat cel putin un element. Determinarea structurii are forma :
<tipul de date > descrierea.
Unde <tipul de date> indica tipul structurii pentru obiecte , determinate in descriere. In cel mai
simplu caz descrierile prezinta din sine identificatori sau massivului
Exemplu: struct {double x,y} s1,s2,sm[9];

struct { int year; char moth, day;} date1, date2;

3. Prin ce se deosebeşte structura de alte tipuri de date?

Deosebire intre manipularea unei stive și manipularea unei cozi, constă în faptul că lucrul cu o coada implica
"monitorizarea" a varfului si a cozii.Iar principalele avantaje ale utilizării unor tipuri structură sunt: Programele
devin mai explicite dacă se folosesc structuri în locul unor variabile separate. Se pot defini tipuri de date specifice
aplicaţiei iar programul reflectă mai bine universul aplicaţiei. Se poate reduce numărul de parametri al unor funcţii
prin gruparea lor în parametri de tipuri structură şi deci se simplifică utilizarea acelor funcţii. Se pot utiliza structuri
de date extensibile, formate din variabile structură alocate dinamic şi legate între ele prin pointeri (liste înlănţuite,
arbori ş.a).
4. Care sunt operațiile cu variabilile de tip structură?
Operaţiile posibile cu variabile de un tip structură sunt:
1) Selectarea unui câmp al unei variabile structură se realizează folosind operatorul de selecţie . . Cîmpul
selectat se comportă ca o variabilă de acelaşi tip cu câmpul, deci i se pot aplica aceleaşi prelucrări ca
oricărei variabile de tipul respectiv.
2) O variabilă structură poate fi iniţializată la declarare prin precizarea între {} a valorilor câmpurilor; cele
neprecizate sunt implicit 0.
3) O variabilă structură poate fi copiată în altă variabilă de acelaşi tip
4) Transmiterea ca argument efectiv la apelarea unei funcţii;
5) Transmiterea ca rezultat al unei funcţii, într-o instrucţiune return
5. Cum se face accesul la câmpurilor structurii?
Accesul la câmpurile unei variabile de tip structură se face utilizând operatorul punct (.). Exemplu: struct
complex c1; ... c1.re struct time t2; ... t2.ora struct time t[10]; ... t[0].min.
6. O structură poate oare să conţină altă structură?
Da, lucreaza exact cacompozitia in poo.
7. O structură poate oare să conţină pointer spre ea însăşi?
Da aceste tipuride structuri se numesc (self referential structures)
8. Poate oare să fie creată dinamic o variabilă de tip structură?
Da,struct carte{},*book; book=newbook;
9. Explicaţi cum are loc apelul prin referinţă și parcurgerea nodurilor.
Pentru modifcarea variabileide tip structura ea se transmite prin referinta:
void setare(structura*variabila_structurei,… parametri …); iar cind are loc apelull functiei se transmite adresa
variabilei si parametri.
10. Care este soluția de implementare a listelor, și ce avantaj au?
O solutie de implementare a listelor liniare este sub forma unei înlantuiri de elemente cu aceeasi structura, aflate în
memorie la diverse adrese si legate între ele prin intermediul pointerilor. Scopul utilizarii listelor este de a economisi
spatiu de memorie, motiv pentru care se foloseste alocarea dinamica în locul celei statice (utilizata în cazul
tablourilor
11. Cum poate fi accesat un nod al listei înlanțuite?
În funcţie de cerinţe, nodurile listei pot fi accesate secvenţial, extrăgând informaţia utilă din ele. O problemă mai
deosebită este găsirea unui nod de o cheie dată şi apoi extragerea informaţiei din nodul respectiv. Căutarea nodului
după cheie se face liniar, el putând fi prezent sau nu în listă.
12. Ce este lista liniara ?
Lista liniara este o structura dce date in care fiecare element are un succesor unic, (exceptie face ultimul element al
listei).
13. Ce este o stiva ?
Stiva reprezinta o lista liniara in care operatiile de introducere si extragere se efectueaza la unul din capetele
structurii. Primul element intalnit la acest capat poarta numele de varf. Orice ansamblu liniar asupra caruia putem
actiona prin introducerea sau extragerea unui element, doar la unul din capete, reprezinta o stiva.
14. Cum se genereaza un nod ?
Se generează nodul de introdus:
n=sizeof(TIP_NOD);
p=(TIP_NOD *)malloc(n); /* rezervare spaţiu de memorie în heap*/
citire date în nodul de adresă p;
15. Cum se fac legăturile între noduri ?
Se fac legăturile corespunzătoare:

p->urm = 0; /*nodul este ultimul în listă */

if(ultim != 0) ultim->urm = p; /* lista nu este vidă */
else prim = p;
/* nodul p este primul introdus în listă */
ultim=p;
16. Cum se face inversarea ?
Inserarea reprezinta o oparatie prin care un nou element este introdus in lista.
Intr-o lista generala, inserarea unui element se face la inceputul, in interiorul sau la sfarsitul ei. Deoarece, intr-o lista
neordonata, nu conteaza pozitia unde se efectueaza inserarea, se obisnuieste ca operatia sa se efectueze la sfarsitul
ei. In acest fel elementele pot fi gasite in ordinea in care au fost ele introduse (inserate). Acesta este si motivul
pentru care Inserarea reprezinta o oparatie prin care un nou element este introdus in lista.

Exerciţiul 1. Să se analizeze programul pentru crearea unei liste simplu înlănţuite cu preluarea
datelor de la tastatură. Sfârşitul introducerii datelor este marcat standard (CTRL+Z). După creare, se va
afişa conţinutul listei apoi se va elibera memoria ocupată.
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define NEW (NOD*)malloc(sizeof(NOD));
struct lista { int info; lista *next; };
typedef struct lista NOD;
NOD* creare() { NOD *prim,*ultim,*q; int nr;
printf(" primul nr="); scanf("%i",&nr); // se cite?te primul num?r
prim=(NOD*)malloc(sizeof(NOD)); prim->info=nr; // se creeaz? primul nod
prim->next=NULL; ultim=prim; // se creeaz? ultimul nod
printf("\n urmatorul nr sau tastati CTRL+Z pentru iesire) = "); scanf("%i",&nr); // se cite?te al doilea num?r
while(!feof(stdin)) // at?ta timp c?t nu introducem CTRL+Z
{ q=(NOD*)malloc(sizeof(NOD)); q->info=nr; // se creeaz? nodul urm?tor
q->next=NULL; ultim->next=q; ultim=q; // se creeaz? ultimul nod
 printf("\n urmatorul nr sau tastati CTRL+Z pentru iesire)= "); scanf("%i",&nr); // se cite?te num?rul
urm?tor
} return prim; }
void afis(NOD* prim) { printf("\n"); printf("\n Lista este");
while(prim!=NULL) // at?ta timp c?t p este diferit de NULL
{ printf("\t \n%i",prim->info); // se afi?eaz? nodul curent
prim=prim->next; // se trece la urm?torul nod
} }
void stergere (NOD* prim) { NOD *p;
while(prim) // at?ta timp c?t prim este diferit de NULL
{ p=prim; // p devine primul nod
prim=prim->next; // prim devine urm?torul nod
free(p); // se elibereaz? nodul curent
} }
main() { NOD *prim; int a,b,c,d,e,f,g;
// Creare
prim=creare(); afis(prim);
// Eliberare memorie
stergere(prim); getch();
}
Probleme la compilare obținute:

După înlăturarea erorilor:

 a)Scrieți programul pentru sortarea listei simplu înlănţuite și efectuați
organigrama.
Programul:
#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node* next;
};
// Funcție pentru a insera un nod dat într-o listă tridimensionată
void sortedInsert(struct Node**, struct Node*);

// Funcție pentru a sorta o lista simplu inlantuita

void insertionSort(struct Node **head_ref)
{
struct Node *sorted = NULL;

// Traversați lista de date asociată și introduceți fiecare

// nodul pentru sortare
struct Node *current = *head_ref;
while (current != NULL)
{
// Stocați pentru următoarea iterație
struct Node *next = current->next;

// Inserati acum in lista inlantuita

sortedInsert(&sorted, current);

// Actualizati
current = next;
}

// Actualizati head_ref pentru a indica sortarea listei inlantuite

*head_ref = sorted;
}

/* Functia insereaza a new_node in lista. Rețineți că această funcție așteaptă

un pointer la head_ref deoarece aceasta poate modifica capul listei de
intrări asociate(similar cu push())*/
void sortedInsert(struct Node** head_ref, struct Node* new_node)
{
struct Node* current;
 /* Caz special pentru sfârșitul capului */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/*Localizați nodul înainte de punctul de inserare*/
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}

/* Functioa pentru afisarea listei simplu inlantuite */

void printList(struct Node *head)
{
struct Node *temp = head;
while(temp != NULL)
{
printf("%d ", temp->data);
temp = temp->next;
}
}

/* funcție pentru a insera un nod la începutul listei */

void push(struct Node** head_ref, int new_data)
{
/* alocați nodul*/
struct Node* new_node = new Node;

new_node->data = new_data;

/* se leagă vechea listă a noului nod */

new_node->next = (*head_ref);

/*mutați capul în punctul spre noul nod*/

(*head_ref) = new_node;
}

// Facem testarea functiilor de mai sus

int main()
{
struct Node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf("Lista simplu inlantuita pina la sortare \n");
printList(a);

insertionSort(&a);
printf("\n Lista simplu inlantuita dupa sortare \n");
printList(a);
 return 0;
}

b) Scrieți programul care convertează lista simplu înlănţuită în lista circulară și

efectuați organigrama.
#include <bits/stdc++.h>

/* Nodul listei simplu înlănțuite */

struct Node {
int data;
struct Node* next;
};

// Functia care converteaza lista simplu înlănțuita in lista circulara.

struct Node* circular(struct Node* head)
{
// declarăm un start al variabilei nodului și atribuim nodul cap în nodul de
început.
struct Node* start = head;

// verificați că în timp ce capul-> următorul nu este egal cu NULL atunci capul

indică spre nodul următor.
while (head->next != NULL)
head = head->next;

// în cazul în care capul -> următorul punct pentru NULL, atunci începeți să
atribuiți capului -> următorul nod.
 head->next = start;
return start;
}

void push(struct Node** head, int data)

{
// Alocați memorie dinamică pentru newNode.
struct Node* newNode = (struct Node*)malloc
(sizeof(struct Node));

// Atribuiți datele în newNode.

newNode->data = data;

// newNode-> alocați apoi adresa nodului principal.

newNode->next = (*head);

// newNode devine headNode.

(*head) = newNode;
}

// Funcție care afișează elementele unei liste circulare .

void displayList(struct Node* node)
{
struct Node* start = node;

while (node->next != start) {

printf("%d ", node->data);
node = node->next;
}

//Afișați ultimul nod al listei circulare.

printf("%d ", node->data);
}

// programul pentru testarea funcțiilor

int main()
{
// Începeți cu o listă goală
struct Node* head = NULL;

// Folosind funcția push () pentru a construi

// listă simplu înlănțuitan
// 17->22->13->14->15
push(&head, 10);
push(&head, 12);
 push(&head, 14);
push(&head, 16);
push(&head, 17);

// Apelați funcția circular_list

// are loc convertarea
circular(head);

printf("Display list: \n");

displayList(head);

return 0;
}

Sa se implementeze un set de functii care sa realizeze urmatoarele operatii:

 adaug (t,id) - introduce identificatorul id în tabela de simboluri t;

 prezent (t,id) - returneaza 1 sau 0 dupa cum identificatorul id este sau nu
prezent în tabela t;
 sterg (t,id) - elimina id din tabela t;
 reuniune (t1,t2,t) - t va contine identificatorii prezenti în t1 sau t2;
 intersectie (t1,t2,t) - t va contine identificatorii prezenti atât în t1 cât si
in t2;
 diferenta (t1,t2,t) - t va contine identificatorii prezenti în t1 si absenti în t2;
 scriu(t) - tipareste în ordine alfabetica identificatorii din t.

Folosind functiile de mai sus sa se realizeze un program care citeste doua secvente
consecutive de text, care se termina fiecare cu caracterul `.`. Dupa citirea textelor se
cere sa se tipareasca, în ordine alfabetica, identificatorii prezenti doar în primul text,
apoi cei doar în al doilea text. În continuare se vor tipari în ordine alfabetica
identificatorii care sunt prezenti atât în primul cât si în al doilea text. În final se
afiseaza identificatorii care apar în cel putin unul din cele doua texte.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>
#define Max 100 /* lungimea maxima a unei linii */

/* tipul pentru nodul listei */

typedef struct elem
{
char *id;
int valoare;
struct elem *urm;
} nod;

nod *radacina=NULL; /* pastreaza inceputul listei */

/*---------------------------------------------------------*/
/* */
/* Functia caut cauta sirul s in lista al carei inceput */
/* e indicat de parametrul lista. Daca sirul apare in lista*/
/* atunci functia returneaza pointerul la nodul respectiv, */
/* in caz contrar returneaza NULL */
/* */
/*---------------------------------------------------------*/
nod *caut(nod *lista, char *s)
{
nod *q1;

for (q1=lista; q1!=NULL && strcmp(q1->id, s)<0; q1=q1->urm);

/* caut 1 */

if (q1!=NULL && strcmp(q1->id, s)==0) /* caut 2 */

return q1; /* daca sirul s a fost gasit in lista */

return NULL;
}

/*---------------------------------------------------------*/
/* */
/* Functia listez parcurge lista si pentru fiecare nod */
/*afiseaza identificatorul memorat si valoarea atasata lui.*/
/*Deoarece lista este ordonata, afisarea identificatorilor*/
/* este in ordine alfabetica */
/* */
/*---------------------------------------------------------*/
void listez(void)
{
nod *q;

for (q=radacina; q!=NULL; q=q->urm)

printf("Identificator: %s Valoare: %d\n",q->id,q->valoare);
}

/*---------------------------------------------------------*/
/* Functia sterg elimina din lista indicata de pointerul */
/* lista, nodul ce are campul id egal cu argumentul s */
/* */
/*---------------------------------------------------------*/
nod *sterg(nod *lista, char *s)
{
nod *q1, *q2;

for (q1=q2=lista; q1!=NULL && strcmp(q1->id, s)<0;

q2=q1,q1=q1->urm); /* sterg 1 */
/* se parcurge lista cautandu-se nodul avand */
/* campul id egal cu sirul s */

if (q1!=NULL && strcmp(q1->id, s)==0) /* sterg 2 */

{
/* daca s-a gasit un astfel de nod */
if (q1!=q2) /* daca nodul nu este la inceputul listei */
/* sterg 3 */
q2->urm = q1->urm; /* elimina nodul din lista */
else /* nodul apare la inceputul listei */
lista = lista->urm; /* sterg 4 */

free(q1->id);
/* se elibereaza memoria ocupata de nodul eliminat */
free(q1);

return lista;
/*returneaza pointerul catre inceputul listei modificate*/
}
else
{
printf("Eroare: identificatorul %s nu apare in lista\n", s);
return lista;
}
}
/*---------------------------------------------------------*/
/* */
/* Functia introduc insereaza un nod in lista ordonata, */
/* indicata de parametrul lista. Lista ramine ordonata si */
/* dupa inserare. Nodul nou are campul id egal cu sirul */
/* indicat de parametrul s, iar campul valoare egal cu */
/* parametrul v. Functia returneaza pointerul catre */
/* inceputul listei modificate */
/* */
/*---------------------------------------------------------*/
nod *introduc(nod *lista, char *s, int v)
{
nod *q1, *q2, *aux;
if ((aux=(nod *)malloc(sizeof(nod)))==NULL ||
(aux->id=(char *)malloc(strlen(s)+1))==NULL)
/* introduc 1 */
{
/* daca nu e memorie suficienta pentru a crea un nod nou,
respectiv pentru a memora sirul s, se da un mesaj de eroare
dupa care executia e incheiata */

printf("Eroare: memorie insuficienta\n");

exit(1);
}

strcpy(aux->id, s); /* se salveaza s in nodul nou */

aux->valoare=v; /* se salveaza v in nodul nou */

/* nodul nou este inserat in lista ordonata astfel incat ea

ramane ordonata si dupa inserare. Lista este parcursa
cautandu-se primul nod avand campul id mai mare
sau egal cu s */

for (q2=q1=lista; q1!=NULL && strcmp(q1->id, s)<0;

q2=q1, q1=q1->urm); /* introduc 2 */

if (q1!=NULL && strcmp(q1->id, s)==0) /* introduc 3 */

/* daca in lista apare un nod avand campul id egal cu s,
atunci se afiseaza un mesaj de eroare si se pastreaza
lista nemodificata*/
{
printf("Eroare: %s apare in tabela\n", s);
return lista;
 }

if (q1!=q2) /* daca inserarea nu se face la inceputul listei*/

/* introduc 4 */
{
q2->urm=aux;
aux->urm=q1;
return lista ;
}

/* daca inserarea se face la inceputul listei */

/* introduc 5 */
aux->urm=lista;
return aux;
}

/*Functia citesc_linie citeste urmatoarea linie de la tastatura */

/*si recunoaste identificatorul si valoarea asociata lui. */
/*Identificatorul este returnat in parametrul s, */
/*iar valoarea in parametrul val */
/* */
/*-------------------------------------------------------------*/
void citesc_linie(char *s, int *val)
{
int i, j;
char temp[Max];

/* citeste urmatoarea linie de la tastatura */

gets(temp); /* citesc_linie 1 */

s[0]='\0'; /* initializeaza valorile argumentelor */

for (i=0; temp[i]!='\0'; )
/* atata timp cat nu a fost atins sfarsitul sirului */
/* citesc_linie 2 */
{
if (isalpha(temp[i])) /* daca incepe un identificator */
/* citesc_linie 3 */
{
j=0;

/* memoreaza identificatorul in s */
while (isalnum(temp[i]))
s[j++]=temp[i++]; /* citesc_linie 4 */

/* memoreaza sfarsitul de sir */

 s[j]='\0'; /* citesc_linie 5 */
continue;
}

if (isdigit(temp[i])) /* daca incepe un numar */

/* citesc_linie 6 */
{
*val=0;
while (isdigit(temp[i])) /* citesc_linie 7 */
{
/* calculeaza valoarea numarului */
*val=*val*10+temp[i]-'0' ; /* citesc_linie 8 */
i++;
}
continue;
}

/* altfel se trece peste caracterul curent */

i++; /* citesc_linie 9 */
} /* while */
}

/* Functia comanda_a realizeaza functionalitatea comenzii a */

void comanda_a(void)
{
int val;
char s[Max];

citesc_linie(s, &val); /* citeste o linie de la tastatura */

if (strlen(s)!=0) /* daca linia e corecta */
radacina=introduc(radacina, s, val);
else
printf("Eroare : linie incorecta\n");
}

/* Functia comanda_t realizeaza functionalitatea comenzii t */

void comanda_t(void)
{
int val;
char s[Max];
nod *p;

citesc_linie(s, &val); /* citeste o linie de la tastatura */

if (strlen(s)==0) /* daca linia e incorecta */
{printf("Eroare: linie incorecta\n"); return;}
 if ((p=caut(radacina, s))!=NULL) /* cauta nodul in lista */
printf("Identificator:%s Valoare:%d\n", p->id, p->valoare);
else
printf("Eroare: Identificator nedefinit\n");
}

/* Functia comanda_s realizeaza comanda s */

void comanda_s(void)
{
char s[Max];
int val;

citesc_linie(s, &val); /* citeste o linie de la tastatura */

if (strlen(s)==0) /* daca linia citita e incorecta */
{printf("Eroare: linie incorecta\n"); return;}

radacina=sterg(radacina, s); /* sterge nodul din lista */

}
/* Functia comanda_oper executa operatiile legate de comenzile +, -, *, / */
/* Se citesc cei doi operatori si se executa operatia dorita. */
/* Rezultatul este afisat. */
void comanda_oper(char c)
{
char s1[Max], s2[Max];
int val;
nod *p1, *p2;

/* se citeste primul operand */

citesc_linie(s1, &val); /* comanda_oper 1 */

/* se citeste al doilea operand */

citesc_linie(s2, &val); /* comanda_oper 2 */

if (strlen(s1)!=0 && strlen(s2)!=0)

if(((p1=caut(radacina, s1))!=NULL) &&
((p2=caut(radacina, s2))!=NULL)) /* comanda_oper 3 */
/* se verifica daca operanzii apar in lista */
{
switch(c) /* functie de tipul comenzii */
{
case '+':
val=p1->valoare+p2->valoare;
break;
 case '-':
val=p1->valoare-p2->valoare;
break;
case '*':
val=p1->valoare*p2->valoare;
break;
case '/':
if (p2->valoare!=0)
val=p1->valoare/p2->valoare;
else
printf("Eroare: Impartire la 0\n");
break;
}
printf("Rezultatul operatiei e %d\n", val);
}
else
printf("Operand nedefinit\n");
else
printf("Eroare: linie eronata\n");
}
/* Functia meniu afiseaza meniul programului,citeste comanda */
/* si apeleaza subrutina corespunzatoare */
void meniu(void)
{
char o;

while(1) /* meniu 1 */
{
clrscr();
/* se afiseaza meniul programului */
puts("a : adauga un identificator si valoarea asociata");
puts("t : tipareste valoarea asociata unui identificator");
puts("s : sterge un identificator");
puts("l : listeaza identificatorii si valorile asociate");
puts("+ : calculeaza suma pentru 2 identificatori");
puts("- : calculeaza diferenta pentru 2 identificatori");
puts("* : calculeaza produsul pentru 2 identificatori");
puts("/ : calculeaza impartirea pentru 2 identificatori");
puts("f : termina programul");
printf("\nOptiunea: ");
o=getche(); /* meniu 2 */
printf("\n\n");
switch (tolower(o)) /* meniu 3 */
{
case 'a':
 comanda_a(); break;
case 't':
comanda_t(); break;
case 's':
comanda_s(); break;
case 'l':
listez(); break;
case '+': case '-': case '*': case '/':
comanda_oper(o);
break;
case 'f':
return;
default:
printf("Eroare : Comanda inexistenta\n");
}
printf("\nApasa orice tasta...");
getch();
}
}
/* Functia main apeleaza functia meniu */
main()
{
meniu();
}

Concluzie
In urma efectuarii lucrarii de laborator nr.4 am însușit materialul teoretic,am aflat
multe lucruri curioase privitor la lucrul cu listele și fișierele,noi
funcții,organigramele pentru diferite liste,ce reprezină o structură și care sunt
variabilele ei,deasemenea utilizînd aceste cunoștințe în practică.

Bibliografia
1. .&quot;Limbajul de programare C&quot;. Brian W.Kernighan. Dennis M.Ritchie.
2. Liviu Negrescu. ”Limbajul de programare C şi C++” V.1-4. Buc. 1999
3. Knuth, D. E. - &quot;Arta programarii calculatoarelor, vol. 1: Algoritmi fundamentali&quot;, Ed.
Teora, 1999.
4.Indicații teoretice la lucrarea de laborator