Laborator nr 4

 
Stive şi cozi în ingineria programării
 
                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, prêt
si valoare).