Gestiunea Unui Hotel

Gestiunea unui hotel----Tehnici de programare
Gestiunea unui hotel.

Acest document prezinta functiile programului GUH (gestiunea unui hotel), precum si detalii despre modul in care a fost creat acesta. Programul a fost creat pentru a ajuta utilizatorul sa poata memora toti clientii care vin si se cazeaza la un hotel, totodata sa aiba o perspectiva asupra camerelor hotelului. Pentru crearea sa s-au folosit fisiere, liste, arbori, metode de sortare si backtracking.
FISIER TEXT
Un stream este asociat unui fiier prin executarea unei operaii open i este eliberat de un fiier prin executarea unei operaii close. Exist dou tipuri de fisiere: text i binar. Un fisier text este folosit pentru a manipula caractere ASCII. Cnd folosim un fisier text, poate apare translatarea anumitor caractere. De exemplu cnd este ntlnit caracterul new line acesta este convertit ntr-o secven de doua caractere carriage_return / line feed. Este deci posibil s nu existe o coresponden total ntre ceea ce este trimis ctre stream i ceea ce conine fiierul. Un fisier se poate deschide cu functia FILE *fis=fopen(char nume.extensie,char mod); si se poate inchide cu functia fclose(fis); Exista mai multe moduri in care poate fi deschis un fisier. w-Deschide/Creaza un fisier text pentru scriere. r-Deschide un fisier text pentru citire. a-Append la un fisier text. r+-Deschide un fisier text pentru citire/scriere. w+-Deschide/Creaza un fisier text pentru citire/scriere a+-Append sau crearea unui fisier text pentru citire/scriere
STRUCTURA FISIER TEXT

Fisierul text are urmatoarele campuri: numele clientului, prenumele clientului, seria de buletin, camera in care acesta este cazat, data la care acesta s-a cazat si data la care acesta va pleca. In codul sursa structura fisierului este dupa cum urmeaza :

struct fisier_text { char nume[30],pren[30],sbul[15]; int camera; struct data_venire { int z,l,a; }dv; struct data_plecare { int z,l,a ; }dp; }ft;
In care : nume[30]->numele clientului pren[30]->prenumele clientului sbul[10]->seria de buletin a clientului camera-> camera la care este cazat Urmeaza 2 structuri aseamanatoare structura data_venire cu campurile z(ziua),l(luna),a(an), si structura data_plecare cu campurile z,l,a. Variabilele dv si dp, sunt variabilele cu care se ajunge la campurile structurilor data_venire respective data_plecare. Acelasi tip de functie are si variabila ft cu care se ajunge la campurile din structura fisier_text.
CREARE FISIER TEXT

Pentru crearea fisierului text s-a folosit functia cft(creare fisier text). Modul in care aceasta functie lucreaza este urmatorul: -se creaza un fisier clinenti de tip text (clienti.txt) -este intrebat utilizatorul daca doreste sa insereze date in fisier -in caz afirmativ se apeleaza functia aft(adaugare fisier text), cu ajutorul careia adauga o noua inregistrare in fisier -in caz negativ fisierul se inchide iar programul iese din functia cft Functia este de tip void si fara parametrii.
3
Codul sura este urmatorul:

void cft() { char r; FILE *cl; clrscr(); cl=fopen("clienti.txt","w"); printf("\nFisierul a fost creat!"); printf("\nDoriti sa adaugati noi inregistrari?(d/n)"); r=getch(); if(r=='d') aft(); fclose(cl); }
In care variabila cl retine adresa la care se va crea fisierul clienti.txt, iar variabila r retine optiunea utilizatorului.
ADAUGARE IN FISIER
Pentru adaugarea in fisier s-a folosit functia aft(adaugare fisier text). Modul de lucru al functiei este urmatorul: -deschide fisierul text si se pozitioneaza dupa ultima inregistrare din acesta -se verifica daca fisierul este creat, in caz afiramativ functia continua cu citirea datelor noii inregistrari -este creat si fisierul binar pentru a face modificarile (functia cfb() despre care o sa vorbim in urmatoarele pagini) -se scrie la finaul fisierului clienti.txt De asemenea se deschide fisierul camere.dat in care se cauta camera la care este cazat noul client, iar statusul acesteia se schimba din Liber in Ocupat La final utilizatorul este intebat daca doreste sa mai adauge alte inregistrari sau nu. In cazul in care doreste sa nu mai adauge alte inregistrari functia inchide fisierele, iar programul revine la meniul anterior.
4

Functia aft este de tipul void si nu are parametrii. Codul sursa este urmatorul:
void aft() { char r; int n=0,i=1; FILE *cl,*ca; cl=fopen("clienti.txt","r"); if(cl==0) { printf("Fisierul nu este creat!\npress any key..."); getch(); main1(); } fclose(cl); cfb(); cl=fopen("clienti.txt","a"); ca=fopen("camere.dat","rb+"); fseek(cl,0,SEEK_END); do { printf("\nNume:");scanf("%s",ft.nume); printf("\nPrenume:");scanf("%s",ft.pren); printf("\nSerie buletin:");scanf("%s",ft.sbul); printf("\nCamera:");scanf("%d",&ft.camera); printf("\nData venirii (ziua/luna/an):");scanf("%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); printf("\nData plecarii (ziua/luna/an):");scanf("%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); fprintf(cl,"%s %s %s %d %d/%d/%d %d/%d/%d\n",ft.nume,ft.pren,ft.sbul,ft.camera,ft.dv.z,ft.dv.l,ft.dv.a,ft.dp.z,ft.dp.l,ft.dp.a); fseek(ca,0,SEEK_SET); i=1; while(!feof(ca)&&(i<n)) { fread(&fb,sizeof(fb),1,ca); if(fb.camera==ft.camera) { strcpy(fb.stare,"Ocupat"); fseek(ca,ftell(ca)-sizeof(fb),SEEK_SET); fwrite(&fb,sizeof(fb),1,ca); } i++; } printf("\n\nDoriti sa mai adaugati noi inregistrari?(d/n)"); r=getch(); } while(r!='n'); fclose(ca); fclose(cl); }

Variabilele ca si cl sunt variabilele la care se gasesc fisierele camere.dat respectiv clienti.txt. Functiile de scriere in fisier folosite sunt: fprintf(stream,tip variabila,variabila); pentru fisier text fwrite(adresa_variabila,numar_octeti,numar_inregistrari,stream); pentru fisier binar. Functiile de citire din fisier folosite sunt: fscanf(stream,tip_variabila,adresa_variabila); pentru fisier text. fread(adresa_variabila,nr_octeti,numar_inregistrari,steram); pentru fisier binar. Alte funtii utilizate: fseek(stream,0,SEEK_SET); pentru pozitionare la inceputul fisierului, fseek(stream,0,SEEK_END); pentru pozitionare la sfarsitul fisierului, fseek(stream,0,SEEK_CUR); pentru pozitionare la cursorului curent.
STERGERE DIN FISIER

