Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing.

Mihail Buricea

Laborator nr 3

Structuri complexe de date in ingineria programarii

1. Probleme rezolvate cu liste.

Problema 1.1. Sa se ceeze o lista dublu inlantuita cu coordonatele spatiale ale mai multor puncte din spatiu si
apoi sa se afiseze pe ecran punctele cu coordonatele lor de la inceput spre sfarsit si invers.
#include<stdio.h>
#include<stdlib.h>
#include<alloc.h>
#include<conio.h>
void main(void)
{
struct tip_punct
{
float x;
float y;
float z;
struct tip_punct *anterior;
struct tip_punct *urmator;
} *var_punct,*primul_punct,*ultimul_punct;
float wx,wy,wz;
char raspuns;
int n=0,nf;
/* citirea coordonatelor primului punct */
primul_punct=(struct tip_punct*)malloc(sizeof(struct tip_punct));
if(primul_punct==NULL)
{
printf("\n memorie insuficienta ptr primul punct");
return;
}
printf("\n abscisa punctului P(%d),x%d=",n,n);
scanf("%f",&wx);
printf("\n ordonata punctului P(%d),y%d=",n,n);
scanf("%f",&wy);
printf("\n cota punctului P(%d),z%d=",n,n);
scanf("%f",&wz);
primul_punct->x=wx;
primul_punct->y=wy;
primul_punct->z=wz;
primul_punct->anterior=NULL;
primul_punct->urmator=NULL;
ultimul_punct=primul_punct;
var_punct=primul_punct;
printf("\n continuati adaugarea de puncte?(d/n):");
raspuns=getche();
while((raspuns=='d')||(raspuns=='d'))
{
/* citirea coordonatelor unui alt punct */
n++;
printf("\n abscisa punctului P(%d),x%d=",n,n);
scanf("%f",&wx);
printf("\n ordonata punctului P(%d),y%d=",n,n);
scanf("%f",&wy);
printf("\n cota punctului P(%d),z%d=",n,n);
scanf("%f",&wz);
ultimul_punct=(struct tip_punct*)malloc(sizeof(struct tip_punct));
if(ultimul_punct==NULL)
{

1
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

printf("\n memorie insuficienta ptr ultimul punct");

return;
}
ultimul_punct->x=wx;
ultimul_punct->y=wy;
ultimul_punct->z=wz;
ultimul_punct->anterior=var_punct;
ultimul_punct->urmator=NULL;
var_punct->urmator=ultimul_punct;
var_punct=ultimul_punct;
printf("\n continuati adaugarea de puncte?(d/n):");
raspuns=getche();
}
/* listarea punctelor de la inceput pana la sfarsit */
printf("\n lista punctelor de la inceput pana la sfarsit:");
printf("\n =============================================");
var_punct=primul_punct;n=0;
while(var_punct->urmator!=NULL)
{
printf("\n P%d(%f,%f,%f)",n,var_punct->x,var_punct->x,var_punct->x);
var_punct=var_punct->urmator;
n++;
}
printf("\n P%d(%f,%f,%f)",n,var_punct->x,var_punct->x,var_punct->x);
printf("\n =============================================");
nf=n;
/* listarea punctelor de la sfarsit catre inceput */
printf("\n lista punctelor de la sfarsit catre inceput:");
printf("\n =============================================");
var_punct=ultimul_punct;n=0;
while(var_punct->anterior!=NULL)
{
printf("\n P%d(%f,%f,%f)",n,var_punct->x,var_punct->x,var_punct->x);
var_punct=var_punct->anterior;
nf--;
}
printf("\n P%d(%f,%f,%f)",n,var_punct->x,var_punct->x,var_punct->x);
printf("\n =============================================");
}
Variabilele alocate dinamic vor fi memorate in zona Heap. La finalul executiei programului se poate sti
adresa primului, respectiv ultimului punct memorat. Locurile din memorie ale celorlalte puncte sunt
necunoscute.
Parcurgerea si extragerea datelor referitoare la puncte sunt permise numai secvential, cu ajutorul
variabilelor de tip pointer incluse in variabilele dinamice (anterior, urmator).
Daca in variabila de tip pointer var_punct se pune continutul variabilei primul_punct, atunci var_punct
= primul_punct si se poate referi primul punct prin var_punct. Referirea la un camp al variabilei dinamice de tip
punct se face prin var_punct-> urmat de numele campului:
var_punct-> x - contine abscisa primului punct.
var_punct -> y - contine ordonata primului punct.
var_punct -> z - contine cota primului punct.
var_punct->urmator - contine adresa unde este memorat urmatorul punct.
De asemenea se poate initia un sir de instructiuni pentru a extrage pe rand datele referitoare la punctele
memorate astfel:
var_punct = var_punct->urmator
(var_punct va contine adresa de memorie in care a fost memorat urmatorul punct)
Referirea la campurile noului punct se va face la fel ca mai inainte. Se va continua aceasta procedura de
prelucrare a datelor referitoare la punctele consecutive pana cand variabila var_punct va avea valoarea egala cu
variabila ultimul_punct, sau cand campul var_punct->urmator va avea valoarea NULL.
Se observa ca variabilele dinamice (de tip pointer) pot interveni in program in doua moduri.

