P. 1
structuri complexe de date in ingineria programarii in c (laborator nr 3 liste stive cozi)

structuri complexe de date in ingineria programarii in c (laborator nr 3 liste stive cozi)

|Views: 200|Likes:

More info:

Published by: Cristinel-Octavian Catrinoiu on Mar 16, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less

03/16/2011

pdf

text

original

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

ultimul_punct->z=wz. var_punct=ultimul_punct.%f)". Daca in variabila de tip pointer var_punct se pune continutul variabilei primul_punct. printf("\n =============================================").var_punct->x. cu ajutorul variabilelor de tip pointer incluse in variabilele dinamice (anterior. ultimul_punct->y=wy.var_punct->x. printf("\n continuati adaugarea de puncte?(d/n):"). 2 . atunci var_punct = primul_punct si se poate referi primul punct prin var_punct.n. while(var_punct->anterior!=NULL) { printf("\n P%d(%f.%f. /* listarea punctelor de la sfarsit catre inceput */ printf("\n lista punctelor de la sfarsit catre inceput:"). Ing.var_punct->x. La finalul executiei programului se poate sti adresa primului. Locurile din memorie ale celorlalte puncte sunt necunoscute. 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. var_punct=ultimul_punct. var_punct=var_punct->anterior.Ingineria Sistemelor de Programe (ISP). var_punct -> z . } Variabilele alocate dinamic vor fi memorate in zona Heap.n.%f.%f)". } printf("\n P%d(%f. raspuns=getche(). ultimul_punct->anterior=var_punct. sau cand campul var_punct->urmator va avea valoarea NULL. printf("\n ============================================="). 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.contine abscisa primului punct. } /* listarea punctelor de la inceput pana la sfarsit */ printf("\n lista punctelor de la inceput pana la sfarsit:").var_punct->x).contine cota primului punct. return. autor Sef de lucrari Dr. nf=n.var_punct->x. Parcurgerea si extragerea datelor referitoare la puncte sunt permise numai secvential. var_punct=var_punct->urmator.%f. } printf("\n P%d(%f.var_punct->x. printf("\n =============================================").var_punct->x.%f)". Mihail Buricea printf("\n memorie insuficienta ptr ultimul punct"). Referirea la un camp al variabilei dinamice de tip punct se face prin var_punct-> urmat de numele campului: var_punct-> x . ultimul_punct->urmator=NULL. printf("\n ============================================="). urmator). var_punct->urmator .contine ordonata primului punct.var_punct->x). respectiv ultimului punct memorat.var_punct->x. var_punct->urmator=ultimul_punct.n=0. } ultimul_punct->x=wx. nf--. var_punct=primul_punct. while(var_punct->urmator!=NULL) { printf("\n P%d(%f. n++.%f)".n. Se observa ca variabilele dinamice (de tip pointer) pot interveni in program in doua moduri.var_punct->x.var_punct->x).%f.n=0.var_punct->x). var_punct -> y .n.contine adresa unde este memorat urmatorul punct.

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

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

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

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