Sft(stergere fisier text) este functia cu ajutorul careia utilizatorul poate sterge o inregistrare din fisierul clienti.txt. Sunt folosite doua functii functia sft, care dupa cum spuneam sterge o intregistrare, si funtia mod_temp_list_bin care modifica fisierul camere.dat. In campul care arata statusul camere se schimba Ocupat cu Liber. Modul de lucru al acestei functii: -se deschide fisierul clienti.txt, si se creaza un alt fisier sterg.txt care ulterior va deveni noul clienti.txt.. -se citeste numele si prenumele clientului care va fi sters -se cauta in fisierul clienti.txt clientul, iar daca numele sau prenumele nu coincid se scriu in fisierul sterg.txt -cand este gasit se sare peste acea inregistrare, se memoreaza numarul camere, se apeleaza mod_temp_lista_bin, si se modifica in fisierul camere.dat statusul camerei din Ocupat in Liber. Functia sft este de tip void si fara parametrii. Functia mod_temp_list_bin este de tip void cu un singur parametru care retine numarul camerei. Codul sursa al functiilor:

void mod_temp_lista_bin(int n) { FILE *ca; int v=0,k=1; ca=fopen("camere.dat","rb+"); while(!feof(ca)) { fread(&fb,sizeof(fb),1,ca); v++; } fseek(ca,0,SEEK_SET); while((!feof(ca))&&(k<v)) { fread(&fb,sizeof(fb),1,ca); if(fb.camera==n) { strcpy(fb.stare,"Liber"); fseek(ca,ftell(ca)-sizeof(fb),SEEK_SET); fwrite(&fb,sizeof(fb),1,ca); } k++; } fclose(ca); } void sft() { FILE *cl,*f; int n,v,k; char s[30],p[30]; clrscr(); printf("\nDati numele clientului:"); scanf("%s",s); printf("\nDati prenumele clientului:"); scanf("%s",p); cl=fopen("clienti.txt","r"); n=0; while(!feof(cl)) { fscanf(cl,"%s %s %s %d %d/%d/%d %d/%d/%d",ft.nume,ft.pren,ft.sbul,&ft.camera,&ft.dv.z,&ft.dv.l,&ft.dv.a,&ft.dp.z,&ft.dp.l,&ft.dp.a); n++; } fseek(cl,0,SEEK_SET); f=fopen("sterg.txt","w"); v=0; k=0; while(v<n-1) { fscanf(cl,"%s %s %s %d %d/%d/%d %d/%d/%d",ft.nume,ft.pren,ft.sbul,&ft.camera,&ft.dv.z,&ft.dv.l,&ft.dv.a,&ft.dp.z,&ft.dp.l,&ft.dp.a); if(strcmp(ft.nume,s)!=0 || strcmp(ft.pren,p)!=0)

{ fprintf(f,"%s %s %s %d %d/%d/%d %d/%d/%d\n",ft.nume,ft.pren,ft.sbul,ft.camera,ft.dv.z,ft.dv.l,ft.dv.a,ft.dp.z,ft.dp.l,ft.dp.a); k++; } else mod_temp_lista_bin(ft.camera); v++; } if(k==n-1) printf("\n Nu exista nici un client %s %s!",s,p); else printf("\n Clientul %s %s a fost sters din fisier!",s,p); fclose(cl); fclose(f); remove("clienti.txt"); rename("sterg.txt","clienti.txt"); printf("\nPress any key..."); getch(); }
Noi functii care s-au folosit in stergere : remove(stream); sterge fisierul, rename(nume vechi,nume nou); redenumeste un fisier. Variabilele s si p s-au folosit pentru a memora numele respectiv prenumele.
MODIFICARE FISIER
Functia de modificare sau mft (modificare fisier text) lucreaza foarte simplu. Defapt este foarte asemanatoare cu functia de stergere. Modul de lucru: -se deschid 2 fisiere : clienti.txt si modi.txt -se citeste numele si prenumele clientului pe care utilizatorul doreste sa il modifice -ce citesc inregistrarile din fisierul clienti.txt,daca sunt diferite de cele cautate sunt scrise in fisierul modi.txt, cand se gasesc numele si prenumele cautate, inregistrarea este inlocuita cu alte date citite de la tastatura. -la final se sterge vechiul fisier, iar noul fisier se redenumese clienti.txt
void mft() { FILE *cl,*md; int n=0,i=1; char s[30],p[30]; printf("Dati numele clientului:"); scanf("%s",s);

printf("Dati prenumele clientului:"); scanf("%s",p); cl=fopen("clienti.txt","r"); md=fopen("modi.txt","w+"); while(!feof(cl)) { fscanf(cl,"%s %s %s %d %d/%d/%d %d/%d/%d",ft.nume,ft.pren,ft.sbul,&ft.camera,&ft.dv.z,&ft.dv.l,&ft.dv.a,&ft.dp.z,&ft.dp.l,&ft.dp.a); n++; } fseek(cl,0,SEEK_SET); while(!feof(cl) && i<n) { fscanf(cl,"%s %s %s %d %d/%d/%d %d/%d/%d",ft.nume,ft.pren,ft.sbul,&ft.camera,&ft.dv.z,&ft.dv.l,&ft.dv.a,&ft.dp.z,&ft.dp.l,&ft.dp.a); if(strcmp(ft.nume,s)!=0 && strcmp(ft.pren,p)!=0) fprintf(md,"%s %s %s %d %d/%d/%d %d/%d/%d\n",ft.nume,ft.pren,ft.sbul,ft.camera,ft.dv.z,ft.dv.l,ft.dv.a,ft.dp.z,ft.dp.l,ft.dp.a); if(strcmp(ft.nume,s)==0 && strcmp(ft.pren,p)==0) { printf("\nNume:");scanf("%s",ft.nume); printf("\nPrenume:");scanf("%s",ft.pren); printf("\nSerie buletin:");scanf("%s",ft.sbul); printf("\nCamera:");scanf("%d",&ft.camera); printf("\nData venirii (ziua/luna/an):");scanf("%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); printf("\nData plecarii (ziua/luna/an):");scanf("%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); fprintf(md,"%s %s %s %d %d/%d/%d %d/%d/%d\n",ft.nume,ft.pren,ft.sbul,ft.camera,ft.dv.z,ft.dv.l,ft.dv.a,ft.dp.z,ft.dp.l,ft.dp.a); } i++; } fclose(cl); fclose(md); remove("clienti.txt"); rename("modi.txt","clienti.txt");}
LISTARE FISIER
Listarea fisierului se face cu ajutorul functiei lft(listare fisier text). Modul de lucru este urmatorul : se citeste o inregistrare din fisier apoi se afiseaza pe ecran, sub forma de tabel, cu campurile NUME ,PRENUME, SERIE BULETIN, CAMERA, DATA VENIRII, DATA PLECARII. Codul sursa este urmatorul:
9