2
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

Primul, cand se foloseste variabila simplu, fara referire, caz in care singurele operatii permise intre ele
sunt cele de atribuire (initializarea unei variabile dinamica cu constanta NULL sau tansferul continutului intre
variabile dinamice de acelasi tip).
Al doilea mod este cand se foloseste ca si referire la o variabila dinamica (var_dinamica1->
var_dinamica2->) caz in care se lucreaza cu variabile dinamice.

Problema 1.2. Sa se creeze o lista simplu inlantuita de articole cu structura:cod produs un camp numeric de
maximum 4 caractere, denumirea produsului un camp alfanumeric de maximum 15 caractere, unitatea de masura
un camp de 2 caractere alfabetice(bc,kg,mp,ml,mc,l,hl, etc.) si pretul produsului, in ordinea introducerii de la
tastatura si apoi sa se afiseze pe ecran lista.
#include<stdio.h>
#include<string.h>
#include<alloc.h>
#include<conio.h>
#include<float.h>
struct tipart
{
int ca;
char denumire[15];
char umas[3];
long int pret;
struct tipart *urm;
};
char raspuns;
struct tipart *artprim,*artanterior,*artcurent;
int primapel=1;
void adaugare()
{
artcurent=(struct tipart*)malloc(sizeof(struct tipart));
if(artcurent==NULL)
{
printf("\n memorie insuficienta ptr articolul curent");
return;
}
if(primapel==1)
{
artprim=artcurent;
primapel=0;
}
else /*nu e primul apel */
artanterior->urm=artcurent;
artcurent->urm=NULL;
artanterior=artcurent;
printf("\n cod articol(1..9999):");
scanf("%d",&artcurent->ca);
printf("\n denumire articol:");
scanf("%s",&artcurent->denumire);
printf("\n unitate de masura (bc,kg,ml,mp,mc.l,hl,etc):");
scanf("%s",&artcurent->umas);
printf("\n pret articol(real):");
scanf("%ld",&artcurent->pret);
}
void listare()
{
printf("\n %4d %-15s %-2s %7ld",artcurent->ca,artcurent->denumire,
artcurent->umas,artcurent->pret);
}
void citestelista()
{
artcurent=artprim;

3
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

printf("\n cod denumire u.m. pret ");

printf("\n =================================");
while(artcurent->urm!=NULL)
{
listare();
artcurent=artcurent->urm;
}
listare();
printf("\n =================================");
}
void main(void)
{
printf("\n creati lista de articole?(d/n):");
raspuns=getche();
primapel=1;
artanterior=NULL;
while((raspuns=='d')||(raspuns=='D'))
{
adaugare();
printf("\n adaugati in lista de articole?(d/n):");
raspuns=getche();
}
citestelista();
}
Problema 1.3. Se considera o lista dublu inlantuita de studenti cu structura:cod matricol, nume, prenume si
media. Sa se scrie programul in C pentru crearea, ordonarea dupa medie si afisarea listei studentilor folosindu-se
cate o functie adecvata pentru fiecare operatie (creare, ordonare si listare).
#include<stdio.h>
#include<string.h>
#include<alloc.h>
#include<conio.h>
#include<float.h>
struct tipstud
{
int cm;
char nume[20];
char prenume[20];
int media;
struct tipstud *ant;
struct tipstud *urm;
};
int nrstud,ok,auxmed,auxcm;
char auxn[20],auxp[20];
char raspuns;
struct tipstud *studprim,*studultim,*studcurent,*student;
void creare()
{
studprim=(struct tipstud*)malloc(sizeof(struct tipstud));
if(studprim==NULL)
{
printf("\n memorie insuficienta ptr primul student");
return;
}
do
{
printf("\n cod matricol (1-99):");
scanf("%d",&studprim->cm);
}
while ((studprim->cm<1)||(studprim->cm>99));
printf("\n nume student:");

4
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

scanf("%s",studprim->nume);
printf("\n prenume student:");
scanf("%s",studprim->prenume);
do
{
printf("\n media (1-99):");
scanf("%d",&studprim->media);
}
while ((studprim->media<1)||(studprim->media>10));
studprim->ant=NULL;
studprim->urm=NULL;
studultim=studprim;
studcurent=studprim;
nrstud=1;
printf("\n continuati adaugarea unui student in lista ?(d/n):");
raspuns=getche();
while((raspuns=='d')||(raspuns=='d'))
{
studultim=(struct tipstud*)malloc(sizeof(struct tipstud));
if(studultim==NULL)
{
printf("\n memorie insuficienta ptr ultimul student");
return;
}
do
{
printf("\n cod matricol (1-99):");
scanf("%d",&studultim->cm);
}
while ((studultim->cm<1)||(studultim->cm>99));
printf("\n nume student:");
scanf("%s",studultim->nume);
printf("\n prenume student:");
scanf("%s",studultim->prenume);
do
{
printf("\n media (1-99):");
scanf("%d",&studultim->media);
}
while ((studultim->media<1)||(studultim->media>10));
studultim->ant=studcurent;
studultim->urm=NULL;
studcurent->urm=studultim;
studcurent=studultim;
nrstud++;
printf("\n continuati adaugarea unui student in lista ?(d/n):");
raspuns=getche();
}
free(studcurent);
return;
}
void listare()
{
studcurent=(struct tipstud*)malloc(sizeof(struct tipstud));
if(studcurent==NULL)
{
printf("\n memorie insuficienta ptr studentul curent");
return;
}
printf("\n doriti afisarea listei de studenti?(d/n):");

5
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

raspuns=getche();
while((raspuns=='d')||(raspuns=='d'))
{
studcurent=studprim;
printf("\n matricol nume prenume media");
printf("\n =======================================");
while (studcurent->urm!=NULL)
{
printf("\n %5d %-10s %-10s %3d",studcurent->cm,studcurent->nume,
studcurent->prenume,studcurent->media);
studcurent=studcurent->urm;
}
printf("\n %5d %-10s %-10s %3d",studcurent->cm,studcurent->nume,
studcurent->prenume,studcurent->media);
printf("\n =======================================");
printf("\n doriti afisarea listei de studenti?(d/n):");
raspuns=getche();
}
free(studcurent);
return;
}
void ordonare()
{
printf("\n doriti ordonarea dupa medii a listei?(d/n):");
raspuns=getche();
studcurent=(struct tipstud*)malloc(sizeof(struct tipstud));
if(studcurent==NULL)
{
printf("\n memorie insuficienta ptr studentul curent");
return;
}
while((raspuns=='d')||(raspuns=='d'))
{
ok=1;
while(ok==1)
{
ok=0;
studcurent=studprim;
do
if(studcurent->media>studcurent->urm->media)
{
auxcm=studcurent->cm;
studcurent->cm=studcurent->urm->cm;
studcurent->urm->cm=auxcm;
auxmed=studcurent->media;
studcurent->media=studcurent->urm->media;
studcurent->urm->media=auxmed;
strcpy(auxn,studcurent->nume);
strcpy(studcurent->nume,studcurent->urm->nume);
strcpy(studcurent->urm->nume,auxn);
strcpy(auxp,studcurent->prenume);
strcpy(studcurent->prenume,studcurent->urm->prenume);
strcpy(studcurent->urm->prenume,auxp);
studcurent=studcurent->urm;
ok=1;
}
else
studcurent=studcurent->urm;
while (studcurent->urm!=NULL);
}

6
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

printf("\n doriti ordonarea dupa medii a listei?(d/n):");

raspuns=getche();
}
free(studcurent);
}
void main(void)
{
creare();
listare();
ordonare();
listare();
free(studprim);
free(studultim);
}