autor Sef de lucrari Dr.float wmedia) { struct tipstud *pstud. else { ultim->urm=pstud. pstud=(struct tipstud*)malloc(sizeof(struct tipstud)). nume si media. actualizare (adaugari si stergeri) si afisarea listei studentilor promovati.h> #include<alloc. return. ordonare(). free(studprim). }.*ultim. if(prim==NULL) prim=ultim=pstud. Ing. pstud->media=wmedia. Sa se scrie programul in C pentru crearea. Mihail Buricea printf("\n doriti ordonarea dupa medii a listei?(d/n):"). } strcpy(pstud->nume. } free(studcurent).h> #include<string.h> #include<process. void adaugare(int wcm. listare(). ultim=pstud. struct tipstud *prim. if(!pstud) return. if(prim==pstud) { prim=pstud->urm. #include<stdio. char nume[20]. if(pstud==NULL) { printf("\n memorie insuficienta"). float media. } 7 .char *wnume. a studentilor bursieri(peste media 8) si a studentilor restantieri.4. } void main(void) { creare().h> struct tipstud { int cm. pstud->urm=NULL. } } /* sf procedura de adaugare*/ void stergere(struct tipstud *pstud) { struct tipstud *qstud. Se considera o lista simplu inlantuita de studenti cu structura:cod matricol. pstud->cm=wcm. raspuns=getche(). struct tipstud *urm.Ingineria Sistemelor de Programe (ISP).h> #include<conio. } Problema 1. free(studultim). if(prim==NULL) ultim=NULL. listare().wnume).

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

Problema 2. Mihail Buricea 2.1. autor Sef de lucrari Dr. varf=ptrcontainer.char *ptrcontinut. struct tipstiva *urm. ptrcontainer->data. ptrcontainer->urm=varf. continutul.struct tipdata *ptrdata. Functia pop() va oferi informatii. return 1. }. Probleme rezolvate cu stive si cozi. ptrcontainer->greutate=*wgreutate.struct tipdata *wdata. char continut[20]. nu este necesara memorarea adresei ultimului element din lista (care a fost asezat primul in stiva). struct tipstiva *varf.char *wcontinut. int an. 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. adica primul element din lista de containere (ultimul asezat in stiva). int greutate. Stiva containerelor se va implementa ca o lista simplu inlantuita. } /* descrierea functiei de extragere din stiva */ int pop(int *ptrcc. Ing. data ambalarii (zi. if(ptrcontainer==NULL) { printf("\n memorie insuficienta ptr memorarea unui container "). 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. identificata prin variabila varf care arata containerul vizibil din varful stivei.h> struct tipdata { int zi. continut un camp alfanumeri de 20 caractere. struct tipdata data.Ingineria Sistemelor de Programe (ISP). Se considera o stiva de containere cu caracteristicile:cod container un numar cuprins intre 1 si 99. ptrcontainer->data. int luna. luna si an) si greutatea in kg. data ambalarii si greutatea iar la incarcarea sa intr-un mijloc de transport pentru plecare se afisaza aceleasi informatii. strcpy(ptrcontainer->continut.wcontinut). prin intermediul parametrilor sai.h> #include<alloc.h> #include<conio. 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. ptrcontainer->data.an=wdata->an. struct tipstiva { int cc. #include<stdio. ptrcontainer=(struct tipstiva*)malloc(sizeof(struct tipstiva)).luna=wdata->luna. }. Intrucat toate operatiile asupra unei stive se fac pe la capatul de inceput al listei.int *ptrgreutate) { 9 .int *wgreutate) { struct tipstiva *ptrcontainer.zi=wdata->zi. } ptrcontainer->cc=*wcc. Sa se simuleze activitatile de stivuire si de incarcare intr-un mijloc de transport a containerelor din stiva. return 0.h> #include<string. /* descrierea functiei push() */ int push(int *wcc.

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

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

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

cod gestiune. case 'l': printf("\n se listeaza masinile care se gasesc la coada"). adaugare().80.90). Mihail Buricea case 'a': printf("\n soseste si se introduce o noua masina la coada"). stergere().40. Totodata trebuie sa pastram adresa ultimului articol generat. anterior rezolvata care sa permita exploatarea directa cat si inversa a listei (adica listarea produselor din lista). mc. Problema 3.1.data de creare sau data ultimei actualizari despachetata luata din sistemul de operare. proprietar.camp de tip numeric apartinand multimii gestiunilor (10. case 'e': printf("\n se alimenteaza si iese prima masina de la coada"). . 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 . Tema de casa nr 2.3.camp alfabetic din multimii (buc. sofer.20. break.60. case 't': printf("\n terminarea gestionarii cozii de masini"). Problema 3.cod articol .50. hl).70. break.999]. a celor care au suerit modificari. stergerea cat si modificarea datelor unui angajat) urmata de listarea la cerere a tuturor angajatilor. anterior rezolvata care sa permita listarea articolelor in ordinea inversa introducerii datelor.7. ml. listare().camp de tip real si se obtine prin inmultirea dintre valoarea campului cantitate si valoarea campului pret. luna si an) si greutatea in tone. 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. pornind de la informatiile introduse de la tastatura si efectuindu-se validarile corespunzatoare. ..6. . Problema 3.2. unitate de masura si pret) si sa se ordoneze crescator lista de produse dupa cod de produs. printr-o coada corespunzatoare si sa se afiseze lista tuturor tirurilor care au fost incarcate si au plecat. Ing. dupa denumire si dupa pret afisandu-se aceste liste si in ordine descrescatoare prin parcurgerea inversa a acestor liste. lista tirurilor care asteapta sa fie incarcate impreuna cu toate caracteristicile acestora (numar de inmatriculare. continut vagonului camp alfanumeri de 20 caractere. Problema 3. Problema 3.30. 4. Sa se creeze o lista dublu inlantuita de produse dintr-un nomenclator de produse cu structura: cod produs. cu urmatoarea structura a articolelor: . . l. dintr-un depozit de marfuri alimentare (sosirea si plecarea). mp. . 1=articol de intrare. data incarcarii (zi. tone.denumirea articolului .5. .2. repere) de organizare secventiala. Pornind de la fisierul anterior creeat sa se creeze o lista dublu inlantuita de articole in zona de memorie heap 13 .cantitatea – camp real cu 5 cifre partea intreaga si 3 cifre pentru zecimale. Problema 3. exit(0). . } } } 3.pret . prêt si valoare). 2=articol de iesire material din stoc. denumire. Probleme propuse pentru rezolvare. stergerea cat si modificarea datelor unui articol ca urmare a intrarilor si iesirilor de articole) urmata de listarea la cerere a tuturor articolelor. break.camp de tip numeric apartinind multimii [100.camp numeric de o cifra zecimala cu semnificatiile: 0=articol de stoc. Sa se creeze o lista liniara dublu inlantuita de produse cu structura de la problema 2.tip articol .camp alfanumeric de 20 caractere. Sa se creeze un fisier de articole (materiale. Sa se simuleze activitatile legate de incarcarea tirurilor de marfuri alimentare.2.camp de tip real pozitiv cu 7 cifre pentru partea intreaga si 2 cifre pentru partea fractionara. .Ingineria Sistemelor de Programe (ISP).2. 4. autor Sef de lucrari Dr. Problema 3. Se considera o linie de garare a 100 vagoane de marfa (stiva) cu caracteristicile:cod vagon un numar cuprins intre 100 si 999. Indicatie: Pentru rezolvarea problemei va trebui sa introducem in corpul fiecarui articol un camp in care sa se memoreze adresa articolului anterior.valoarea .1. a celor sterse si a celor noi adaugate in lista. kg.4. produse. 4. cu acelasi tip de aliment. 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. cantitatea transportata.unitate masura . Sa se creeze o lista liniara simplu si invers inlantuita de articole cu structura din problema 1.

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

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->