Laborator nr 4

Stive i cozi n ingineria programrii

1. Probleme rezolvate cu stive si cozi.

Problema 1.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)
{
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();
}
}

Problema 1.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
{
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)
{
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);
}
}
}

2. Probleme propuse pentru rezolvare cu stive i cozi.

Problema 2.1. 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 2.2. 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, prt si valoare).