Problema 1.4. Se considera o lista simplu inlantuita de studenti cu structura:cod matricol, nume si media. Sa se
scrie programul in C pentru crearea, actualizare (adaugari si stergeri) si afisarea listei studentilor promovati, a
studentilor bursieri(peste media 8) si a studentilor restantieri.
#include<stdio.h>
#include<string.h>
#include<alloc.h>
#include<conio.h>
#include<process.h>
struct tipstud
{
int cm;
char nume[20];
float media;
struct tipstud *urm;
};
struct tipstud *prim,*ultim;
void adaugare(int wcm,char *wnume,float wmedia)
{
struct tipstud *pstud;
pstud=(struct tipstud*)malloc(sizeof(struct tipstud));
if(pstud==NULL)
{
printf("\n memorie insuficienta");
return;
}
strcpy(pstud->nume,wnume);
pstud->media=wmedia;
pstud->cm=wcm;
pstud->urm=NULL;
if(prim==NULL) prim=ultim=pstud;
else
{
ultim->urm=pstud;
ultim=pstud;
}
} /* sf procedura de adaugare*/
void stergere(struct tipstud *pstud)
{
struct tipstud *qstud;
if(!pstud) return;
if(prim==pstud)
{
prim=pstud->urm;
if(prim==NULL) ultim=NULL;
}

7
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

else
{
for(qstud=prim;(qstud->urm!=pstud)&&(qstud->urm!=NULL);qstud=qstud->urm);
{
if(qstud->urm==NULL)
{
printf("/n nodul nu apartine listei");
return;
}
qstud->urm=pstud->urm;
if(pstud==ultim) ultim=qstud;
}
free(pstud);
}
}
void main(void)
{
char wnume[20];
float wmedia;
int wcm;
struct tipstud *pstud,*qstud;
int i,n;
printf("\n Numarul studentilor:");
scanf("%d",&n);
prim=ultim=NULL;
for (i=0;i<n;i++)
{
printf("\n Codul matricol:");scanf("%d",&wcm);
printf("\n Nume:"); scanf("%s",wnume);
printf("\n Media:");scanf("%f",&wmedia);
adaugare(wcm,wnume,wmedia);
}
printf("\n lista studentilor bursieri: ");
printf("\n ===============================");
for(pstud=prim;pstud!=NULL;pstud=pstud->urm)
if(pstud->media>=8)
printf("\n %d %-20s %5.2f",pstud->cm,pstud->nume,pstud->media);
pstud=prim;
printf("\n ===============================\n");
printf("\n lista studentilor restantieri: ");
printf("\n ===============================");
while(pstud!=NULL)
{
if(pstud->media<5)
{
printf("\n %d %-20s %5.2f",pstud->cm,pstud->nume,pstud->media);
qstud=pstud->urm;
stergere(pstud);
pstud=qstud;
}
else
pstud=pstud->urm;
}
printf("\n ===============================\n");
printf("\n lista studentilor promovati ");
printf("\n ===============================");
for(pstud=prim;pstud!=NULL;pstud=pstud->urm)
printf("\n %d %-20s %5.2f",pstud->cm,pstud->nume,pstud->media);
printf("\n ===============================\n");
}