void lft() { int n,i=1,j; FILE *cl; cl=fopen("clienti.txt","r"); n=0; while(!feof(cl)) { fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); n++; } fseek(cl,0,SEEK_SET); for(j=0;j<80;j++) printf("="); printf("\nI I I I I I I"); printf("\nINUME IPRENUME ISERIE BULETIN ICAMERA IDATA VENIRE IDATA PLECARE I"); printf("\nI I I I I I I"); printf("\n"); for(j=0;j<80;j++) printf("="); while(!feof(cl)&&(i<n)) { fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); printf("\nI I I I I I I"); printf("\nI%9sI%9sI%14sI%7dI %2d/%2d/%4d I %2d/%2d/%4d I",ft.nume,ft.pren,ft.sbul,ft.camera,ft.dv.z,ft.dv.l,ft.dv.a,ft.dp.z,ft.dp.l,ft.dp.a); printf("\nI I I I I I I"); printf("\n"); for(j=0;j<80;j++) printf("-"); i++; } fclose(cl); getch(); }
10
FISIER BINAR
Un fisier binar este o secven de octei, iar corespondena ntre ceea ce este transmis ctre stream i ceea ce conine fiierul este total, nu apar translatri de caractere. Toate stream-urile au proprietari similare si sunt operate de aceleai funcii de intrare/iesire. Fiierul este entitatea fizica care primete datele. Modurile de deschidere ale unui fisier binar: -wb deschiderea unui fisier binar pentru scriere -rb deschiderea unui fisier binar pentru citire -ab append la un fisier binar -r+b deschiderea unui fisier pentru a fi citit/scris -w+b deschide/creaza un fisier binar pentru a fi citit/scris -a+b adauga/creaza un fisier binar pentru a fi citit/scris
STRUCTURA FISIER BINAR
Fisierul binar este camere.dat, si are urmatoarele campuri: camera,etaj, costul/noapte, tipul camerei, statusul camerei. Codul sursa este urmatorul:
11

struct fisier_binar { int camera,et,cost; char tc[20],stare[10]; }fb;
CREARE FISIER BINAR

Fisierul binar se creaza cu ajutorul functiei cfb(creare fisier binar), care are urmatorul mod de lucru: - in primul rand terbuie spus ca fisierul binar se construieste dupa anumite conditii: am presupus ca este un hotel cu 3 etaje la fiecare etaj aflandu-se cate 5 camere(exceptie etajul 1 care are 6 camere) camerele de la 100-105 se afla la etajul 1, toate sunt camere simple si toate costa 100 lei/noapte camerele de la 106-110 se afla la etajul 2, toate sunt camere duble si toate costa 200 lei/noapte camerele de la 111-115 se afla la etajul 3, toate sunt apartamente si toate costa 300 lei/noapte. nu exista functii de stergere sau adaugare a unei camere - functia este formata din 3 instructiuni for cu ajutorul carora sunt scrise in fisierul camere.dat inregistrarile cu conditiile explicate mai sus Functia este de tip void si nu are parametrii. Codul sursa pentru functie este:
12

void cfb() { int i; FILE *ca; ca=fopen("camere.dat","w+b"); for(i=100;i<=105;i++) { fb.camera=i; fb.et=1; fb.cost=100; strcpy(fb.tc,"Simpla"); strcpy(fb.stare,"Liber"); fwrite(&fb,sizeof(fb),1,ca); } for(i=106;i<=110;i++) { fb.camera=i; fb.et=2; fb.cost=200; strcpy(fb.tc,"Dubla"); strcpy(fb.stare,"Liber"); fwrite(&fb,sizeof(fb),1,ca); } for(i=111;i<=115;i++) { fb.camera=i; fb.et=3; fb.cost=300; strcpy(fb.tc,"Apartament"); strcpy(fb.stare,"Liber"); fwrite(&fb,sizeof(fb),1,ca); } fclose(ca); }
UPDATE FISIER BINAR

Update-ul fisierului binar consta in examinarea fisierului clienti.txt si schimbarea statusului in Ocupat in fisierul camere.dat a camerelor care se afla in fisierul clienti.txt.Modul de lucru: -se deschid ambele fisiere -se citeste o inregistrare din fisierul clienti.txt -se cauta acea inregistrare in fisierul camere.dat -se schimba statusul
13

-se repeta pana cand nu mai sunt inregistrari in clienti.txt -se inchid fisierele Codul sursa este urmatorul:
void update_fis_bin() { FILE *cl,*ca; int n=0,m=0,j=1,i; cl=fopen("clienti.txt","r") ; ca=fopen("camere.dat","rb+"); while(!feof(ca)) { fread(&fb,sizeof(fb),1,ca); n++; } while(!feof(cl)) { fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); m++; } fseek(cl,0,SEEK_SET); while((!feof(cl))&&(j<m)) { fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); i=1; fseek(ca,0,SEEK_SET); while((!feof(ca))&&(i<n)) { fread(&fb,sizeof(fb),1,ca); if(ft.camera==fb.camera) { strcpy(fb.stare,"Ocupat"); fseek(ca,ftell(ca)-sizeof(fb),SEEK_SET); fwrite(&fb,sizeof(fb),1,ca); fseek(ca,0,SEEK_SET); } i++; } j++; } fclose(ca);
14

fclose(cl); }
De mentionat: S-au mai folosti functii ca : feof(stream) functia care returneaza daca s-a ajuns la sfarsitul fisierului sau nu, ftell(stream) returneaza pozitia curenta a cursorului, sizeof(variabila) returneaza cati octeti are variabila, strcpy(sir1,sir2) copiaza in sir1 informatia din sir2, strcmp(sir1, sir2) returneaza 1 daca sir1>sir2, 0 daca sir1=sir2, -1 daca sir1<sir2. Functia este de tip void si nu are parametrii.
LISTARE FISIER BINAR
Listarea se face cu functa lfb(listare fisier binar), iar modul de lucru este foarte usor: -se citeste din fisierul camere.dat apoi se afiseaza sub forma de tabel informatiile. -campurile tabelului sunt : CAMERA, ETAJ, COST/NOAPTE, TIP CAMERA, STAUS
Codul sursa este urmatorul:

