Nume: Herțeg Alexandra Antoaneta

Grupa: 214

Structuri de date și algoritmi

Proiect 8
TAD DicționarOrdonat – implementare folosind o tabelă de dispersie / rezolvare coliziuni prin liste
independente.

Enunț
Pizza Delivery
Să se creeze o aplicație care ajută un angajat de la o Pizzerie să distribuie corect cutiile de pizza pe
anumită stradă. La fiecare casă el poate lăsa un anumit număr de cutii. Aplicația permite adăugarea
unui număr de cutii pentru o anumită casă, iar fiecărei case i se asociază o cheie corespunzătoare
numărului în cadrul străzii. De asemenea, aplicația permite ștergerea și căutarea unui număr de cutii
de pizza pentru o anumită casă și afișarea numărului de case de pe stradă.

Interfață TAD + Specificare

1) TAD DicționarOrdonat

Domeniu:
OD = { od | od este un dictionar ordonat cu elemente e = (c, v), c de tip Tcheie, v de tip
TValoare}

Operații: (interfață TAD-ului Dicționar)

creează(R, od)
pre: true
post: od  OD, od este dicționarul vid (fără elemente)

adaugă(od, c, v)
pre: od  OD, cTCheie, v  TValoare,
post: od’  OD, od’=od+(c,v) (se adaugă în dictionar perechea (c, v))

caută(od, c, v)
pre: od  OD, c  TCheie
post: v  TValoare e valoarea asociată cheii v
 -1 în cazul in care nu exista cheia c

șterge(od, c)
pre: od  OD, c  TCheie
post: perechea (c, v) este ștearsă din dictionar, dacă c  od
v  TValoare

dim(od)
pre: od  OD
post: dim=dimensiunea dicționarului od (numărul de elemente)

vid(od)
pre: od  OD
post: vid= adevărat în cazul în care od e dicționarul vid
fals în caz contrar

iterator(od, i)
{se creează un iterator pe dictionarul od}
pre: od  OD
post: od  I i este iterator pe dicționarul od

2) TAD Iterator DicționarOrdonat

Domeniu:
I = { i | i – iterator pe od  OD }

Operații:
creeazăIterator(od, i)
pre: od  OD
post: I  I, current referă primul nod din dictionar

următor(i)
pre: i  I
post: i  I, current referă următorul nod din dictionar, față de cel referit de current
valid(i)
pre: i  I
post: valid = adevărat dacă current referă o poziție validă din dictionar
 fals în caz contrar

element(i, e)
pre: i  I, valid(i)
post: e de tip TElement , e este elemntul curent

3) TNod
Operatii:

creeazaTNod(nod, c, v, pnod)
pre: nod ∈ TNod, c ∈ TCheie, v ∈ TValoare, pnod ∈ PNod;
post: s-a creat nod ∈ TNod;

getElement(nod)
pre: nod ∈ TNod
post: getElement = e ∈ TElement, elemental in cadrul nodului

getCheie(nod)
pre: nod ∈ TNod
post: getCheie = c ∈ TCheie, cheia elementului

getValoare(nod)
pre: nod ∈ TNod
post: getValoare = v ∈ TValoare, valoarea elementului

Reprezentare + implementare operatii TAD

SD: tabelă de dispersie / rezolvare coliziuni prin liste independente

TElement
• c: TCheie (derivat din TComparabil)
• v: TValoare
• R ⸦ TCheie × TCheie

TNod
• e: TElement
• urm: ↑TNod

Iterator DO
 • od: OD
• current: ↑TNod

DO (DicționarOrdonat)
• od: TFuncție (funcția de dispersie)
• n: Întreg
• l: ↑TNod[0… n-1]
• R: Relații

PNod: ↑TNod

TNod

Subalgoritm creeazaTNod(nod, c, v, pnod) (Complexitate ϴ(1))

nod.e.c<-c
nod.e.v<-v
nod.urm<-pnod
SfSubalgoritm

Functie getEement(nod) (Complexitate ϴ(1))

getElement<- nod.e
SfFunctie

Functie getCheie(nod) (Complexitate ϴ(1))

getCheie<- nod.e.c
SfFunctie

Functie getValoare(nod) (Complexitate ϴ(1))

getValoare<- nod.e.v
SfFunctie

DictionarOrdonat

Subalgoritm creeaza(od) (Complexitate ϴ(n))

md.m <- max
Pentru i <-0,od.n-1 executa
od.l[i] <- NIL
SfPentru
SfSubalgoritm
Subalgoritm distruge(od) (Complexitate ϴ(n))
Pentru i <-0,od.n-1 executa
creeazaPNod(pnod)
pnod<- od.l[i]
od.l[i] <- od.l[i].urm
SfPentru
SfSubalgoritm