8
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

2. Probleme rezolvate cu stive si cozi.

Problema 2.1. Se considera o stiva de containere cu caracteristicile:cod container un numar cuprins intre 1 si 99,
continut un camp alfanumeri de 20 caractere, data ambalarii (zi, luna si an) si greutatea in kg. Sa se simuleze
activitatile de stivuire si de incarcare intr-un mijloc de transport a containerelor din stiva.
Evenimentele care pot avea loc cu aceasta stiva de containere sunt: sosirea unuinou container pentru
stivuire simulata prin apasarea tastei S si incarcarea intr-un mijloc de transport a unui container simulata prin
apasarea tastei I. Pentru un container sosit pentru stivuire se vor cere:codul, continutul, data ambalarii si
greutatea iar la incarcarea sa intr-un mijloc de transport pentru plecare se afisaza aceleasi informatii. Stiva
containerelor se va implementa ca o lista simplu inlantuita, identificata prin variabila varf care arata containerul
vizibil din varful stivei, adica primul element din lista de containere (ultimul asezat in stiva). Intrucat toate
operatiile asupra unei stive se fac pe la capatul de inceput al listei, nu este necesara memorarea adresei ultimului
element din lista (care a fost asezat primul in stiva). Functia push() va simula asezarea unui nou container in
stiva si va returna valoarea 0 in cazul in care nu s-a reusit alocarea dinamica a spatiului de memorie necesar
pentru introducerea unui nou element (informatiile containerului) in stiva de containere si valoarea 1 in caz
contrar. Functia pop() va oferi informatii, prin intermediul parametrilor sai, despre containerul scos din stiva
pentru expediere si va returna valoarea 1 daca in stiva nu mai sunt containere si valoarea 0 in caz contrar.
#include<stdio.h>
#include<string.h>
#include<alloc.h>
#include<conio.h>
struct tipdata
{
int zi;
int luna;
int an;
};
struct tipstiva
{
int cc;
char continut[20];
struct tipdata data;
int greutate;
struct tipstiva *urm;
};
struct tipstiva *varf;
/* descrierea functiei push() */
int push(int *wcc,char *wcontinut,struct tipdata *wdata,int *wgreutate)
{
struct tipstiva *ptrcontainer;
ptrcontainer=(struct tipstiva*)malloc(sizeof(struct tipstiva));
if(ptrcontainer==NULL)
{
printf("\n memorie insuficienta ptr memorarea unui container ");
return 0;
}
ptrcontainer->cc=*wcc;
strcpy(ptrcontainer->continut,wcontinut);
ptrcontainer->data.zi=wdata->zi;
ptrcontainer->data.luna=wdata->luna;
ptrcontainer->data.an=wdata->an;
ptrcontainer->greutate=*wgreutate;
ptrcontainer->urm=varf;
varf=ptrcontainer;
return 1;
}
/* descrierea functiei de extragere din stiva */
int pop(int *ptrcc,char *ptrcontinut,struct tipdata *ptrdata,int *ptrgreutate)
{

9
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

struct tipstiva *ptrcontainer;

ptrcontainer=varf;
if(!varf) return 0;
varf=ptrcontainer->urm;
*ptrcc=ptrcontainer->cc;
strcpy(ptrcontinut,ptrcontainer->continut);
ptrdata->zi=ptrcontainer->data.zi;
ptrdata->luna=ptrcontainer->data.luna;
ptrdata->an=ptrcontainer->data.an;
*ptrgreutate=ptrcontainer->greutate;
free(ptrcontainer);
return 1;
}
void main(void)
{
int wcc;
char wcontinut[20];
struct tipdata wdata;
int wgreutate;
char rasp;
int terminat=0;
varf=NULL;
while(!terminat)
{
clrscr();
printf("\n a - asezare container in stiva");
printf("\n s - scoatere container din stiva");
printf("\n t - terminare program");
printf("\n Alegeti operatia dorita:");
rasp=getche();
switch (rasp)
{
case 'a': printf("\n cod container:");scanf("%d",&wcc);
printf("\n continut container:");scanf("%s",&wcontinut);
printf("\n ziua ambalarii:");scanf("%d",&wdata.zi);
printf("\n luna ambalarii:");scanf("%d",&wdata.luna);
printf("\n anul ambalarii:");scanf("%d",&wdata.an);
printf("\n greutate container:");scanf("%d",&wgreutate);
if(push(&wcc,wcontinut,&wdata,&wgreutate))
printf("\n containerul a fost asezat in stiva");
else
printf("\n memorie insuficienta ptr container");
break;
case 's': if(pop(&wcc,wcontinut,&wdata,&wgreutate))
printf("\n containerul %d,%s,%d kg,din %d/%d/%d a fost scos din stiva",
wcc,wcontinut,wgreutate,wdata.zi,wdata.luna,wdata.an);
else
printf("\n nu mai exista containere");
break;
case 't': terminat=1;
break;
default: printf("\n operatie aleasa gresit");
}
printf("\n Apasati o tasta pentru continuare:");
getch();
}
}

