Differences

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

--- aa:lab:sol:3 [2025/10/19 14:18]
andreidarlau04 [Metoda Agregatelor]
+++ aa:lab:sol:3 [2025/10/19 21:59] (current)
andreidarlau04 [Algebraic Data Types]
@@ Line 80: / Line 80: @@
 (pentru insertion: 3 bani -> 1 inserare, 1 banut atribuit inseratiei curente, 1 banut atribuit altei inseratii din bucata copiata precedent)
-Idee de rezolvare: impartim array-ul in 2 bucati, bucata care se va copia la resize iar bucata care se va sterge fara impact. Cand facem o stergere, avem cost 1 pentru stergerea efectiva, dar atribuim un banut unui element (care nu se va sterge) pentru copierea sa ulterioara. Astfel, la timpul unui resize, vom avea banutii exacti necesari pentru copiere.
+Idee de rezolvare: impartim array-ul in 2 bucati:
+  * bucata care se va copia = elementele care raman dupa stergeri
+  * bucata elementelor care se sterg.
+Pentru fiecare operatie de stergere (cost 1), "plasam" un banut catre prima bucata a array-ului (cea care se va copia). In acest fel, la momentul copierii, fiecare element are deja banutul pregatit care ii acopera costul. Astfel, nu mai trebuit platit un cost suplimentar pentru copiere.
 ==== Metoda potentialelor ====
@@ Line 95: / Line 98: @@
   * c<sub>i</sub> = 1
   * ΔΦ = Φ(n - 1, m) - Φ(n, m):
-     * caz 1, n >= 2m: ΔΦ = 2n - 2 - m - 2n + m = -2 => ĉ<sub>i</sub> = -1
+    * caz 1: n > m/2 => ΔΦ = (2(n - 1) - m) - (2n - m) = -2
-     * caz 2, n < m: ΔΦ = m/2 - n - (m/2 - n - 1) = 1 => ĉ<sub>i</sub> = 2
+    * caz 2: n = m/2 => ΔΦ = (m/2 - (n - 1)) - (2n - m) = 1 + 3m/2 - 3n, dar n = 3m/2 => ΔΦ = 1 + 3m/2 - 3m/2 = 1
+    * caz 3: n < m/2 => ΔΦ = (m/2 - (n - 1)) - (m/2 - n) = 1
 Aflam ca pentru un load factor de peste 1/2 (suntem aproape de capacitatea maxima) avem cost amortizat -1, iar 2 daca ne apropiem de injumatatire.
+<note important>In operatiile de analiza amortizata, noi luam drept cost amortizat costul operatiilor mai "scumpe", neluand in calcul operatiile "ieftine", deci ĉ<sub>i</sub> = 2 in acest caz, nu -1. </note>
 . Cazul stergerii in care capacitatea se schimba:
@@ Line 105: / Line 111: @@
   * c<sub>i</sub> = 1 + n (deletion + copiere)
   * ĉ<sub>i</sub> = 1 + n + (1 - n) = 2
+===== Algebraic Data Types =====
+. <code>
+typedef struct list {
+    int e;
+    struct list *next;
+} *List;
+List Void() {
+    return NULL;
+}
+List Cons(int e, List list) {
+    List newElem = (List)malloc(sizeof(struct list));
+    newElem->e = e;
+    newElem->next = list;
+    return newElem;
+}
+</code>
+.
+<code>
+Size(Void) = 0
+Size(Cons(e, L)) = 1 + Size(L)
+</code>
+<code>
+Add(Void, x) = Cons(x, Void)
+Add(Cons(y, L), x) = Cons(y, Add(L, x)
+</code>
+<code>
+Append(Void, L) = L
+Append(Cons(x, L1), L2) = Cons(x, Append(L1, L2))
+</code>
+<code>
+Reverse(Void) = Void
+Reverse(Cons(x, L)) = Append(Reverse(L), Cons(x, Void))
+</code>
+Helper:
+<code>
+isNull(Void) = True
+isNull(Cons(x, L)) = False
+</code>
+.
+<code>
+bool isNull(List l) {
+    return l == NULL;
+}
+int size(List l) {
+    if (isNull(l))
+        return 0;
+    return 1 + size(l->next);
+}
+List add(List l, int x) {
+    if isNull(l))
+        return Cons(x, Void());
+    return Cons(l->e, add(l->next, x));
+}
+List append(List l1, List l2) {
+    if (isNull(l1))
+        return l2;
+    return Cons(l1->e, append(l1->next, l2));
+}
+List reverse(List l) {
+    if (isNull(l))
+        return Void();
+    return append(reverse(l->next), Cons(l->e, Void()));
+}
+</code>