void lfb() { FILE *ca; int n=0,i=1,j; ca=fopen("camere.dat","r+b"); if(ca==0) { printf("Fisierul nu este creat!"); getch(); }else{ while(!feof(ca)) { fread(&fb,sizeof(fb),1,ca); n++; } fseek(ca,0,SEEK_SET);
15

printf("\t"); for(j=0;j<54;j++) printf("="); printf("\n\tI I I I I I"); printf("\n\tICAMERA IETAJ ICOST/NOAPTE ITIP CAMERA ISTATUS I"); printf("\n\tI I I I I I"); printf("\n\t"); for(j=0;j<54;j++) printf("="); while(!feof(ca)&&(i<n)) { fread(&fb,sizeof(fb),1,ca); printf("\n\tI %3d I %1d I %4d lei I%10s I%9s I ",fb.camera,fb.et,fb.cost,fb.tc,fb.stare); printf("\n\t"); for(j=0;j<=54;j++) printf("-"); i++; } fclose(ca); getch();} }
16
LISTE
O lista liniara este o colectie de n noduri cu x1,x2,....xn aflate intr-o relatie de ordine. Astfel, x1 este primul nod al listei, x2 al doilea nod al listei,...xn este ultimul nod. Listele liniare sunt de mai multe tipuri: - liste simplu inaltuite (lista se poate parcurge doar dintr-o parte in cealalta) - liste dublu inlantuite(lista se poate parcurde si de la stanga la dreapta dar si de la dreapta la stanga) - liste simplu inlantuite circulare (lista se parcure intr-o singura directie dar nu se opreste la ultimul nod, ci continua parcurgerea), ultimul nod are succesor pe primul nod - liste dublu inlantuite cirulare(lista se parcurge de la stanga la dreapta si invers dar nu se opreste la ultimul sau primul nod), ultimul nod are succesor la dreapta primul nod , iar primul nod are succesor la stanga ultimul nod Operatiile permise sunt: - accesul la oricare nod al liste in scopul citirii sau modificarii informatiei continute de acesta - adaugarea unui nod, indiferet de pozitia pe care o ocupa in lista - stergerea unui nod, indiferent de pozitia pe care o ocupa in lista - schimbarea pozitiei unui nod in cadrul listei.
17
CREARE LISTA
Crearea listei se face cu ajutorul functiei crl(creare lista), modul de lucru al functiei este urmatorul: -citeste o inregistrare din fisierul clienti.txt -verifica daca lista a fost creata, in caz negativ creaza primul nod al listei -apoi continua cu adaugarea unui nou nod la dreapta pana cand se termina toate inregistrarile din fisierul clienti.txt -functia face legaturile intre noduri in felul urmator primul nod are la stanga adresa NULL la dreapta adresa urmatorului nod, un nod diferit de primul si de ultimul nod are la stanga adresa nodului pozitionat la stanga, iar la dreapta adresa nodului pozitionat la dreapta.Ultimul nod are la stanga adresa nodului pozitionat la stanga iar la dreapta are adresa NULL.
Un nod are urmatoarea structura:

struct nod_lista { fisier_text ftt; nod_lista *st,*dr; }*prim,*ultim;
In care variabila ftt este te tip fisier_text , iar campurile se pot observa la subcapitolul STRUCTURA FISIER TEXT , variabilele *st, *dr sunt variabilele la care se memoreaza adresa de la stanga respectiv la dreapta a unui nod. Variabilele *prim si *ultim sunt variabilele care memoreaza primul si ultimul nod.
18

Codul sursa al functiei este:
void crl() { FILE *cl; nod_lista *c,*d; int n=0,i=1; cl=fopen("clienti.txt","r"); if(cl!=0){ while(!feof(cl)) { fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); n++; } fseek(cl,0,SEEK_SET); while(!feof(cl) && i<n) { fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); if(prim==0) { prim=new nod_lista; prim->st=0; prim->dr=0; strcpy(prim->ftt.nume,ft.nume); strcpy(prim->ftt.pren,ft.pren); strcpy(prim->ftt.sbul,ft.sbul); prim->ftt.camera=ft.camera; prim->ftt.dv.z=ft.dv.z;prim->ftt.dv.l=ft.dv.l;prim->ftt.dv.a=ft.dv.a; prim->ftt.dp.z=ft.dp.z;prim->ftt.dp.l=ft.dp.l;prim->ftt.dp.a=ft.dp.a; ultim=prim; } else { d=new nod_lista; d->st=ultim; d->dr=0; strcpy(d->ftt.nume,ft.nume); strcpy(d->ftt.pren,ft.pren); strcpy(d->ftt.sbul,ft.sbul); d->ftt.camera=ft.camera; d->ftt.dv.z=ft.dv.z;d->ftt.dv.l=ft.dv.l;d->ftt.dv.a=ft.dv.a; d->ftt.dp.z=ft.dp.z;d->ftt.dp.l=ft.dp.l;d->ftt.dp.a=ft.dp.a;
19

ultim->dr=d; ultim=d; } i++; } fclose(cl); printf("\nLista a fost creata!"); getch(); } else { printf("Fisierul nu a fost creat!"); getch(); } }
AFISAREA LISTEI
Afisarea listei se poate face in doua moduri : de la stanga la dreapta , apoi de la dreapta la stanga. Pentru primul mod de parcurgere folosim functia listl, in care unei variabile c i se atribuie adresa primului nod, apoi afiseaza informatia si contiuna procesul pana la intalnirea adresei NULL. Informatia se afiseaza sub forma de tabel, cu urmatoarele campuri: NUME , PRENUME, SERIE BULETIN, CAMERA, DATA VENIRII, DATA PLECARII. Codul sursa pentru aceasta functie este:
void listl() { nod_lista *c; int j; c=prim; if(prim==0) { clrscr(); printf("\nLista trebuie mai intai creata."); getch(); }else{ printf("\n"); for(j=0;j<80;j++) printf("="); printf("\nI I I I I I I"); printf("\nI Nume I Prenume I Serie Buletin I Camera I Data venire I Data plecare I"); printf("\nI I I I I I I");
20

printf("\n"); for(j=0;j<80;j++) printf("="); while(c!=0) { printf("\nI%9sI%9sI%14s I%6d I %2d/%2d/%4d I %2d/%2d/%4d I",c->ftt.nume,c->ftt.pren,c->ftt.sbul,c>ftt.camera,c->ftt.dv.z,c->ftt.dv.l,c->ftt.dv.a,c->ftt.dp.z,c->ftt.dp.l,c->ftt.dp.a); printf("\n"); for(j=0;j<80;j++) printf("-"); c=c->dr; } getch();} }
Al doilea mod de parcurgere al listei este de la dreapta la stanga. Parcurgerea se face cu ajutorul functiei listld(listare lista dreapta). Modul de lucru este asemanator cu cel de la functia precedenta. Intr-o variabila c se memoreaza de aceasta data adresa ultimului nod , apoi se afiseaza informatia sub forma de tabel cu aceleasi campuri ca cel anterior, si procesul se intampla pana cand c intalneste adresa NULL. Codul sursa este :
void listld() { nod_lista *c; int j; c=ultim; if(ultim==0) { clrscr(); printf("\nLista trebuie mai intai creata."); getch(); } else{ printf("\n"); for(j=0;j<80;j++) printf("="); printf("\nI I I I I I I"); printf("\nI Nume I Prenume I Serie Buletin I Camera I Data venire I Data plecare I"); printf("\nI I I I I I I"); printf("\n"); for(j=0;j<80;j++) printf("="); while(c!=0) { printf("\nI%9sI%9sI%14s I%6d I %2d/%2d/%4d I %2d/%2d/%4d I",c->ftt.nume,c->ftt.pren,c->ftt.sbul,c>ftt.camera,c->ftt.dv.z,c->ftt.dv.l,c->ftt.dv.a,c->ftt.dp.z,c->ftt.dp.l,c->ftt.dp.a); printf("\n");
21

for(j=0;j<80;j++) printf("-"); c=c->st; } getch();} }
MODIFICARE LISTA
Modificarea listei se face cu ajutorul functiei mdl(modificare lista) si are urmatorul mod de lucru: -in 2 variabile de tip char se memoreaza numele si prenumele clientului pe care doreste ultilizatorul sa-l modifice -o variabila c primeste adresa primului nod apoi parcurgand lista de la stanga la dreapta cauta nodul cu numele si prenumele cautat -informatiile apoi sunt inlocuite cu altele primite de la tastatura -utilizatorul este intrebat daca doreste sa faca modificarile si in fisier. Modificarile in fisier se fac cu ajutorul functiei modi_fist_list(modificare fisier text lista) care are urmatorul mod de lucru: -creaza un alt fisier in care introduce informatiile nodurilor -apoi il sterge pe vechiul clienti.txt si modifica numele noului fisier in clienti.txt Codurile sursa sunt:
void mdl() { nod_lista *c; char n[30],p[30],s; int ok=0; if(prim==0) crl(); c=prim; printf("\nDati numele si prenumele clientului caruia doriti sa-i modificati datele."); printf("\nNume:");scanf("%s",n); printf("\nPrenume:");scanf("%s",p); while(c!=0)
22

{ if(strcmp(n,c->ftt.nume)==0 && strcmp(p,c->ftt.pren)==0) { printf("\nNume:");scanf("%s",c->ftt.nume); printf("\nPrenume:");scanf("%s",c->ftt.pren); printf("\nSerie Buletin:");scanf("%s",c->ftt.sbul); printf("\nCamera:");scanf("%d",&c->ftt.camera); printf("\nData venirii:");scanf("%d/%d/%d",&c->ftt.dv.z,&c->ftt.dv.l,&c->ftt.dv.a); printf("\nData plecarii:");scanf("%d/%d/%d",&c->ftt.dp.z,&c->ftt.dp.l,&c->ftt.dp.a); ok=1; } c=c->dr; } if(!ok) { printf("\nClientul nu exista!"); } else { printf("\nLista a fost modificata!"); } printf("Doriti sa faceti aceasta modificare si in fisierul text?(d/n)"); s=getch(); if(s=='d') modi_fist_list(); getch(); } void modi_fist_list() { FILE *md; nod_lista *c; md=fopen("modi.txt","w+"); c=prim; while(c!=0) { fprintf(md,"%s %s %s %d %d/%d/%d %d/%d/%d\n",c->ftt.nume,c->ftt.pren,c->ftt.sbul,c->ftt.camera,c>ftt.dv.z,c->ftt.dv.l,c->ftt.dv.a,c->ftt.dp.z,c->ftt.dp.l,c->ftt.dp.a); c=c->dr; } fclose(md); remove("clienti.txt"); rename("modi.txt","clienti.txt"); printf("\n"); lft(); }
23
ARANJARE LISTA
Lista poate fi aranjata crescator sau descrescator dupa numele si prenumele clientilor. Programul GUH face aceasta aranjare cu ajutorul functiei aranjare_lista. Metoda de sortare folosita este metoda interchimbarii directe. Practic functia ia fiecare nod in parte il compara cu celalalt nod si. daca sunt indeplinite conditiile dorite de utilizator, atunci ele se interschimba. Codul sursa este urmatorul :
void aranjare_lista() { char s; nod_lista *c,*d,*man; do { clrscr(); printf("\n1-Crescator dupa nume si prenume."); printf("\n2-Descrescator dupa nume si prenume."); printf("\n0-Iesire."); s=getch(); switch(s) { case '1': { c=prim; while(c->dr!=ultim) { d=c->dr; while(d!=0) { if(strcmp(c->ftt.nume,d->ftt.nume)>0) { man->ftt=c->ftt; c->ftt=d->ftt; d->ftt=man->ftt; } if(strcmp(c->ftt.nume,d->ftt.nume)==0) if(strcmp(c->ftt.pren,d->ftt.pren)>0) { man->ftt=c->ftt; c->ftt=d->ftt; d->ftt=man->ftt; }
24

d=d->dr; } c=c->dr; } printf("\nLista aranjata crescator dupa numele si prenumele clientilor:\n"); listl(); break; } case '2' : { c=prim; while(c->dr!=0) { d=c->dr; while(d!=0) { if(strcmp(c->ftt.nume,d->ftt.nume)==0) if(strcmp(c->ftt.pren,d->ftt.pren)<0) { man->ftt=c->ftt; c->ftt=d->ftt; d->ftt=man->ftt; } if(strcmp(c->ftt.nume,d->ftt.nume)<0) { man->ftt=c->ftt; c->ftt=d->ftt; d->ftt=man->ftt; } d=d->dr; } c=c->dr; } printf("\nLista aranjata descrescator dupa numele si prenumele clientilor:\n"); listl(); break; } } } while(s!='0'); printf("\nDoriti sa faciti schimbarile si in fisier?(d/n)"); s=getch(); if(s=='d') { modi_fist_list(); printf("\n"); lft(); } }
25