10
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

Problema 2.2. Se considera o coada de masini, la o statie de alimentare cu benzina, cu caracteristicile: numarul
de inmatriculare un camp alfanumeric de 10 caractere, tipul masinii un camp alfanumeric de 15 caractere,
culoarea un camp alfanumeric de 10 caractere. Sa se simuleze activitatile de alimentare cu benzina ale masinilor
din coada: adaugarea unei masini la coada, eliminarea din capul cozii a masinii alimentate si listarea tuturor
masinilor din coada folosindu-se cate o functie adecvat definite.
Evenimentele care pot avea loc cu aceasta coada sunt: adaugarea unei noi masini la coada, simulata prin
apasarea tastei a, eliminarea din coada a masinii alimentate simulata prin apasarea tastei e si listarea masinilor
din coada simulata prin apasarea tastei l. Pentru o masina sosita la coada se vor cere:numarul de inmatriculare,
tipul, culoarea si capacitatea rezervorului iar la plecarea masinii dupa ce a fost alimentata se vor afisa aceleasi
informatii. Listarea masinilor din coada presupune afisarea acelorasi informatii pentru toate masinile care sunt la
coada si urmeaza sa se alimenteze cu benzina. Coada masinilor se va implementa ca un tablou de pointeri spre
articole de tip structura care se initializeaza cu valoarea NULL. Toate operatiile asupr unei cozi se fac pe la
ambele capate ale listei si constau fie din adaugarea unei structuri de tip masina la sfarsitul cozii fie din
extragerea (stergera) unei structuri de tip masina la inceputul cozii. Functia qstore() va simula asezarea unei noi
masini la coada si verifica daca lista este completa. Functia qretrieve() simuleaza eliberarea unei masini din
coada si va returna NULL daca nu mai sunt masini in coada si va returna pozitia urmatoarei masini care va fi
eliberata, permitand in acest mod afisarea informatiilor despre masina care va fi eliberata.
#include<stdio.h>
#include<string.h>
#include<alloc.h>
#include<conio.h>
#include<process.h>
#define MAX 20
struct tipmasina
{
char numar[10];
char tip[15];
char culoare[10];
int capacitate;
};
struct tipmasina *ptrmasina[MAX],*qretrive(void);
int freepos=0;
int recupos=0;
/* descrierea functiei de adaugare masina la coada, adaugare() */
void qstore(struct tipmasina *q)
{
if(freepos==MAX)
{
printf("\n lista plina");
return;
}
ptrmasina[freepos]=q;
freepos++;
}
/* descrierea functiei de extragere masina din coada */
struct tipmasina *qretrieve(void)
{
if(recupos==freepos)
{
printf("\n nu mai sunt masini la coada");
return NULL;
}
recupos++;
return ptrmasina[recupos-1];
}
void adaugare()
{
char r;
struct tipmasina masina,*ptrmasina;
do

11
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

{
printf("\n introduceti in coada masina %d ?(d/n):",freepos+1);
r=getche();
ptrmasina=(struct tipmasina*)malloc(sizeof(struct tipmasina));
if(!ptrmasina)
{
printf("\n memorie insuficienta ptr o noua alocare");
return;
}
printf("\n numarul de inmatriculare al masinii:");
scanf("%s",&ptrmasina->numar);
printf("\n tipul masinii:");
scanf("%s",&ptrmasina->tip);
printf("\n culoarea masinii:");
scanf("%s",&ptrmasina->culoare);
printf("\n capacitatea rezervorului:");
scanf("%d",&ptrmasina->capacitate);
qstore(ptrmasina);
}
while ((r!='d')&&(r!='D'));
}
/* descrierea functiei de extragere (stergere) din stiva */
void stergere()
{ \
struct tipmasina *ptrmasina;
if((ptrmasina=qretrieve())==NULL) return;
printf("\n date despre masina iesita de la coada");
printf("\n ===================================================");
printf("\n masina %-10s,%-15s,%-10s,%3d l",ptrmasina->numar,ptrmasina->tip,
ptrmasina->culoare,ptrmasina->capacitate);
printf("\n ===================================================");
getch();
}
void listare()
{
int t;
printf("\n numar tip culoare capacitate(l)");
printf("\n ===============================================");
for(t=recupos;t<freepos;++t)
printf("\n %-10s%-15s %-10s %5d",ptrmasina[t]->numar,ptrmasina[t]->tip,
ptrmasina[t]->culoare,ptrmasina[t]->capacitate);
printf("\n ================================================");
getch();
}
/* descrierea functiei de stocare a unei masini */
void main(void)
{
int t; char rasp;
for(t=0;t<MAX;++t) ptrmasina[t]=NULL;
for(;;)
{
clrscr();
printf("\n a - asezare masina la coada ptr alimentare");
printf("\n e - alimentare si iesire masina de la coada");
printf("\n l - consultare si listare masini din coada");
printf("\n t - terminare program");
printf("\n Alegeti operatia dorita:");
rasp=getche();
switch (rasp)
{

12
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

case 'a': printf("\n soseste si se introduce o noua masina la coada");

adaugare();
break;
case 'e': printf("\n se alimenteaza si iese prima masina de la coada");
stergere();
break;
case 'l': printf("\n se listeaza masinile care se gasesc la coada");
listare();
break;
case 't': printf("\n terminarea gestionarii cozii de masini");
exit(0);
}
}
}

