Show page

Differences

This shows you the differences between two versions of the page.

--- sd-ca:laboratoare:lab-04 [2022/03/21 01:05]
maximilian.banu
+++ sd-ca:laboratoare:lab-04 [2025/03/26 12:47] (current)
radu.marin0508 [Double ended queue - Dequeue]
@@ Line 1: / Line 1: @@
-====== Laborator 4 - Dicţionar  ======
+====== Laborator 4 - Stivă și Coadă ======
+Responsabili:
+  * [[mailto:andreipirlea03@gmail.com|Andrei Pîrlea]]
+  * [[mailto:popaiarina13@gmail.com|Iarina-Ioana Popa]]
-Responsabili
-  * [[mailto:dinuaadrian@gmail.com|Andrei Dinu]]
-  * [[mailto:banu.maximilian401@gmail.com|Banu Maximilian]]
 ===== Obiective =====
-În urma parcurgerii acestui articol studentul va fi capabil să:
+În urma parcurgerii acestui laborator studentul va fi capabil să:
-  * definească tipul de date dicționar
+  * înțeleagă principiul de funcționare al structurilor de date stivă și coadă
-  * implementeze un dicționar folosind tabele de dispersie
+  * implementeze o stivă și o coadă folosind un vector pentru stocarea elementelor
-  * prezinte avantaje / dezavataje ale diverselor implementări de dicționare
+  * transforme o expresie din forma infixată în formă postfixată
+  * să evalueze o expresie în formă postfixată
+  * implementeze algoritmul de sortare Radix Sort
-===== Ce este un dicționar? =====
-{{ :sd-ca:laboratoare:hashing-crux.png|}}
+===== Stivă (Stack) =====
-Un dicţionar este un tip de date abstract compus dintr-o colecție de chei şi o colecție de valori, în care fiecărei chei îi este asociată o valoare.
-Operația de găsire a unei valori asociate unei chei poartă numele de **indexare**, aceasta fiind și cea mai importantă operație. Din acest motiv dicționarele se mai numesc și //array-uri asociative// - fac asocierea între o cheie și o valoare.
+O stivă este o instanță a unui tip de date abstract ce formalizează conceptul de colecție cu acces restricționat. Restricția respectă regula LIFO (Last In, First Out).
-Operația de adăugare a unei perechi (cheie-valoare) în dicționar are **două părți**. Prima parte este transformarea cheii într-un index întreg, strict pozitiv, printr-o funcție de **hashing**. În mod ideal, chei diferite mapează indexuri diferite în dicționar, însa în realitate nu se întamplă acest lucru. De aceea, partea a doua a operației de adăugare constă în procesul de **rezolvare a coliziunilor**.
+Accesul la elementele stivei se face doar prin vârful acesteia.
-==== Operații de bază ====
+Operații:
+      * //void push(struct Stack *stack, void *new_data)// – adaugă un element (entitate) în stivă. Adăugarea se poate face doar la vârful stivei.
+      * //void* pop(struct Stack *stack)// – șterge un element din stivă și îl returnează. Ștergerea se poate face doar la vârful stivei.
+      * //void* peek(struct Stack *stack)// – consultă (întoarce) elementul din vârful stivei fără a efectua nicio modificare asupra acesteia.
+      * //int is_empty(struct Stack *stack)// – întoarce //1// dacă stiva este goală; //0// dacă are cel puțin un element
-  * **put(key, value):**
+==== Implementare ====
-    * adaugă în dicționar o nouă valoare și o asociază unei anumite chei
-    * dacă perechea există deja, valorea este înlocuită cu cea nouă
-  * **remove(key):**
-    * elimină din dicţionar cheia **key** (şi valoarea asociată acesteia)
-  * **get(key):**
-    * întoarce valoarea asociată cheii
-    * dacă perechea nu există, întoarce corespunzător o eroare pentru a semnala acest lucru
-  * **has_key(key):**
-    * întoarce **TRUE** dacă există cheia respectivă în dicționar
-    * întoarce **FALSE** dacă nu există cheia respectivă în dicționar
-===== Implementare =====
+O structură de date definește un set de operații și funcționalitatea acestora.\\
+**Implementarea efectivă a unei structuri de date poate fi realizată în diverse moduri, cât timp funcționalitatea este păstrată.**
-O implementare frecvent întâlnită a unui dicționar este cea folosind o tabelă de dispersie - **hashtable**. Un **hashtable** este o structură de date optimizată pentru funcția de //căutare// - în medie, timpul de căutare este constant: O(1). Acest lucru se realizează transformând cheia într-un hash - un număr întreg fără semn pe 16 / 32 / 64 de biţi, etc. - folosind o **funcție hash**.
+O stivă poate fi implementată cu ajutorul unui **vector** sau cu **liste înlănțuite**.
-În cel mai defavorabil caz, timpul de căutare al unui element poate fi O(n) - dupa hash vom avea toate elementele in acelasi bucket, formand astfel o lista inlantuita care va trebui parcursa in intregime. Totuși, tabelele de dispersie sunt foarte utile în cazul în care se stochează cantități mari de date, a căror dimensiune (mărime a volumului de date) poate fi anticipat.
+În cadrul acestui laborator, ne vom concentra asupra implementării unei stive cu ajutorul unui liste înlănțuite.
-Funcția hash trebuie aleasă astfel încât să se **minimizeze** numărul coliziunilor (chei diferite care produc aceleași hash-uri). Coliziunile apar în mod inerent, deoarece lungimea hash-ului este fixă, iar obiectele de stocare pot avea lungimi și conținut arbitrare. În cazul apariției unei coliziuni, valorile se stochează pe aceeaşi poziție - în același **bucket**. În acest caz, căutarea se va reduce la compararea valorilor efective ale cheilor în cadrul bucket-ului.
+==== Reprezentare internă cu vector ====
-Exemplu de hash pentru șiruri de caractere:
+La nivel de implementare, stiva este reprezentată printr-o structură ce folosește un vector de stocare (//stack_array//) de o dimensiune maximă dată (//NMAX//) și un indice ce indică vârful stivei (//top_level//), cât și un set de operații ce pot fi efectuate asupra stivei.
-<code cpp hash.h>
+==== Exemplu de utilizare ====
-#ifndef __HASH__H__
-#define __HASH__H__
-// Hash function based on djb2 from Dan Bernstein
+=== Forma poloneză inversă ===
-// http://www.cse.yorku.ca/~oz/hash.html
-//
-// @return computed hash value
-unsigned int hash_fct(char *str)
+[[http://en.wikipedia.org/wiki/Reverse_Polish_notation|Forma poloneză inversă]] este o notație matematică în care fiecare operator urmează după toți operanzii săi.
-{
-    unsigned int hash = 5381;
-    int c;
-    while ((c = *str++) != 0) {
+Cel mai simplu exemplu de notație postfixată este cel pentru doi operanzi și un operator:
-        hash = ((hash << 5) + hash) + c;
+^ 5 + 4 ^ se scrie sub forma ^ 5 4 + ^
-    }
-    return hash;
+În cazul în care există mai multe operații, operatorul apare imediat după cel de-al doilea operand:
-}
+^ 2 + 4 - 5 ^ se scrie sub forma ^ 2 4 + 5 - ^
-#endif //__HASH__H__
+Avantajul major al formei poloneze inverse este faptul că elimină parantezele din cadrul expresilor:
-</code>
+^ 5 + (1 + 4) ^ se scrie sub forma ^ 5 1 4 + + ^
-[[https://stackoverflow.com/questions/1145217/why-should-hash-functions-use-a-prime-number-modulus|Exemplu pentru construcția de funcții hash care minimizează numărul de coliziuni]]
+=== Algoritmul de conversie a unei expresii din formă infixată în formă postfixată ===
-==== Reprezentarea internă cu liste înlănțuite ====
-O implementare a unui hashtable care tratează coliziunile se numește înlănțuire directă - **direct chaining**.
+<code>
-Cea mai simplă formă folosește câte o listă înlănțuită pentru fiecare bucket, practic un array de liste.
+. cât timp există elemente de citit
+.1 citește un element
+.2 dacă elementul este un număr, afișare (se adaugă la forma
+        postfixată)
+.3 dacă elementul este o paranteză stângă, adaugă-l în stivă
+.4 dacă elementul este o paranteză dreaptă, extrage operatorii din
+        stivă și adaugă-i la forma postfixată până când vârful stivei
+        ajunge o paranteză stângă (care este extrasă, dar nu este
+        adăugată la forma postfixată).
-Fiecare listă este asociată unui anumit hash.
+    !!! dacă stiva s-a golit fără să fie găsită o paranteză stângă,
+        înseamnă că expresia inițială avea paranteze greșite
+.5 dacă elementul este un operator (fie el O1)
+.5.1 cât timp există un alt operator în vârful stivei (fie el O2)
+        ȘI precedența lui O1 este MAI MICA SAU EGALA decât cea a lui O2, extrage O2
+        din stivă, afișare (se adaugă la forma postfixată)
+.5.2 adaugă O1 în stivă
+. când nu mai există elemente de citit, extrage toate elementele rămase
+   în stivă și adaugă-le la forma postfixată (elementele trebuie să fie
+   numai operatori; dacă este extrasă o paranteză stângă expresia inițială
+   avea parantezele greșite).
+</code>
-  * **inserarea** în hashtable presupune găsirea indexului corect și adăugarea elementului la lista corespunzătoare.
+=== Exemplu ===
-<note important>
-Hash-ul poate depăşi cu mult dimensiunea array-ului de bucket-uri, ceea ce duce la necesitatea folosirii, cel mai frecvent, a operaţiei //modulo// -> **index = hash % HMAX**,  pentru a situa indexul bucket-ului în care va fi inserat elementul în limitele necesare.
-Dacă dimensiunea array-ului este exprimată în puteri ale lui 2, se mai poate folosi şi formula următoare -> **index = hash & (HMAX - 1)**.
-**HMAX** reprezintă dimensiunea maximă a array-ului.
-</note>
-  * **ștergerea** presupune căutarea și scoaterea elementului din lista corespunzătoare.
-  * **cautarea** presupune determinarea index-ului prin funcția de hashing și apoi identificarea perechii potrivite.
-  * **has_key** presupune determinarea existenței unei chei în dicționar
+Fie expresia:
 <code>
-void put(key, value, hash_table)
+- 7 * 2 /(3 + 5)^2^5
-	index <- hash(key) % DIMENSIUNE_DICTIONAR
+</code>
-	pentru element it in bucketul hash_table[index]
-		// Se itereaza prin lista inlantuita de la index, pana se
-		// gaseste cheia dorita; daca nu este gasita, vom insera
-		// un entry nou in cadrul bucketului
-		daca it->key == key
-			// Daca exista key deja in bucket
-			// doar se updateaza valoarea
-			it->value <- value
-			return; // Cheia a fost actualizata, iesim din functie
-        // Daca nu a fost gasita cheia in bucket, inseram una noua
-	creeaza un nou element pe baza key, value
-        adauga elementul in hashtable
-void remove(key, hash_table)
+^  Element  ^  Acțiune  ^  Forma postfixată  ^  Stiva  ^  Observaţii  ^
-        index <- hash(key) % DIMENSIUNE_DICTIONAR
+|   1   | Adaugă element la forma postfixată |       1       |            |    |
-	pentru element it in bucketul hash_table[index]
+|   -   |       Pune elementul în stivă      |       1       |     -     | |
-		daca it->key == key
+|   7   | Adaugă element la forma postfixată |       1,7      |     -     | |
-			break
+|   *   |       Pune elementul în stivă      |       1,7      |     * \\ -   |  * are precedență mai mare decât -  |
+|   2   | Adaugă element la forma postfixată |      1,7,2      |    * \\ -     | |
-	// it va pointa ori dupa ultimul element (hash_table.end) => nu avem ce sterge
+|   /   |     Extrage element din stivă      |      1,7,2*     |          -         |     / și * au aceeași prioritate    |
-	// ori catre un element deja existent in bucket => stergem elementul it
+|  :::  |       Pune elementul în stivă      |     :::        |    / \\ -           |  / are precedență mai mare decât -  |
-	daca it nu indica finalul listei
+|   (   |       Pune elementul în stivă      |      1,7,2*     |  (  \\ / \\ -     | |
-		sterge elementul de la pozitia lui it
+|   3   | Adaugă element la forma postfixată |     1,7,2*3     |  (  \\ / \\ -      | |
+|   +   |       Pune elementul în stivă      |     1,7,2*3     |  + \\ (  \\ / \\ -  | |
+|   5   | Adaugă element la forma postfixată |     1,7,2*3,5    |  + \\ (  \\ / \\ -  | |
+|   )   |     Extrage element din stivă      |    1,7,2*3,5+    |   (  \\ / \\ -       | Se repeta până când se întâlnește ( |
+|   :::  |              repetă                |    :::    |    / \\ -         |          ( a fost ignorat           |
+|  %%^%%  |       Pune elementul în stivă      |    1,7,2*3,5+   |  %%^%% \\ / \\ -   |  %%^%% are precedență mai mare decât /  |
+|   2   | Adaugă element la forma postfixată |    1,7,2*3,5+2   |   %%^%% \\ / \\ -   | |
+|  %%^%%  |       Pune elementul în stivă      |    1,7,2*3,5+2   |  %%^%% \\ %%^%% \\ / \\ -  | %%^%% este considerat asociativ-dreapta |
+|   5   | Adaugă element la forma postfixată |   1,7,2*3,5+2,5   |   %%^%% \\ %%^%% \\ / \\ -  | |
+| Final | Extrage toate elementele din stivă |  1,7,2*3,5+2,5%%^%%%%^%%/-  | | |
-TypeValue get(key, hash_table)
+=== Algoritmul de evaluare a unei expresii în formă postfixată ===
-	index <- hash(key) % DIMENSIUNE_DICTIONAR
-	pentru element it in bucketul hash_table[index]
-		daca it->key == key
-			return it->value
-	return null
-bool has_key(key, hash_table)
+<code>
-	index <- hash(key) % DIMENSIUNE_DICTIONAR
+. cât timp există elemente de citit
-	pentru element it in bucketul hash_table[index]
+.1 citește un element
-		daca it->key == key
+.2 dacă elementul este o valoare
-			return true
+.2.1 pune elementul în stivă
+        altfel (elementul este un operator)
-	return false
+.2.2 extrage 2 operanzi din stivă
+.2.3 dacă nu există 2 operanzi în stivă
+                EROARE: forma postfixată nu este corectă
+.2.4 evaluează rezultatul aplicării operatorului asupra celor doi
+                  operanzi
+.2.5 pune rezultatul în stivă
+. dacă există o singură valoare în stivă
+.1 afișează valoarea ca rezultat final al evaluării expresiei
+    altfel
+        EROARE: forma postfixată nu este corectă
 </code>
-Avantajul tabelelor de dispersie constă în faptul că operația de ștergere este simplă, iar redimensionarea tabelei poate fi amânată mult timp, deoarece performanța este suficient de bună chiar și atunci când toate pozițiile din hashtable sunt folosite.
-Dezavantajele acestei soluții sunt cele moștenite de la listele înlănțuite: pentru stocarea unor date mici, overhead-ul introdus poate fi semnificativ, iar parcurgerea unei liste este costisitoare.
+=== Exemplu de utilizare in sistemele de operare ===
-Există și alte structuri de date cu ajutorul cărora se poate implementa un hashtable ca mai sus. Un exemplu ar fi un arbore binar de căutare echilibrat, pentru care timpul, pe cazul cel mai defavorabil, se poate reduce la O(log n) față de O(n). Totuși, această variantă se poate dovedi ineficientă dacă hashtable-ul este proiectat pentru puține coliziuni.
+Sistemele de operare folosesc conceptul de stiva pentru rularea oricarui program prin ceea ce se numeste call stack.
+Acesta este un mecanism care tine evidenta functiilor care se executa la un moment de timp. Call stack-ul
+va fi populat cu stack frame-uri, fiecare functie avand propriul frame ce se va distruge la terminarea executiei acesteia.
+Fiecare frame va stoca mai multe informatii necesare rularii programului precum parametri primiti de functie, variabile locale
+si adresa de return.
+La fiecare apel de functie, inainte de a executa codul respectivei functii, procesorul salveaza pe stiva
+adresa urmatoarei instructiuni de dupa acel apel, astfel incat, la terminarea functiei, sa poata relua executia din punctul corect.
-Un alt mod de a utiliza o listă inlanțuită pentru crearea unui dicționar presupune folosirea **linear probing**. Atunci când la inserarea unei perechi (cheie-valoare) în dicționar apărea o coliziune, algoritmul caută primul "spațiu gol" și inserează acolo perechea.
+===== Coadă (Queue) =====
-{{ :sd-ca:laboratoare:hashtb12.svg.png?nolink |}}
-==== Alte reprezentări interne ====
+O coadă este o structură de date organizată după modelul FIFO (First In, First Out): primul element introdus va fi primul eliminat din buffer.
-  *arbori binari de căutare echilibrați
+Funcții generale disponibile pentru interacțiunea cu o coadă:
-  *radix-tree
-  *prefix-tree
-  *array-uri judy
-Acestea prezintă timpi de căutare mai buni pentru cel mai defavorabil caz și folosesc eficient spațiul de stocare în funcție de tipul de date folosit.
+  * //void enqueue(struct Queue *queue, void *new_data)// – adaugă elementul la sfârșitul cozii. Adăugarea se face doar la sfârșitul cozii.
+  * //void* dequeue(struct Queue *queue)// – șterge un element din coadă și îl returnează. Ștergerea se poate face doar la începutul cozii.
+  * //void* front(struct Queue *queue)// – întoarce primul element din coada fără a-l scoate din aceasta.
+  * //int is_empty(struct Queue *queue)// – întoarce //1// dacă coada este goală; //0// dacă are cel puțin un element
-===== Schelet =====
+==== Variante de implementare ====
-{{:sd-ca:laboratoare:lab_4:lab_04_hashmap_skel.zip|}}
-===== Exerciţii =====
+O coadă se poate poate implementa folosind pe post de container **lista înlănțuită**, **array de dimensiune fixă**, **array circular**.
-<note important>
+=== Reprezentare internă cu listă înlănțuită ===
-Pentru a rezolva laboratorul folosind Github Classroom, urmați [[sd-ca:laboratoare/tutorial-github-classroom#adaugarea_solutiei_unui_laborator|acești pași]]. Asigurați-vă ca ați creat branchul pentru acest laborator **din branchul ''master''** al repository-ului vostru.
-</note>
-<note>
+  * //void enqueue(struct Queue *queue, void *new_data)// - echivalent cu operația de //add_last// efectuată pe listă. Complexitate: timp constant - O(1)
-Fiecare laborator va avea unul sau doua exerciții publice și un pool de subiecte ascunse, din care asistentul poate alege cum se formează celelalte puncte ale laboratorului.
+  * //void* dequeue(struct Queue *queue)// echivalent cu operația de //removeFirst//. Complexitate: timp constant - O(1)
-</note>
+  * //void* front(struct Queue *queue)// presupune returnarea valorii stocate in `head`-ul listei. Complexitate: timp constant - O(1)
+  * //int is_empty(struct Queue *queue)// - la fel ca în cazul listei. Complexitate: timp constant - O(1)
+=== Reprezentare internă cu vector ===
-) [**5p**] Implementaţi structura de date dicţionar, plecând de la pseudocodul de mai sus şi de la schelet.
+Vom avea doi indici (**head** și **tail**) ce vor reprezenta începutul, respectiv sfârșitul cozii în cadrul vectorului. Apare însă următoarea problemă din punctul de vedere al spațiului neutilizat: întotdeauna spațiul de la **0** la **head-1** va fi nefolosit, iar numărul de elemente ce pot fi stocate în coadă va scădea (având inițial N elemente ce pot fi stocate, după ce se extrage prima oară un element, mai pot fi stocate doar N-1 elemente). Vrem ca întotdeauna să putem stoca maxim N elemente.
-<hidden>
-  * [2p] funcţiile //init_ht// şi //put//
-  * [2p] funcţiile //get// şi //has_key//
-  * [2p] funcţiile //remove_ht_entry// şi //free_ht//
-</hidden>
+**Soluția**: vector circular.
-[**311CAa**]
+  * //void enqueue(struct Queue *queue, void *new_data)// - presupune adăugarea noului element la sfârșitul vectorului. Se verifică în prealabil dacă dimensiunea vectorului mai permite adăugarea unui element. Se incrementează **tail**. Complexitate: O(1)
+  * //void* dequeue(struct Queue *queue)// - "șterge" și întoarce primul element din vector. Se incrementează **head**. Complexitate: O(1)
+  * //void* front(struct Queue *queue)// - întoarce primul element din vector. Complexitate: O(1)
+  * //int is_empty(struct Queue *queue)// - //1// dacă vectorul nu conține niciun element, //0// în caz contrar. Complexitate: O(1)
-) [**2p**] **Studenţi**
+=== Reprezentare internă cu vector circular ===
-Studenții unei universități sunt memorați într-o bază de date ce are forma unui hashtable. Fiecare student este caracterizat prin nume, anul de studiu, materia preferată și nota obținută.
+La nivel de implementare, coada este reprezentată printr-un vector de stocare (//queue_array//) de o dimensiune maximă specificată (//N//), doi indici ce indică începutul (//head//) și sfârșitul cozii (//tail//), cât și un set de operații ce pot fi efectuate asupra cozii. De asemenea, se reține și dimensiunea curentă a cozii (//size//) pentru a putea spune când aceasta este plină sau vidă.
+  * //void enqueue(struct Queue *queue, void *new_data)// - adaugă noul element la sfârșitul vectorului. Se incrementează modulo (dimensiune container) indicele **tail**. Complexitate: O(1)
+  * //void* dequeue(struct Queue *queue)// - șterge și întoarce primul element din vector. Se incrementează modulo (dimensiune container) indicele **head**. Complexitate: O(1)
+  * //void* front(struct Queue *queue)// - întoarce primul element din vector. Complexitate: O(1)
+  * //int is_empty(struct Queue *queue)// - la fel ca în celelalte cazuri. Complexitate: O(1)
+  * //int is_full(struct Queue *queue)// - se verifică dacă următorul index după **tail** (circular) este egal cu **head**. Dacă da, returnează //1//,  returnează //0// în caz contrar. Complexitate: O(1)
-[**1p**] **a.** Adăugați studenții în hashtable. Comanda aferenta este **adauga_studenti N**, N numarul de studenti, urmand apoi N randuri cu studenti cu formatul: nume_student,an_de_studiu,materie,nota
-[**1p**] **b.** Căutarea unui student dupa nume. Se va folosi comanda **afiseaza_student nume**.
+=== Exemplu de utilizare a unei cozi (circulare) ===
-[**311CAb**]
+Conceptul de CPU scheduling se refera la ordinea in care procesele noastre ruleaza. Deoarece avem mai multe procese decat core-uri,
+trebuie sa stabilim un algoritm care ghideaza planificarea aceasta: cat timp unele vor rula, altele isi vor astepta randul.
+Cel mai simplu mecanism de acest tip este folosirea este folosirea unei cozi (circulare), in care toate procesele sunt tratate cu
+aceeasi prioritate si se executa in ordinea in care au fost introduse in coada. Spunem despre acest tip de algoritm ca este de tip
+[[https://www.guru99.com/round-robin-scheduling-example.html|Round Robin]].
-) [**2p**] **Movies**
+Pasii sunt urmatorii:
+Lansam un proces. El este adaugat in coada si primeste o cuanta de timp de nivelul ms (cat timp are voie sa ruleze).
+Cand se elibereaza un loc pe procesor, se face dequeue, iar procesul scos din coada va rula. Daca isi consuma toata cuanta
+de timp si inca nu si-a terminat toate instructiunile, este adaugat inapoi in coada, i se reseteaza cuanta si isi asteapta randul.
-Un website are o baza de date in care retine filme si seriale. Un film este caracterizat de nume, regizor, anul aparitiei și rating.
+===== Alte tipuri de coadă =====
-[**1p**] **a.** Adăugaţi filme în hashtable. Comanda aferenta este **adauga_filme N**, N numarul de filme, urmand apoi N randuri cu filme cu formatul: nume_filme,regizor,an_aparitie,rating
+==== Double ended queue - Deque ====
-[**1p**] **b.** Afisati toate filmele cu rating mai mic de N stele. Se va folosi comanda **afiseaza_filme N**.
+Într-o coadă obișnuită accesul la elemente este de tip FIFO - elementele sunt introduse pe la un capăt și scoase la celălalt capăt. În cazul unei Deque, se permit ambele operații, la ambele capete. Astfel, în capătul **head** se pot atât introduce, cât și extrage elemente. La fel și în cazul capătului **tail**. Se observă că cele două structuri prezentate în acest laborator (stiva și coada) sunt particularizări ale structurii de date Dequeue.
+Dintre cele 4 operații de adaugare/ștergere puse la dispoziție de o deque, atât stiva cât și coada folosesc doar 2 (push_front() și pop_front() în cazul stivei, respectiv push_back() și pop_front() în cazul cozii). Desigur, deque permite vizualizarea elementelor din ambele capete ale cozii: front() și back().
-[**312CAa**]
+==== Priority Queue ====
-) [**2p**] **Bibliotecă**
+Este o coadă în care un dequeue() / peek() va întoarce primul element din acea coadă în funcție de un anumit criteriu. Exemplu: pentru o coadă cu priorități care organizează elementele în funcție de valoarea maximă, un peek() va întoarce valoarea maximă stocată. Similar, în cazul unei cozi cu priorități de minim, peek() va întoarce valoarea minimă stocată.
-Cărțile dintr-o bibliotecă sunt reprezentate în sistem folosindu-se un hashtable. O carte este caracterizată prin titlu, autor, anul în care a fost publicată și statusul (la raft sau împrumutată).
+===== Exemple de utilizare =====
-[**1p**] **a.** Adăugaţi cărţi în hashtable. Comanda aferenta este **adauga_carte N**, N numarul de carti, urmand apoi N randuri cu carti cu formatul: titlu,autor,an_publicare,status
+<hidden>
+==== Cel mai dens interval ====
-[**1p**] **b.** Afișarea tuturor cărților scrise de autorul **famous_author**. Se va folosi comanda **afiseaza_carti famous_author**. Nu parcurgeți toate intrările din hashtable!  (HINT: Este de ajuns hashtable-ul curent?)
+Să presupunem că avem o mulțime de puncte unidimensionale și sortate. Dorim să găsim intervalul de mărime k > 0 care are cele mai multe puncte în interiorul acestuia. Această problemă se poate rezolva printr-o singură parcurgere a şirului de numere. Considerăm o coadă inițial vidă. Pe măsură ce parcurgem șirul, adăugăm elemente în coadă. Atât timp cât elementul pe care urmează să-l adăugam este la o distanță mai mare decât k față de capul cozii, atunci putem apela metoda dequeue() pentru a scoate elementul din capul cozii. Elementul poate fi scos deoarece se află la o distanță mai mare de k față de ultimul element introdus și deci nu mai trebuie luat în considerare.
-[**312CAb**]
+Exemplu:
-) [**2p**] **Adrese**
+Fie șirul de numere:
+<code>
+, 2, 4, 20, 21, 22, 23, 60, 100, 101, 111
+</code>
-O firma de imobiliare folosește un hashtable pentru a memora imobilele pe care le administrează. Un astfel de imobil este caracterizat de numele strazii, numarul, anul în care a fost construit si numarul de camere.
+Dorim să aflam cel mai mare interval de numere a căror distanță între capete sa fie cel mult 3([x ... x + 3])
-[**1p**] **a.** Adăugaţi imobile în hashtable. Comanda aferenta este **adauga_imobil N**, N numarul de imobile, urmand apoi N randuri cu imboile cu formatul: adresa,,an_publicare,status
+Introducem primul element în coadă:
-[**1p**] **b.** Verificarea disponibilității casei de la adresa **nume_adresa**. Se va folosi comanda **verifica_adresa nume_adresa**. Dacă nu locuiește nimeni la această adresă, afișați “Omg! You can move in right now!”, altfel, afișați “Your dream house is no longer available”.
+<code>
+queue = { 1 }
+</code>
-[**313CAa**]
+După următoarele 2 iterații coada va arăta astfel:
+<code>
+queue = { 1, 2, 4 }
+</code>
-) [**2p**] **UEFA**
+La următoarea iterație ajungem la numărul 20
-Site-ul UEFA se pregăteşte să publice cea mai bună echipă a tuturor timpurilor.
+ se află la distanță mai mare de 3 decât toate elementele aflate momentan în coadă, așa că vor fi scoase toate și introdus 20.
-Baza de date este ținută sub forma unui hashtable. Un fotbalist este caracterizat
-prin nume, naţionalitate, poziția pe care a jucat, cel mai important trofeu câştigat şi
-un rating. În cazul atacanţilor şi mijlocaşilor se contorizează numărul de goluri marcate
-și assist-uri iar în cazul portarilor şi al fundașilor se contorizează
-numărul de meciuri fără gol primit și tackling-uri reușite.
-[**1p**] **a.** Adăugați cel puţin 5 jucători în hashtable. Cel puţin unul dintre aceştia trebuie să aibă un rating mai mare de 200 şi cel puţin un jucător trebuie să aibă un rating mai mic de 200.
+<code>
+queue = { 20 }
+</code>
-[**1p**] **b.** Afişarea informaţiilor despre un jucător
+La final programul va returna numerele
+<code>
+result = { 20, 21, 22, 23 }
+</code>
+</hidden>
-[**1p**] **c.** Eliminați din hashtable fotbaliștii cu rating mai mic de 200.
+==== Radix Sort ====
-[**1p**] **d.** Afișați cei mai buni jucători din țara <country_query>. Nu parcurgeți toate intrările din hashtable! Hint: Este de ajuns hashtable-ul curent?
+Radix Sort este un algoritm de sortare care ține cont de cifre individuale ale elementelor sortate. Aceste elemente pot fi nu doar numere, ci orice altceva ce se poate reprezenta prin întregi. Majoritatea calculatoarelor digitale reprezintă datele în memorie sub formă de numere binare, astfel că procesarea cifrelor din această reprezentare se dovedește a fi cea mai convenabilă. Există două tipuri de astfel de sortare: LSD (least significant digit) şi MSD (most significant digit). LSD procesează reprezentările dinspre cea mai puțin semnificativă cifră spre cea mai semnificativă, iar MSD invers.
-[**313CAb**]
+O versiune simplă a radix sort este cea care folosește 10 cozi (câte una pentru fiecare cifră de la 0 la 9). Aceste cozi vor reține la fiecare pas numerele care au cifra corespunzătoare rangului curent. După această împărțire, elementele se scot din cozi în ordinea crescătoare a indicelui cozii (de la 0 la 9), și se rețin într-un vector (care devine noua secvență de sortat).
+Exemplu:
-) [**2p**] **Recipes**
+Secvența inițială:
-O mini-carte de rețete este memorată într-o bază de date ce are forma unui hashtable. Fiecare rețetă este caracterizată prin nume și o listă de ingrediente.
+<code>
+, 45, 75, 90, 2, 24, 802, 66
+</code>
-[**1p**] **a.** Adăugaţi cel puţin 5 reţete în hashtable. Cel puţin o reţetă trebuie să folosească mai mult de 5 ingrediente şi cel puţin o reţetă trebuie să folosească mai puţin de 5 ingrediente.
+Numere sunt introduse în 10 cozi (într-un vector de 10 cozi), în funcție de cifrele de la dreapta la stânga fiecărui număr.
-Exemplu orientativ:
-HASH = 0: Bomboane cu lapte: apa, zahar, smantana
- | Chec: oua, faina, zahar, unt, lapte, cacao
- |
-HASH = 1:
-HASH = 2: Mamaliga: apa, sare, malai
- | MBS: apa, sare, malai, branza, smantana
- | Bruschete: rosii, usturoi, busuioc, ulei de masline, ceapa, sare, bagheta
- |
-[**1p**] **b.** Căutarea unei rețete din schelet în hashtable. Se va afișa lista de ingrediente în cazul în care este găsită sau “I don’t know how to cook this”, în caz contrar.
+Cozile pentru prima iterație vor fi:
-[**1p**] **c.** Afișarea tuturor preparatelor care conțin un anumit ingredient. Nu parcurgeți toate intrările din hashtable! (Hint: Este de ajuns hashtable-ul curent)?
+<code>
+  * 0: 170, 090
+  * 1: nimic
+  * 2: 002, 802
+  * 3: nimic
+  * 4: 024
+  * 5: 045, 075
+  * 6: 066
+  * 7 - 9: nimic
+</code>
-[**1p**] **d.** Eliminarea tuturor reţetelor care au mai mult de 5 ingrediente.
+a. Se face dequeue pe toate cozile, în ordinea crescătoare a indexului cozii, și se pun numerele într-un vector, în ordinea astfel obținută:
-[**314CAa**]
+Noua secvență de sortat:
-) [**2p**] **Bancă**
+<code>
+, 090, 002, 802, 024, 045, 075, 066
+</code>
-The Trans-Dimensional Bank folosește un hashtable pentru a memora clienții. Contul unui client este caracterizat de nume, cod pin, listă de tranzacții și o sumă de bani. O tranzacție este definită prin locație, data efectuării tranzacției și suma tranzacționată. Pentru o listă de clienți dată, implementați următoarele:
+b. A doua iterație:
-[**1p**] **a.** Adăugaţi cel puţin 5 clienţi în hashtable, iar pentru fiecare client adăugați cel puţin 2 tranzacţii. Cel puţin unul dintre clienţi trebuie să aibă mai mult de 50 de bani în cont, iar cel puţin un client trebuie să aibă mai puţin de 50 de bani în cont.
+Cozi:
-Exemplu orientativ:
-HASH = 0:
-Morty Smith's transactions:
-spent on 12-1-16
-spent on 1-12-15
-spent on 20-1-14
- |
-Jerry Smith's transactions:
-spent on 17-1-17
-spent on 13-1-12
- |
-HASH = 1:
-HASH = 2:
-Rick Sanchez's transactions:
-spent on 21-7-98
-spent on 8-8-18
- |
-Summer Smith's transactions:
-spent on 20-12-15
-spent on 19-1-14
- |
-Beth Smith's transactions:
-spent on 15-6-18
-spent on 16-6-18
-[**1p**] **b.** Afișarea tuturor tranzacţiilor unui client dat.
+<code>
-Exmeplu output:
+  * 0: 002, 802
-Rick Sanchez's transactions:
+  * 1: nimic
-spent on 21-7-98
+  * 2: 024
-spent on 8-8-18
+  * 3: nimic
+  * 4: 045
+  * 5: nimic
+  * 6: 066
+  * 7: 170, 075
+  * 8: nimic
+  * 9: 090
+</code>
-[**1p**] **c.** Eliminarea din hashtable a clienților care au în cont o sumă de bani mai mică de 50.
+Noua secvență:
-[**1p**] **d.** Afişarea tuturor tranzacțiilor dintr-o zi (Hint: e suficient un singur hashtable?)
+<code>
+, 802, 024, 045, 066, 170, 075, 090
+</code>
-[**314CAb**]
+c. A treia iterație:
-) [**2p**] **Studenţi (varianta 2)**
+Cozi:
-Studenții unei universități sunt memorați într-o bază de date ce are forma unui hashtable. Fiecare student este caracterizat prin nume, facultatea la care este înscris, anul de studiu și media obținută.
+<code>
+  * 0: 002, 024, 045, 066, 075, 090
+  * 1: 170
+  * 2 - 7: nimic
+  * 8: 802
+  * 9: nimic
+</code>
-[**1p**] **a.** Adăugați cel puțin 5 studenți în hash table.
+Noua secvență:
-Exemplu orientativ:
-HASH = 0: Todd Chavez | Mr. Peanutbutter |
-HASH = 1: BoJack Horseman | Sarah Lynn |
-HASH = 2: Diane Nguyen |
-HASH = 3: Princess Carolyn |
-HASH = 4:
-[**1p**] **b.** Căutarea unui student după nume. Se va afișa “Studentul <nume_student> este înscris la facultatea <facultate_student> și are media <nota_student>.” în cazul în care este găsit sau “Studentul <nume_student> nu a fost găsit!”, în caz contrar.
+<code>
+, 024, 045, 066, 075, 090, 170, 802 (sortată)
+</code>
-[**1p**] **c.** Afişaţi toţi studenţii care sunt înscrişi la o anumită facultate. Nu parcurgeți toate intrările din hashtable!  (HINT: Este de ajuns hashtable-ul curent?)
+Observam ca au fost suficiente 3 iterații, adică numărul cel mai mare de cifre dintre numerele din colecție. În acest caz, numerele cu mai puțin de 3 cifre au fost reprezentate cu 0-uri la început pentru a fi mai ușor de înțeles.
-[**1p**] **d.** Eliminați din hashtable toţi studenţii care au o medie mai mică decât valoarea medie a mediilor studentilor de la facultatea lor.
+===== Schelet =====
+<note important>
+Daca folositi **Github Classroom**, va rugam sa va actualizati scheletul cu cel de mai jos. Cel din repo-ul clonat initial nu este la cea mai recenta versiune.
+</note>
+{{:sd-ca:laboratoare:sda_lab5.zip|Scheletul de laborator}}
+===== Exerciţii =====
+<note>
+Trebuie să vă creați cont de [[https://www.devmind.ro/ | Devmind]], dacă nu v-ați creat deja, pe care îl veți folosi la SD pe toată durata semestrului.
+</note>
-[**315CAa**]
-) [**2p**] [**Magazin**]
+) [**3.5p**] Implementați, plecând de la scheletul de cod, stiva. **Atenție!** În implementarea stivei se va folosi **lista simplu înlănțuită** detaliată în secțiunea de mai sus. (problema **Stack Implementation** pe Devmind)
-Un magazin stochează date despre produsele pe care le vinde într-o bază de date implementată ca hashtable. Fiecare produs este caracterizat prin nume, categorie, pret, număr vânzări.
+) [**3.5p**] Implementați, plecând de la scheletul de cod, coada. **Atenție!** Implementarea are la baza un **vector circular** despre care puteți citi mai multe în secțiunea de mai sus. (problema **Queue Implementation** pe Devmind)
-[**1p**] **a.** Adăugați cel puțin 5 produse în hashtable din cel puţin două categorii diferite.
+(**Bonus**) [**2p**] Implementați operațiile elementare ale unei stive folosind două cozi. Problema admite două versiuni: una în care operația pop este eficientă, iar cealaltă în care operația push este eficientă. (pentru a primi punctajul, implementați soluția local, apoi urcați codul pe GitHub)
-[**1p**] **b.** Căutarea unui produs după nume. Se va afișa “Produs: <nume_produs>; Categorie: <nume_categorie>; Pret: <pret_produs>; Nr vanzari: <nr_vanzari_produs>” în cazul în care este găsit sau “Produsul <nume_produs> nu face parte din oferta magazinului.”, în caz contrar.
+<hidden>
+) [**1p**] Verificați dacă un număr este palindrom folosind un deque.
-[**1p**] **c.** Afişaţi toate produsele dintr-o anumită categorie. Nu parcurgeți toate intrările din hashtable!  (HINT: Este de ajuns hashtable-ul curent?)
+</hidden>
-[**1p**] **d.** Eliminați din hashtable toate produsele care au un număr de vânzări mai mic strict decât media vânzărilor produselor din categoria lor.
-[**315CAb**]
-) [**2p**] **Garaj**
-Un service auto stochează date despre maşinile clienţilor într-o bază de date implementată ca hashtable. Fiecare maşină este caracterizat prin număr de înmatriculare, proprietar şi status (maşina e reparată sau aşteaptă ca un mecanic s-o verifice).
-[**1p**] **a.** Adăugați cel puțin 5 maşini în hashtable. Cel puţin o maşină trebuie să aibă statusul de “reparată” şi cel puţin una trebuie să aibă statusul de “în aşteptare”. Cel puţin 2 maşini trebuie să aibă acelaşi proprietar.
-[**1p**] **b.** Căutarea unei maşini după numărul de înmatriculare. Se va afișa “Maşina: <numar_inmatriculare>; Proprietar: <nume_proprietar>; Status: <status_masina>” în cazul în care este găsită sau “Masina <numar_inmatriculare> nu se afla in service.”, în caz contrar.
-[**1p**] **c.** Afişaţi toate maşinile din baza de date care sunt deţinute de un acelaşi proprietar specificat. Nu parcurgeți toate intrările din hashtable!  (HINT: Este de ajuns hashtable-ul curent?)
-[**1p**] **d.** Eliminați din hashtable toate maşinile care au fost deja reparate (pe baza statusului).
-[**2p**] **(bonus).** Implementați și testați redimensionarea unui hashtable: funcția resize dublează dimensiunea structurii interne a tabelei de dispersie. Dublarea se va face în momentul în care raportul dintre numărul de elemente introduse în hashtable şi numărul de bucket-uri HMAX este mai mare decâti o valoare aleasă (ex: size / HMAX > 0.75). Comportamentul dorit pentru această funcţionalitate este următorul: se redimensionează array-ul de bucket-uri, iar apoi fiecare bucket este parcus în ordine și elementele sunt redistribuite după valoarea noului hash.
 ===== Interviu =====
@@ Line 355: / Line 354: @@
 Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului.
-  * Pentru o colecție de date cu nume, prenume și multe alte câmpuri, cum ai defini funcția hash?
+  - Implementați, folosind un singur vector, 3 stive
-  * Care este complexitatea unei operatiuni de căutare într-un hashtable?
+  - Scrieți un program cu ajutorul căruia să sortați o stivă. Nu aveți acces decât la operațiile push(), pop(), top() și is_empty()
-  * Care este diferența dintre un hashtable și un vector?
+  - Adăugați structurii de stivă o nouă funcție numită min, funcție care returnează cel mai mic element. Push, pop și min trebuie să aibă complexitate O(1)
-  * Descrie cum ai implementa DEX cu ajutorul unui hashtable.
+  - Descrieți cum este folosită stiva sistemului în cazul transmiterii parametrilor apelului unei funcții
-  * În ce condiții căutarea într-un hashtable ar putea să nu fie constantă?
+  - Implementați operațiile elementare ale unei stive folosind două cozi. Problema admite două versiuni: una în care operația **pop** este eficientă, iar cealaltă în care operația **push** este eficientă.
+  - Implementați operațiile elementare ale unei cozi folosind două stive.
+  - Presupunând că avem o coadă ce conține un număr mare de elemente, coada neputând fi ținută în memorie. Prezentați o modalitate de a implementa operațiile **enqueue** și **dequeue**.
+  - Să se implementeze o coadă ce are și operația **findmax**, pe lângă operațiile **enqueue** și **dequeue**. **findmax** trebuie să returneze cea mai mare valoare aflată în coadă la momentul respectiv. Oferiți o implementare eficientă.
+  - Cum s-ar implementa o stivă folosind o coadă de priorități?
+  - De câte cozi este nevoie ca să se poată implementa o coadă de priorități?
+  - Rezolvati problema Turnurilor din Hanoi.
 ===== Bibliografie =====
-  - [[http://en.wikipedia.org/wiki/Hashtable|Wikipedia: Hashtable]]
+  - [[http://www.cs.usfca.edu/~galles/visualization/StackArray.html|Array Stack Visualization]]
-  - [[http://en.wikipedia.org/wiki/Hash_function|Wikipedia: Hash function]]
+  - [[http://www.cs.usfca.edu/~galles/visualization/StackLL.html|Linked List Stack Visualziation]]
-  - [[http://www.cs.usfca.edu/~galles/visualization/OpenHash.html|Open Hashing Visualization]]
+  - [[http://www.cs.usfca.edu/~galles/visualization/QueueArray.html | Array Queue Visualization]]
-  - [[http://www.cs.usfca.edu/~galles/visualization/ClosedHash.html|Closed Hashing Visualization]]
+  - [[http://www.cs.usfca.edu/~galles/visualization/QueueLL.html | Linked List Queue Visualization]]
-  - [[http://www.cs.usfca.edu/~galles/visualization/ClosedHashBucket.html|Closed Hashing (Buckets) Visualization]]
+  - CLRS - //Introduction to Algorithms, 3rd edition//, capitol 10.1 - Stacks and queues
-  - [[http://www.cse.yorku.ca/~oz/hash.html|Collection of hash functions]]

Informatii utile

Laboratoare

Laboratoare din anii trecuti

Teme

Temele vor fi comune la toate seriile, urmariti meta-cursul SDA CA+CB+CC+CD

Resurse

sd-ca/laboratoare/lab-04.1647817552.txt.gz · Last modified: 2022/03/21 01:05 by maximilian.banu

Show page Old revisions

Media Manager Back to top