In cazul in care utilizatorul doreste sa faca aceste modificari si in fisier, poate fi apelata functia modi_fist_list();.
ADAUGARE IN LISTA
Functia adaugare_list() este cea care indeplineste acest rol. Ea are 4 componente: - Adaugarea la inceputul listei - Adaugarea inaintea unui nod - Adaugarea dupa un nod - Adaugarea la finalul listei Codul sursa :
void adaugare_list() { char a,n[20],p[20]; nod_lista *c,*d; do { clrscr(); printf("\n1-Adaugare la inceput."); printf("\n2-Adauga inainte de un nod."); printf("\n3-Adaugare dupa un nod."); printf("\n4-Adaugare la final."); printf("\n0-Iesire."); a=getch(); switch(a) { case'1': { c=new nod_lista; printf("\nDati datele clientului:"); printf("\nNume:");scanf("%s",c->ftt.nume); printf("\nPrenume:");scanf("%s",c->ftt.pren); printf("\nSerie buletin:");scanf("%s",c->ftt.sbul); printf("\nCamera:");scanf("%d",&c->ftt.camera); printf("\nData venirii:");scanf("%d/%d/%d",&c->ftt.dv.z,&c->ftt.dv.l,&c->ftt.dv.a); printf("\nData plecarii:");scanf("%d/%d/%d",&c->ftt.dp.z,&c->ftt.dp.l,&c->ftt.dp.a); c->dr=prim; prim->st=c; c->st=0; prim=c; break; } case '2': {
26

c=new nod_lista; printf("\nNumele si prenumele clientului inaintea caruia doriti sa insearati noul nod:"); printf("\nNume:");scanf("%s",n); printf("\nPrenume:");scanf("%s",p); d=prim; while(strcmp(d->ftt.nume,n)!=0 && strcmp(d->ftt.pren,p)!=0) d=d->dr; printf("\nDatele noului nod:"); printf("\nNume:");scanf("%s",c->ftt.nume); printf("\nPrenume:");scanf("%s",c->ftt.pren); printf("\nSerie Buletin:");scanf("%s",c->ftt.sbul); printf("\nCamera:");scanf("%d",&c->ftt.camera); printf("\nData venirii:");scanf("%d/%d/%d",&c->ftt.dv.z,&c->ftt.dv.l,&c->ftt.dv.a); printf("\nData plecarii:");scanf("%d/%d/%d",&c->ftt.dp.z,&c->ftt.dp.l,&c->ftt.dp.a); c->dr=d; c->st=d->st; d->st->dr=c; d->st=c; break; } case '3': { c=new nod_lista; printf("\nNumele si prenumele clientului dupa care doriti sa insearati noul nod:"); printf("\nNume:");scanf("%s",n); printf("\nPrenume:");scanf("%s",p); d=prim; while(strcmp(d->ftt.nume,n)!=0 && strcmp(d->ftt.pren,p)!=0) d=d->dr; printf("\nDatele noului nod:"); printf("\nNume:");scanf("%s",c->ftt.nume); printf("\nPrenume:");scanf("%s",c->ftt.pren); printf("\nSerie Buletin:");scanf("%s",c->ftt.sbul); printf("\nCamera:");scanf("%d",&c->ftt.camera); printf("\nData venirii:");scanf("%d/%d/%d",&c->ftt.dv.z,&c->ftt.dv.l,&c->ftt.dv.a); printf("\nData plecarii:");scanf("%d/%d/%d",&c->ftt.dp.z,&c->ftt.dp.l,&c->ftt.dp.a); c->st=d; c->dr=d->dr; d->dr=c; d->dr->st=c; break; } case '4': { c=new nod_lista; printf("\nDati datele clientului:"); printf("\nNume:");scanf("%s",c->ftt.nume); printf("\nPrenume:");scanf("%s",c->ftt.pren); printf("\nSerie buletin:");scanf("%s",c->ftt.sbul); printf("\nCamera:");scanf("%d",&c->ftt.camera); printf("\nData venirii:");scanf("%d/%d/%d",&c->ftt.dv.z,&c->ftt.dv.l,&c->ftt.dv.a); printf("\nData plecarii:");scanf("%d/%d/%d",&c->ftt.dp.z,&c->ftt.dp.l,&c->ftt.dp.a);
27

c->st=ultim; c->dr=0; ultim->dr=c; ultim=c; break; } } } while(a!='0'); printf("\nNoua lista:\n"); listl(); printf("\nDoriti sa modificati si in fisier?(d/n)"); a=getch(); if(a=='d') { clrscr(); modi_fist_list(); } }
STERGERE LISTA
Stergea unui nod din lista se face cu ajutorul functiei sterg_list. Aceasta are un mod de lucru foarte simplu: prin variabilele n si p,se memoreaza numele si prenumele clinetului care va fi sters, apoi este cautat cu ajutorul variabilei c. Cand este gasit acestuia ii se rup legaturile cu nodurile vecine, se fac leaga nodurile vecine iar apoi se sterge memoria alocata acestui nod. Codul sursa:
void sterg_list() { nod_lista *c; char p[10],n[10],s; c=prim; printf("\nDati numele si prenumele clientului pe care il doriti sters:"); printf("\nNume:");scanf("%s",n); printf("\nPrenume:");scanf("%s",p); while(strcmp(p,c->ftt.pren)!=0 && strcmp(n,c->ftt.nume)!=0) c=c->dr; c->st->dr=c->dr; c->dr->st=c->st;
28

delete c; listl(); printf("\Doriti sa modificati si in fisier?(d/n)"); s=getch(); if(s=='d') { clrscr(); modi_fist_list(); } }
ARBORI
Structurile arborescente sunt foarte des utilizate atat pe parcursul stocarii informatiei in memoria calculatorului cat si pe parcursul regasirii si prelucrarii acestei informatii. Ca atare, apare ca necesara detalierea modului in care sunt folosite aceste structuri de date. Un arbore este un graf orientat fara cicluri, format dintr-o multime de noduri, N, si o multime de arce R, notat A=(N,R) cu urmatoarele proprietati: 1) exista un singur nod rad din multimea nodurilor, numit radacina, pentru care i-gradul (numarul de arce ce intra in nod) este zero; 2) toate celelalte noduri au i-gradul 1; 3) orice nod este accesibil din radacina.
29
CREARE ARBORE
Inainte de a vorbi despre modul in care acest program creaza arborii, trebuie sa vorbim despre modul in care un arbore este structurat. Acesta are urmatoarea structura :
struct arb { fisier_text ftt; arb *st,*dr; }; arb *rad;
Variabila ftt este de tip fisier_text a fost explicata la Creare lista arb sunt variabile te tip arb(arbore) care memoreaza adresa fiilor unui nod al arborelui. St memoreaza adresa fiului stang, dr memoreaza adresa fiului drept. Crearea aborelui poate fi facuta in 2 moduri: direct din fisierul clienti.txt sau de la tastatura. Modul de lucru: -se creaza nodul radacina,memorat prin rad, acesta ia valoarea camerei primei inregistrari. -se trece la urmatoarea inregistrare, daca aceasta are numarul camerei mai mare ca radacina atunci acest nod devine fiul drept, daca este mai mic atunci el devine fiul stang. -in cazul in care radacina este deja creata atunci locul radacinii este luat de variabila p si se continua algoritmul anterior. Codul sursa:
void creare_arb() { FILE *cl; arb *p,*q; cl=fopen("clienti.txt","r"); fseek(cl,0,SEEK_SET); while(!feof(cl)) {
30

fscanf(cl,"%s",ft.nume); fscanf(cl,"%s",ft.pren); fscanf(cl,"%s",ft.sbul); fscanf(cl,"%d",&ft.camera); fscanf(cl,"%d/%d/%d",&ft.dv.z,&ft.dv.l,&ft.dv.a); fscanf(cl,"%d/%d/%d",&ft.dp.z,&ft.dp.l,&ft.dp.a); if(rad==0) { rad=new arb; strcpy(rad->ftt.nume,ft.nume); strcpy(rad->ftt.pren,ft.pren); strcpy(rad->ftt.sbul,ft.sbul); rad->ftt.camera=ft.camera; rad->ftt.dv=ft.dv; rad->ftt.dp=ft.dp; rad->st=0; rad->dr=0; p=rad; } if(rad!=0) { if(ft.camera<p->ftt.camera && p->st!=0) p=p->st; if(ft.camera<p->ftt.camera && p->st==0) { q=new arb; strcpy(q->ftt.nume,ft.nume); strcpy(q->ftt.pren,ft.pren); strcpy(q->ftt.sbul,ft.sbul); q->ftt.camera=ft.camera; q->ftt.dv=ft.dv; q->ftt.dp=ft.dp; p->st=q; q->st=0; q->dr=0; } if(ft.camera>p->ftt.camera && p->dr!=0) p=p->dr; if(ft.camera>p->ftt.camera && p->dr==0) { q=new arb; strcpy(q->ftt.nume,ft.nume); strcpy(q->ftt.pren,ft.pren); strcpy(q->ftt.sbul,ft.sbul); q->ftt.camera=ft.camera; q->ftt.dv=ft.dv; q->ftt.dp=ft.dp; p->dr=q; q->st=0; q->dr=0; } }
31

} fclose(cl); printf("\nArborele a fost creat din fisierul Clienti.txt!"); getch(); } void creare_arb_tast() { char alege; if(rad==0) { rad=new arb; printf("Numele:");scanf("%s",rad->ftt.nume); printf("Prenumele:");scanf("%s",rad->ftt.pren); printf("Seria buletinului:");scanf("%s",rad->ftt.sbul); printf("Camera:");scanf("%d",&rad->ftt.camera); printf("Data venirii:");scanf("%d/%d/%d",&rad->ftt.dv.z,&rad->ftt.dv.l,&rad->ftt.dv.a); printf("Data plecarii:");scanf("%d/%d/%d",&rad->ftt.dp.z,&rad->ftt.dp.l,&rad->ftt.dp.a); rad->st=0; rad->dr=0; } printf("\nDoriti sa adaugati alte noduri?(d/n)") ; alege=getch(); if(alege=='d') adaugare_arb(); }
Acelasi algoritm este si la crearea prin tastatura, doar ca inregistrarile le da direct utilizatorul.
ADAUGARE IN ARBORE
Adaugarea se face dupa cum urmeaza: se insereaza un nou nod, informatia este comparata cu radacina, daca este mai mic atunci se trece la nodul din partea stanga si se face iar comparatie, daca este mai mare atunci se trece la nodul din partea dreapta si se face iar comparatie. Acest proces se intampla pana cand se gaseste un loc vid, sau adresa NULL, unde se insereaza noul nod. Pentru aceasta este utilizata functia adaugare_arb. Codul sursa este pe urmatoarea pagina:
32