3. Probleme propuse pentru rezolvare.

Problema 3.1. Sa se creeze o lista liniara simplu si invers inlantuita de articole cu structura din problema 1.2.
anterior rezolvata care sa permita listarea articolelor in ordinea inversa introducerii datelor.
Indicatie: Pentru rezolvarea problemei va trebui sa introducem in corpul fiecarui articol un camp in care
sa se memoreze adresa articolului anterior. Totodata trebuie sa pastram adresa ultimului articol generat.
Problema 3.2. Sa se creeze o lista liniara dublu inlantuita de produse cu structura de la problema 2.2. anterior
rezolvata care sa permita exploatarea directa cat si inversa a listei (adica listarea produselor din lista).
Problema 3.3. Sa se creeze o lista dublu inlantuita cu angajatii unei firme ordonata dupa numele si prenumele
angajatilor si sa se actualizeze aceasta lista (adaugarea la locul potivit a unui nou angajat, stergerea cat si
modificarea datelor unui angajat) urmata de listarea la cerere a tuturor angajatilor.
Problema 3.4. Sa se creeze o lista dublu inlantuita cu stocurile articolelor de marfuri dintr-o firma ordonata dupa
codurile marfurilor si sa se actualizeze aceasta lista (adaugarea la locul potivit a unui articol , stergerea cat si
modificarea datelor unui articol ca urmare a intrarilor si iesirilor de articole) urmata de listarea la cerere a tuturor
articolelor, a celor care au suerit modificari, a celor sterse si a celor noi adaugate in lista.
Problema 3.5. Sa se creeze o lista dublu inlantuita de produse dintr-un nomenclator de produse cu structura: cod
produs, denumire, unitate de masura si pret) si sa se ordoneze crescator lista de produse dupa cod de produs, dupa
denumire si dupa pret afisandu-se aceste liste si in ordine descrescatoare prin parcurgerea inversa a acestor liste.
Problema 3.6. Se considera o linie de garare a 100 vagoane de marfa (stiva) cu caracteristicile:cod vagon un
numar cuprins intre 100 si 999, continut vagonului camp alfanumeri de 20 caractere, data incarcarii (zi, luna si
an) si greutatea in tone. Sa se simuleze activitatile de garare si de iesire din garare pentru formarea unei garnituri
de tren a cate 10 vagoane din stiva de vagoane.
Problema 3.7. Sa se simuleze activitatile legate de incarcarea tirurilor de marfuri alimentare, cu acelasi tip de
aliment, dintr-un depozit de marfuri alimentare (sosirea si plecarea), printr-o coada corespunzatoare si sa se
afiseze lista tuturor tirurilor care au fost incarcate si au plecat, lista tirurilor care asteapta sa fie incarcate
impreuna cu toate caracteristicile acestora (numar de inmatriculare, proprietar, sofer, cantitatea transportata, prêt
si valoare).