Functie vid(od) este (Complexitate ϴ(n))

Pentru i <-0,od.n-1 executa
Daca od.l[i] ≠ NIL atunci
vid<- fals
SfDaca
Altfel
vid <- adevarat
SfAltfel
SfPentru
SfFunctie

Functie dim(od) (Complexitate ϴ(n))

dim<-0
Pentru i <-0,od.n-1 executa
Daca od.l[i] ≠ NIL atunci
dim<- dim + 1
SfDaca
SfPentru
SfFunctie

Subalgoritm adauga(od, c, v) (Complexitate O(1))

i <- od.d(c)
aloca(p)
p<- PNod(c, v, NIL)
Daca od.l[i] = NIL atunci
l[i]=p
SfDaca
Altfel
aux1<- od.l[i]
Daca [aux1].e.c > c atunci
 l[i]=p
[p].urm-<aux1
SfDaca
aux2<-[od.l[i]].urm
CatTimp aux2≠ NIL si [aux1].e.c < c executa
Daca [aux2].e.c > c atunci break
aux1<-[aux1].urm
aux2<-[aux2].urm
SfCatTimp
[p].urm <- aux2
[aux].urm <- p
SfAltfel
SfSubalgoritm

Complexitate:
Caz favorabil: ϴ(1) – perechea se afla pe prima pozitie in lista din tabela
Caz mediu: O(k), k = numarul perechilor din lista de pe pozitita i din tabela, cheia c
se poate afla pe oricare din pozitiile listei
Caz defavorabil: ϴ(k), k = numarul perechilor din lista de pe pozitia i din tabela,
cheia c se afla pe ultima pozitie in lista ce incepe de pe pozitia i

Functie sterge(od, c)
i <- od.d(c)
Daca od.l[i] = NIL atunci
sterge<-fals
break
SfDaca
Altfel
Daca [l[i]].e.c = c atunci
p<- l[i]
l[i]<- [l[i]].urm
dealoca(p)
sterge<- adevarat
break
SfDaca
aux1<- od.l[i]
aux2<-[od.l[i]].urm
 CatTimp aux2≠ NIL si ([aux2].e.c ≠c ) executa
aux1<-aux2
aux2<-[aux2].urm
SfCatTimp
Daca aux2 ≠ NIL atunci
[aux1].urm<-[aux2].urm
dealoca(aux2)
sterge<-adevarat
break
SfDaca
SfAltfel
Sterge<-false
SfSubalgoritm

Functie cauta(od, c) (Complexitate O(1))

i <- od.d(c)
p<-od.l[i]
CatTimp p≠ NIL executa
Daca [p].e.c =c atunci
cauta<-[p].e.v
break
SfDaca
p<-[p].urm
SfCatTimp
cauta= -1
SfFunctie

Subalgoritm iterator(od,it) (Complexitate ϴ (1))

i<- creazaIterator(od)
SfSubalgoritm

Iterator

Subalgoritm creeazaIterator(od, i) (Complexitate ϴ (1))

i.od<-od
i.poz <- 0
deplasare(i)
SfSubalgoritm
Functie valid(i) (Complexitate ϴ (1))
valid<- fals
Daca poz<od.n si i.curent ≠ NIL atunci
valid<- adevarat
SfFunctie

Subalgoritm prim(i) (Complexitate ϴ (1))

i.poz<- 0
deplasare(i)
SfSubalgoritm

Subalgoritm urmator(i) (Complexitate ϴ (1))

i.curent<-[i.curent].urm
Daca i.curent = NIL atunci
i.poz<- i.poz +1
deplasare(i)
SfDaca
SfSubalgoritm

Functie element(i) (Complexitate ϴ (1))

e.c<- [i.curent].e.c
e.v<- [i.curent].e.v
element<- e

Proiectarea aplicatiei
In implementarea aplicatiei am creat clasa Repository care gestioneaza toate
actiunile care se pot face asupra Dictionarului. De asemenea am creat si o clasa UI
care face legatura intre utlizator si aplicatie.

Repository

 od: OD
 it: I

UI

 rep: Repository
Operatii Repository

Adauga( c, v)
pre: c ∈ TCheie, v ∈ TValoare;
post: Adauga = adevarat, daca s-a adaugat (c,v) in dictionarul rep.d
fals, altfel

Functie Adauga(c, v) (Complexitate O(1))

Daca cauta(rep.od, c) != -1 atunci
Adauga<-false
altfel
prim(rep.it)
adauga(rep.od, c, v)
prim(rep.it)
Adauga<-adevarat
SfAltfel
SfSubalgoritm

Sterge( c)
pre: c ∈ TCheie,
post: Sterge = adevarat, daca s-a sters (c,v) din dictionarul rep.d
fals, altfel