void adaugare_arb() { char alege; arb *p,*q; do { p=rad; q=new arb; printf("\nNumele:");scanf("%s",q->ftt.nume); printf("\nPrenumele:");scanf("%s",q->ftt.pren); printf("\nSeria buletinului:");scanf("%s",q->ftt.sbul); printf("\nCamera:");scanf("%d",&q->ftt.camera); printf("\nData venirii:");scanf("%d/%d/%d",&q->ftt.dv.z,&q->ftt.dv.l,&q->ftt.dv.a); printf("\nData plecarii:");scanf("%d/%d/%d",&q->ftt.dp.z,&q->ftt.dp.l,&q->ftt.dp.a); q->st=0; q->dr=0; while(p->ftt.camera!=q->ftt.camera) { if(q->ftt.camera<p->ftt.camera && p->st!=0) p=p->st; if(q->ftt.camera<p->ftt.camera && p->st==0) p->st=q; if(q->ftt.camera>p->ftt.camera &&p->dr!=0) p=p->dr; if(q->ftt.camera>p->ftt.camera &&p->dr==0) p->dr=q; } printf("\nDoriti sa mai insearati alte noduri?(d/n)"); alege=getch(); } while(alege!='n'); printf("\nDoriti sa continuati arborele cu datele din fisierul Clienti.txt?(d/n)"); alege=getch(); if(alege=='d') creare_arb(); }
De mentionat: Operatorii new si delete sunt operatori gasiti in limbajul c++, acesti doi operatori creaza respectiv sterg un spatiu de memorie alocat. Sunt foarte folositi in lucrul cu liste si arbori.
33
CAUTAREA IN ARBORE
Cautarea unui nod in arbore are acelasi principiu ca adaugarea in arbore. Un nod este introdus de la tastatura, se compara cu radacina daca este mai mic atunci se continua comparatia in partea stanga, daca este mai mare se continua comparatia in partea dreapta. Ajungand la nodul cautat acesta este afiasat impreuna cu datele pe care le detine. Rolul acesta este indeplinit de functia cautare() care are urmatorul cod sursa:
void cautare() { arb *p; int cheie; if(rad==0) creare_arb(); p=rad; clrscr(); printf("Dati camera:");scanf("%d",&cheie); while(p!=0 && cheie!=p->ftt.camera) { if(cheie>p->ftt.camera) p=p->dr; if(cheie<p->ftt.camera) p=p->st; } if(p==0) printf("Nu exista nici nu locatar la camera :%d",cheie); else { printf("In camera %d se afla:",cheie); printf("\nClientul %s %s cu seria de buletin:%s \nvenit la data de: %d/%d/%d pana la data de:%d/%d/%d",p->ftt.nume,p->ftt.pren,p->ftt.sbul,p->ftt.dv.z,p->ftt.dv.l,p->ftt.dv.a,p->ftt.dp.z,p->ftt.dp.l,p>ftt.dp.a); } getch(); }
34
AFISARE ARBORE
Exista 4 moduri de afisarea a unui arbore : - Inordine (subarbore stang,radacina,subarbore drept) - Postordine(subarbore stang, subarbore drept, radacina) - Preordine(radacina,subarbore stang,subarbore drept) - Afisare in forma arborescenta. Pentru afisare sunt folosite functiile inordine(), postordine(), preordine(), afiare_arbore_nivel();. Codul sursa este urmatorul:
void inordine(arb *m) { if(m!=0) { inordine(m->st); printf("%d ",m->ftt.camera); inordine(m->dr); } } void postordine(arb *m) { if(m!=0) { postordine(m->st); postordine(m->dr); printf("%d ",m->ftt.camera); } } void preordine(arb *m) { if(m!=0) { printf("%d ",m->ftt.camera); preordine(m->st); preordine(m->dr); } } void afisare_arbore_nivel(arb *m, int t) { int i; if(m!=NULL) { afisare_arbore_nivel(m->dr,t+5); for (i=0;i<t;i++) printf(" ");
35

if (m->ftt.camera>0) printf("%d\n", m->ftt.camera); for (i=0;i<t;i++) printf(" "); printf("\n"); afisare_arbore_nivel(m->st,t+5); } }
PERMUTARI
Metoda backtraking se foloseste in rezolvarea problemelor care indeplinesc simultan urmatoarele conditii: - solutia lor poate fi pusa sub forma unui vetor S=x1,x2...xn cu x1 din A1 , x2 din A2 ....xn din An - multimile A1, A2...An sunt multimi finite, iar elementele lor se considera ca se afla intr-o relatie de ordine bine stabilita - nu se dispune de o alta metoda de rezolvare, mai rapida. Principiul metodei Metoda backtracking are la baza un principiu simplu: daca in procesul de generare a unui vector solutie S=x1,x2,...,xn pentru componenta k, atunci cand am generat deja x1,x2,...,xk constatam ca valoarea xk nu este bine aleasa( pastrand-o nu se la ajunge la o solutie), nu trecem la componeta k+1 ci reluam cautarea pentr alta valoare pentru componenta k, iar daca asceasta valoare nu exista, reluam cautarea pentru componenta k-1. Programul genereaza toate permutarile posibile ale camerelor ocupate din fisierul camere.dat. Numarul camerelor ocupate se memoreaza in vectorul vex.x*30+. Structura pentru backtracking este urmatoarea:
36