4. Tema de casa nr 2.
4.1. Sa se creeze un fisier de articole (materiale, produse, repere) de organizare secventiala, pornind de
la informatiile introduse de la tastatura si efectuindu-se validarile corespunzatoare, cu urmatoarea structura a
articolelor:
- cod articol - camp de tip numeric apartinind multimii [100..999];
- denumirea articolului - camp alfanumeric de 20 caractere;
- tip articol - camp numeric de o cifra zecimala cu semnificatiile: 0=articol de stoc, 1=articol de intrare,
2=articol de iesire material din stoc;
- cod gestiune- camp de tip numeric apartinand multimii gestiunilor (10,20,30,40,50,60,70,80,90);
- unitate masura - camp alfabetic din multimii (buc, kg, tone, ml, mc, mp, l, hl);
- cantitatea – camp real cu 5 cifre partea intreaga si 3 cifre pentru zecimale;
- pret - camp de tip real pozitiv cu 7 cifre pentru partea intreaga si 2 cifre pentru partea fractionara;
- valoarea - camp de tip real si se obtine prin inmultirea dintre valoarea campului cantitate si valoarea
campului pret;
- data de creare sau data ultimei actualizari despachetata luata din sistemul de operare.
4.2. Pornind de la fisierul anterior creeat sa se creeze o lista dublu inlantuita de articole in zona de
memorie heap

13
Ingineria Sistemelor de Programe (ISP), autor Sef de lucrari Dr. Ing. Mihail Buricea

4.3. Sa se sorteze crescator lista de articole dupa cod articol si tip articol (in aceasta ordine) care se va
lista, utilizindu-se un algoritm de sortare cunoscut.
4.4. Pornind de la lista anterior sortata sa se creeze o noua lista care sa contina stocurile de articole
(pentru un acelasi cod de articol, stocul final=stocul initial+intrari de articole-iesiri de articole. Apoi sa se listeze
pe ecran continutul listei de stocuri finale si sa se salveze intr-un fisier adecvat stocurile finale.
4.5. Sa se recreeze lista de stocuri finale pornind de la fisierul anterior salvat si sa se actualizeze, printr-
un meniu adecvat, aceasta lista (adaugari, modificari si stergeri de articole in lista) apoi sa se listeze pe ecran
lista astfel actualizata.
Precizare : Aplicatia se va proiecta utilizandu-se tehnica meniurilor pentru selectarea unei actiuni precizate in
tema

14