Show page

Differences

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

--- sd-ca:laboratoare:lab-10 [2020/04/28 20:00]
dorin_andrei.geman [Laborator 10 - Treap]
+++ sd-ca:laboratoare:lab-10 [2024/05/16 14:31] (current)
andrei.pirlea [Noțiuni de bază despre treapuri]
@@ Line 2: / Line 2: @@
 Responsabili
+  * [[alinichim49@gmail.com | Alin Ichim]]
+  * [[andreipirlea03@gmail.com | Pîrlea Andrei]]
-* [[mailto:topala.andrei@gmail.com|Andrei Topală]]
-* [[mailto:doringeman@gmail.com|Dorin Geman]]
 ===== Obiective =====
+În urma parcurgerii articolului, studentul va fi capabil să:
+    * înțeleagă conceptul unui arbore echilibrat de căutare
+    * exemplifice acest concept pe structura de treap
+    * implementeze operațiile de adăugare/ștergere a unui nod și rotiri
+    * facă operații mai complexe și parcurgeri de treapuri
+===== Noțiuni teoretice =====
-În urma parcurgerii acestui articol studentul va:
+==== Necesitatea structurii de arbore binar de căutare echilibrat ====
-  * înțelege conceptul unui arbore echilibrat de căutare
-  * exemplifica acest concept pe structura de treap
-  * implementa operațiile de adăugare nod, ștergere nod și rotiri
-  * face operații mai complexe si parcurgri de treapuri
-  * intelege cum functioneaza structurile AVL si Red-Black Tree
-===== Necesitatea structurii de arbore binar de căutare echilibrat =====
 O structură de date este o metodă de a reține anumite date astfel încât operațiile cu acestea (căutare, inserare, ștergere) să fie făcute cât mai eficient și să respecte cerințele programatorului. De multe ori, o anumită structură de date se află la baza unui algoritm sau sistem, iar o performanță bună a acesteia (complexitate spațială și temporală cât mai mică) influențează performanța întregului sistem.
-În laboratoarele precedente am observat că un arbore binar de căutare de înălțime **h** implementează operațiile descrise mai sus într-o complexitate de **O(h)**. Dacă acest arbore binar nu este capabil să gestioneze elementele ce sunt inserate pentru a își menține o structura echilibrată atunci complexitatea pe operațiile de bază va crește.
+În laboratoarele precedente am observat că un arbore binar de căutare de înălțime h implementează operațiile descrise mai sus într-o complexitate de O(h). Dacă acest arbore binar nu este capabil să gestioneze elementele ce sunt inserate pentru a își menține o structura echilibrată atunci complexitatea pe operațiile de bază va crește.
-<note tip>
+<note example>
-**Exemplu**: Să presupunem ca avem de introdus **n** numere într-un arbore binar de căutare. Întâmplarea face ca numerele să fie sortate, de unde rezultă că arborele format va avea o structură liniară -> fiecare nod va avea un singur vecin (practic, arborele se va transforma intr-o lista inlantuita). Astfel, complexitatea pe operaţiile de bază va fi **O(n)**.
+Exemplu: Să presupunem ca avem de introdus n numere într-un arbore binar de căutare. Întâmplarea face ca numerele să fie sortate, de unde rezultă că arborele format va avea o structură liniară → fiecare nod va avea un singur vecin (practic, arborele se va transforma intr-o lista inlantuita). Astfel, complexitatea pe operaţiile de bază va fi O(n).
 </note>
+==== Noțiuni de bază despre treapuri ====
-===== Noțiuni de bază despre treapuri =====
+Treapurile sunt un bun exemplu de arbori de căutare echilibrați, cel mai des folosiți datorită implementării relativ ușoare (comparativ cu alte structuri similare cum ar fi Red-Black Trees, AVL-uri sau B-Trees), dar și a modului de operare destul de intuitiv. Fiecare nod din treap va reţine două câmpuri:
-Treapurile sunt un bun exemplu de ''arbori de căutare echilibrați'', cel mai des folosiți datorită implementării relativ ușoare (comparativ cu alte structuri similare cum ar fi Red-Black Trees, AVL-uri sau B-Trees), dar și a modului de operare destul de intuitiv.
-Fiecare nod din treap va reţine două câmpuri:
   * cheia - informația care se reține în arbore și pe care se fac operațiile de inserare, căutare și ștergere
   * prioritatea - un număr pe baza căruia se face echilibrarea arborelui
 Această structură trebuie să respecte doua proprietati (sau invarianți):
-  * Proprietatea de arbore binar de căutare -> **binary search tree** (''tr''): **cheia** unui nod va fi mai mare sau egală decât **cheia** fiului stânga, dacă există şi mai mică sau egală decât **cheia** fiului dreapta, dacă există. Cu alte cuvinte o parcurgere inordine a arborelui va genera șirul sortat de chei.
+  * Proprietatea de arbore binar de căutare → binary search tree (tr): cheia unui nod va fi mai mare sau egală decât cheia fiului stânga, dacă există şi mai mică sau egală decât cheia fiului dreapta, dacă există. Cu alte cuvinte o parcurgere inordine a arborelui va genera șirul sortat de chei.
-  * Proprietatea de **heap** (''eap''): **prioritatea** unui nod este mai mare sau egală decât **prioritățile** fiilor.
+  * Proprietatea de heap (eap): prioritatea unui nod este mai mare sau egală decât prioritățile fiilor.
-Se poate observa că numele structurii de date provine din acești doi invarianți: ''tr-eap''.
+Se poate observa că numele structurii de date provine din acești doi invarianți: tr-eap.
 <note important>
 **Cum se menține echilibrul structurii?**
 De fiecare dată când un nod este inserat în arbore prioritatea lui este generată aleator (metodă similară cu cea folosită la randomized quick sort, în care la fiecare pas pivotul este generat aleator). Arborele va fi aranjat într-un mod aleator, bineînțeles, respectând cei doi invarianți. Cum numărul arborilor echilibrați este mai mare decât cel al arborilor rău echilibrați, șansa este destul de mică ca prioritățile generate aleator să nu mențină arborele echilibrat.
 </note>