struct back { int x[30],n; }vex;
X memoreaza vectorul cu camerele, n numarul de componente din camere. In program s-a folosit metoda iterativa. Codul sursa este urmatorul:
void creare_vex() { FILE *ca; int k=0,i=1,man=0; ca=fopen("camere.dat","rb"); while(!feof(ca)) { fread(&fb,sizeof(fb),1,ca); man++; } fseek(ca,0,SEEK_SET); while(!feof(ca)&&i<man) { fread(&fb,sizeof(fb),1,ca); if(strcmp(fb.stare,"Ocupat")==0) vex.x[++k]=fb.camera; i++; } vex.n=k; printf("\n\n"); fclose(ca); } void init(int k) { sol[k]=0; } int succesor(int k) { if(sol[k]<vex.n) { sol[k]++; return 1; } else return 0; } int valid(int k) { int i,ev=1; for(i=1;i<k;i++) if(sol[k]==sol[i]) ev=0;
37

return ev; } int solutie(int k) { return k==vex.n; } void tipar() { int i; for(i=1;i<=vex.n;i++) printf("%d ",vex.x[sol[i]]); printf("\n"); } void back() { int k,as=0; char ch; k=1; init(k); while(k>0) { do { as=succesor(k); } while(as && valid(k)!=1); if(as) { if(solutie(k)) { tipar(); printf("Doriti afisarea altei permutari?(d/n)\n"); ch=getch(); if(ch=='n') k=0; } else { k++; init(k); } } else k--; } }
De mentionat: functia creare_vex creaza vectorul vex.x[30] si numara cate componete are.
38
MENIURI
In void main() exista 4 apelari ale unor functii. Aceste 4 apelari sunt : 1. Meniu fisiere. 2. Meniu liste. 3. Meniu arbori. 4. Permutari. La randul lor fiecare are mai multe optiuni pe care utilizatorul pe poate vedea cand ruleaza programul. Codul sursa al acestora este urmatorul:
void main4() { clrscr(); printf("\nAcest meniu afiseaza toate permutarile camerelor ocupate posibile din fisierul camere.dat"); creare_vex(); back(); getch(); } void main3() { char alege,al; do { clrscr(); printf("\n1-Creare arbore."); printf("\n2-Afisare."); printf("\n3-Cautare."); printf("\n4-Creare din tastatura."); printf("\n5-Adaugare."); printf("\n0-Iesire."); alege=getch(); switch(alege) { case '1': { creare_arb(); break; } case '2': { do { clrscr(); printf("\n1-Afisare pe nivel.");
39

printf("\n2-Inordine."); printf("\n3-Postordine."); printf("\n4-Preordine."); printf("\n0-Iesire."); al=getch(); switch(al) { case '1': { clrscr(); if(rad==0) { printf("Arborele nu este creat!"); break; } printf("\n"); afisare_arbore_nivel(rad,0); getch(); break; } case '2': { clrscr(); if(rad==0) { printf("Arborele nu este creat!"); break; } printf("Arborele afisa in inordine este:\n"); inordine(rad); getch(); break; } case '3': { clrscr(); if(rad==0) { printf("Arborele nu este creat!"); break; } printf("Arborele afisat in postordine este:\n"); postordine(rad); getch(); break; } case '4': { clrscr(); if(rad==0) {
40

printf("Arborele nu este creat!"); break; } printf("Arborele afisat in preordine este:\n"); preordine(rad); getch(); break; } } } while(al!='0'); break; } case '3': { cautare(); break; } case '4': { clrscr(); creare_arb_tast(); break; } case '5': { clrscr(); if(rad==0) creare_arb_tast(); adaugare_arb(); break; } } } while(alege!='0'); } void main2() { char alege,al; do { clrscr(); printf("\n1-Creare lista din fisier."); printf("\n2-Afisare."); printf("\n3-Modificare."); printf("\n4-Adaugare in lista."); printf("\n5-Stergere din lista."); printf("\n0-Iesire."); alege=getch(); switch(alege) {
41

case '1': { crl();break; } case '2': { do { clrscr(); printf("\n1-Afisare stanga-dreapta."); printf("\n2-Afisare dreapta-stanga."); printf("\n0-Iesire."); al=getch(); switch(al) { case '1': { listl();break; } case '2': { listld();break; } } } while(al!='0'); break; } case '3': { do { clrscr(); printf("\n1-Modificare alfabetica."); printf("\n2-Modificare clienti."); printf("\n0-Iesire."); al=getch(); switch(al) { case '1': { aranjare_lista(); break; } case '2': { mdl();break; } } } while(al!='0'); break;
42

} case '4': { clrscr(); adaugare_list(); break; } case '5': { clrscr(); sterg_list(); break; } } } while(alege!='0'); } void main1() { char alege,al; do { clrscr(); printf("\n1-Creare Fisier Text."); printf("\n2-Adaugare in Fisier Text."); printf("\n3-Stergere din Fisier Text."); printf("\n4-Modificare Fisier Text."); printf("\n5-Listare Fisier Text."); printf("\n6-Creare/Refresh Fisier Binar."); printf("\n7-Listare/Update Fisier Binar."); printf("\n0-Iesire!"); alege=getch(); switch (alege) { case '1': { clrscr(); cft();break; } case '2': { clrscr(); aft();break; } case '3': { clrscr(); sft();break; } case '4': { clrscr();
43

mft();break; } case '5': { clrscr(); lft();break; } case '6': { clrscr(); cfb(); clrscr(); printf("\nFisierul binar a fost creat."); getch(); break; } case '7': { clrscr(); printf("\n1-Update."); printf("\n2-Listare."); al=getch(); switch(al) { case '1': { update_fis_bin(); printf("\nFisierul Binar a fost updatat.\n"); lfb(); main1(); break; } case '2': { clrscr(); lfb(); main1(); break; } } break; } } } while(alege!='0'); } void main() { float h; char meniu; textbackground(BLACK); textcolor(WHITE);
44

clrscr(); printf("Inserati un numar pentru a intra in program!"); scanf("%f",&h); do { clrscr(); printf("\n1-Meniu fisiere."); printf("\n2-Meniu lista."); printf("\n3-Meniu arbore."); printf("\n4-Permutari."); printf("\n0-Iesire."); meniu=getch(); switch(meniu) { case '1': { main1();break; } case '2': { main2();break; } case '3': { main3();break; } case '4': { main4();break; } } } while(meniu!='0'); }
De mentionat faptul ca pentru a evita orice eroare de genul function() should have a prototype s-au declarat antetele functiilor dupa cum urmeaza:
void cft(); void aft(); void sft(); void mft(); void lft(); void cfb(); void lfb(); void update_fis_bin(); void modi_fist_list(); void crl(); void mdl(); void listl(); void adaugare_list(); void main1(); void main2();
45

void main3(); void creare_vex(); int sol[30]; struct fisier_text { char nume[30],pren[30],sbul[15]; int camera; struct data_venire { int z,l,a; }dv; struct data_plecare { int z,l,a; }dp; }ft; struct fisier_binar { int camera,et,cost; char tc[20],stare[10]; }fb; struct nod_lista { fisier_text ftt; nod_lista *st,*dr; }*prim,*ultim; struct arb { fisier_text ftt; arb *st,*dr; }; arb *rad; struct back { int x[30],n,k; }vex; void inordine(arb *m); void postordine(arb *m); void preordine(arb *m); void cautare(); void creare_arb_tast(); void adaugare_arb();
46
BIBLIOGRAFIE
CURSURI TEHNICI DE PROGRAMARE CURSURI PROGRAMAREA CALCULATOARELOR MANUAL INFORMATICA, PROFIL REAL, CLASA XI
http://www.cprogramming.com http://www.cplusplus.com
47

Gestiunea Unui Hotel

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Gestiunea Unui Hotel

Încărcat de

Drepturi de autor:

Formate disponibile

Gestiunea unui hotel----Tehnici de programare