Functie Sterge(c) (Complexitate O (1))

Sterge<-sterge(rep.d, c)
prim(rep.it)
SfSubalgoritm

NumarCutiiCasa(c)
pre: c ∈ TCheie
post: NumarCutiiCasa = v ∈ TValoare, valoarea asociata cheii c

Functie NumarCutiiCasa(c) (Complexitate O (1))

NumarCutiiCasa <- cauta(rep.d,c)
SfSubalgoritm

NumarCase()
post: nrCase = n, n ∈ N;
n = numerul de chei ale dictionarului;
Functie nrCase() (Complexitate ϴ(n))
nrCase<-dim(rep.md)
SfSubalgoritm

TotalCutii()
post: TotalCutii = suma valorilor din dictionar

Functie TotalCutii() (Complexitate ϴ (1))

total<-0
CatTimp valid(rep.it) executa
e<- element(rep.it)
total = total + e.v
urmator(rep.it)
SfCatTimp
prim(rep.it)
SfSubalgoritm

ToateComenzile()
post: ToateComenzile = vector de elemente TElement

Functie ToateComenzile (Complexitate ϴ (1))

v<-NIL
CatTimp valid(rep.i) executa
e<-element(rep.it)
@adauga(v,e)
urmator(rep.it)
SfCatTimp
prim(rep.it)
SfSubalgoritm

Operatii UI

showMenu( ui)
pre: ui∈ UI;
post:

Subalgoritm showMenu(UI) (nu se poate calcula complexitatea)

 Repeta
tipareste ("____________________\n")
tipareste (" PIZZA DELIVERY \n")
tipareste (“1. Adauga comanda\n")
tipareste (“2. Sterge comanda\n")
tipareste (“3. Afisarea comenzii pentru o casa\n")
tipareste (“4. Afiseaza numarului de case de pe strada care au
comenzi\n")
tipareste ("5. Numarul total de cutii de pizza necesare pentru a finaliza
comenzile pe strada\n")
tipareste ("6. *Adauga cateva comenzi prestabilite\n")
tipareste (“7. Afisare comenzi\n”)
tipareste ("0. Exit\n")
tipareste (" Dati comanda: ")
citeste(comanda)
run(ui, comanda);
PanaCand comanda ≠ "0"
SfSubalgoritm

run( ui, comanda)

pre: ui ∈ UI, comanda ∈ string;
post:

Subalgoritm run(ui, comanda) (nu se poate calcula complexitatea)

Daca comanda = "1" atunci
tipareste( "\nNumar casa: ")
citeste (str)
@validare str ca fiind intreg
c<-str
tipareste( "Numar cutii de pizza: ")
citeste (v)
Daca rep.adauga(c, v) atunci
tipareste( "\n Comanda adaugata!\n")
Altfel tipareste("\n Comanda existenta!\n")
SfDaca
Altfel Daca comanda = "2" atunci
tipareste( "\nNumar casa: ")
citeste (str)
 @validare str ca fiind intreg
c<-str
Daca rep.sterge(c, v) atunci
tipareste( "\n Comanda stearsa!\n")
Altfel tipareste("\n Comanda inexistenta!\n")
SfDaca
Altfel Daca comanda = "3" atunci
tipareste( "\nNumar casa: ")
citeste (str)
@validare str ca fiind intreg
c<-str
Daca rep.numarCutiiCasa(c) = 0 atunci
tipareste (" Nu exista comanda!\n")
Altfel
tipareste(rep.corespondenteCasa(c))

SfDaca

Altfel Daca comanda = "4" atunci

tipareste( "\n Numar de case: ", rep.nrCase() )
SfDaca

Altfel Daca comanda = "5" atunci

tipareste( rep.totalCutii())
SfDaca
Altfel Daca comanda = "6") atunci
rep.adauga(2, 12)
rep.adauga(4, 13)
rep.adauga(1, 10)
rep.adauga(15, 3)
SfDaca
Altfel Daca comanda = ”7” atunci
Pentru e in rep.toateComenzile()
@tipareste e
Altfel Daca comanda = "0" atunci
comanda<- “0”
Altfel
tipareste("\nComanda invalida!\n")
SfSubalgoritm
 Diagrama de apeluri
PIZZA DELIVERY

showMenu(ui)

run(ui,comanda)

creazaRepository(rep) Adauga(rep,c,v) Sterge(rep,c,v) distrugeRepository(rep)

NumarCutiiCasa(rep,c) totalCutii(rep) nrCase(rep) toateComenzile(rep)

adauga(od, c,v) sterge(od,c) cauta(od, c) creaza(od) distruge(od)

vid(od) dim(od) urmator(i) prim(i) valid(i)

creeazaIterator(i) iterator(od, i) element(i)