-Demonstraţia complet teoretică asupra faptului că operațiile de bază au complexitatea O(logN) se poate găsi în [2].
-===== Structura unui nod =====
+Operațiile de bază au complexitatea O(logN).
+==== Structura unui nod ====
 Mai jos avem codul pentru structura nodului unui treap; se pot observa asemănările cu structura de arbore binar și cu cea de heap.
-<code c++ Treap.h>
+<code c treap.h>
-template <typename T> struct Treap {
+typedef struct treap_node_t treap_node_t;
-  T key;
+struct treap_node_t {
-  int priority;
+    /* left child */
-  Treap<T> *left, *right;
+    treap_node_t *left;
+    /* right child */
+    treap_node_t *right;
+    /* priority that will be randomly set at insertion */
+    int priority;
+    /* the key of the node which will also be used for sorting */
+    void *key;
+};
+typedef struct treap_t treap_t;
+struct treap_t {
+    /* root of the tree */
+    treap_node_t *root;
+    /* function used for comparing the keys */
+    int (*cmp)(const void *key1, const void *key2);
 };
 </code>
 <note important>
-Bineînțeles, tipul de date trebuie să permită o relație de ordine totală astfel încât oricare două elemente să poată fi comparate. Deci clasa T trebuie să implementeze operatorul **''<''**.
+Bineînțeles, tipul de date trebuie să permită o relație de ordine totală astfel încât oricare două elemente să poată fi comparate.
+Astfel, pentru fiecare Treap vom avea o funcție de comparare a cheilor care va întoarce o valoare:
+  * 0, dacă cele două chei sunt egale
+  * < 0, dacă cheia nou introdusă este mai mică conform modalității noastre de comparare
+  * > 0, dacă cheia nou introdusă este mai mare conform modalității noastre de comparare
+Observați că Treap-ul conține un pointer la o funcție de tip int. Aceea va fi funcția folosită pentru compararea cheilor, care vă fi oferită funcției ce creează arborele.
 </note>
 ===== Operații de bază =====
@@ Line 140: / Line 156: @@
 </code>
+<hidden>
 ===== Noțiuni de bază despre AVL Trees =====
@@ Line 171: / Line 188: @@
 Puteți urmări încă un exemplu [[https://www.gatevidyalay.com/avl-tree-avl-tree-example-avl-tree-rotation/|aici]].
+</hidden>
+<hidden>
 ===== Noțiuni de bază despre Red-Black Trees =====
@@ Line 187: / Line 206: @@
   *Fiecare drum simplu de la un nod la un descendent care este frunza contine acelasi numar de noduri negre.
-{{:sd-ca:laboratoare:800px-Red-black_tree_example.svg.png?600 }}
+</hidden>
 ===== Schelet =====
-{{sd-ca:laboratoare:lab_10:lab_10_schelet.zip|Schelet}}
+{{:sd-ca:laboratoare:lab10_2022.zip|Scheletul de laborator}}
 ===== Exerciții =====
 <note>
-Fiecare laborator va avea unul sau doua exerciții publice si un pool de subiecte ascunse, din care asistentul poate alege cum se formeaza celelalte puncte ale laboratorului.
+Trebuie să vă creați cont de [[https://lambdachecker.io | Lambda Checker]], dacă nu v-ați creat deja, pe care îl veți folosi la SD pe toată durata semestrului. Aveti grija sa selectati contestul corect la submit, si anume **[[https://beta.lambdachecker.io/contest/38 |Laborator 10 SD - update]]**
 </note>
-) **[4.5p]** Implementați următoarele funcții de bază pentru un treap:
+) **[5.5p]** Implementați următoarele funcții de bază pentru un treap:
-    * [1p] Căutare
+    * Căutare
-    * [2p] Rotiri stânga și dreapta
+    * Rotiri stânga și dreapta
-    * [1.5p] Inserare
+    * Inserare
-) **[1.5p]** Implementați și funcția de ștergere pentru un treap.
-) **[1p]** Realizați o parcurgere a treap-ului astfel încât să obțineți cheile sortate crescător/descrescător.
-) **[1.5p]** Folosiți acest [[https://www.cs.usfca.edu/~galles/visualization/AVLtree.html|tool]] pentru a vizualiza cum funcționează un AVL.
+) **[1.5p]** Realizați o parcurgere a treap-ului astfel încât să obțineți cheile sortate crescător/descrescător.
-) **[1.5p]** Folosiți acest [[https://www.cs.usfca.edu/~galles/visualization/RedBlack.html|tool]] pentru a vizualiza cum funcționează un Red-Black Tree
+Ambele task-uri sunt verificate in unica problema din contest.
-Pentru exercițiile 4 și 5 introduceți datele din exemplul oferit în laborator și încercați să preziceți la fiecare pas care va fi următoarea configurație.
 ===== Interviu =====

sd-ca/laboratoare/lab-10.1588093249.txt.gz · Last modified: 2020/04/28 20:00 by dorin_andrei.geman

Show page Old revisions

Media Manager Back to top

Differences

Laboratoare

Laboratoare din anii trecuti

Teme

Resurse