Update Summary

notes/Summary.md

@@ -5,15 +5,22 @@ $$self.address: A[i] $$
 $$\longleftarrow prev.address \ | \ next.address\longrightarrow$$
 ### Stack
 First-In; Last-Out
+Add: "Push"
+Remove: "Pop"
 
+### Queue
+First-In; First-Out
+Add: "Enqueue"
+Remove: "Dequeue"
 ### Binary-Tree
 $$self.address : Value$$
-$$\rightarrow left.address : \rightarrow right.address$$
+$$\leftarrow left.address : \rightarrow right.address$$
 
 ### Graphen
 #### Adjazenzmatrix
 
-Von *Zeile* nach *Spalte*
+Von *Zeile* nach *Spalte* lesen. Wert vom Element ist das Gewicht dieser Verbindung, wenn alle $Gewichte = 1$, dann ungewichtet.
+Wenn Symmetrische Matrix, dann Ungerichtet.
 
 $$
 \newcommand\T{\rlap{\text{to}}}
@@ -31,20 +38,16 @@ $$
 \end{array}
 $$
 #### Adjazenzliste
-Von Spaltenheader zu allen elementen in der Spalte
-
+Der **Header-Knoten**, geht zu allen Knoten in der Spalte.
 $$
 \begin{array}
  & 1 & 2 & 3 & 4 \\
 \hline
 2 & 3 & 2 & 1 \\
 4 \\
-
 \end{array}
 $$
 
-
-
 ## 2. Skipliste, Binary-Search-Tree, Shellsort
 
 ### Skipliste
@@ -58,13 +61,10 @@ $$
 \text{Layer 0:} \quad H \rightarrow E_1 \rightarrow E_2 \rightarrow E_3 \rightarrow E_4 \rightarrow E_5 \rightarrow \text{NIL}
 \end{array}
 $$
-
-
-
 ### Binary Search Tree
 >Linker Teilbaum *kleiner*, rechter Teilbaum *größer*
 
-$$Tiefe = Max(\text{Anzahl Kanten})$$
+$$Tiefe = Max(\text{Anzahl Kanten nach unten})$$
 
 **Suchen**
 Richtung? -> Vergleich von beiden Kinder knoten
@@ -123,10 +123,9 @@ $$
 $$
 $$Parent: floor\left(\frac{2i}{2}\right)$$
 
-
 ### Max/Min-Heap-Reparieren:
-Man itereriert durch alle Element, ausgeschlossen die Blätter.
-Folgendes Schema:
+Man iteriert durch alle Elemente, außer die Blätter.
+Folgendes Schema: 
 >**Breadth-First**: Man startet dem Letzten Element (Visuell unten rechts), das **Kinder** hat. Dann nach Links bis ende der Ebene und dann nach oben.
 
 Das ist nur das Iterieren! Noch Reparieren!
@@ -156,13 +155,14 @@ Jedes Element das man anschaut wird dann *down-geshifted*. Im grunde Rekursives
 ```
 
 2. (Abbruchbedingung), Gehe zum nächsten Element ...
-	1. Max-Heap: Wenn $element$ ist das **größte** von den drei: $max([e, c1, c2]) = e$
-	2. Min-Heap: Wenn $element$ ist das **kleinste** von den drei: $min([e, c1, c2]) = e$
+	1. Max-Heap: Wenn $element$ das **größte** von den drei ist, i.e. $max([e, c1, c2]) = e$
+	2. Min-Heap: Wenn $element$ das **kleinste** von den drei ist, i.e. $min([e, c1, c2]) = e$
 3. Wenn nicht, dann *tausche* mit dem größten (Max-Heap) / kleinsten (Min-Heap) der drei.
-4. Wiederhole, bis Abbruchbedingung erreicht, oder ende vom Baum, bzw. ganz unten.
+4. Wiederhole, bis Abbruchbedingung erreicht, oder am ende vom Baum, bzw. ganz unten.
 
 #### Heap-Sort
-1. Unten Rechts (Letztes Element im Heap-Array, ist ein Blatt btw.), mit dem ersten (Root) Tauschen.
+0. (Vorrausgesetzt ist ein Valider-Heap)
+1. Unten Rechts (Letztes Element im Heap-Array, ist ein Blatt btw.), mit dem ersten (Root) Tauschen, und es (bzw. previous Root) vom Heap entfernen.
 2. Heap Reparieren indem man das neue Root element **down-shifted**, bis es wieder am richtigen platz ist, siehe vorherige erklärung.
 
 ## 4. Balancierte Bäume
@@ -172,17 +172,16 @@ Max. Tiefe: $log_2(n)$
 
 Jeder Knoten bekommt einen *Balancefaktor*, dieser Entspricht der Tiefe vom rechten, minus der Tiefe des linken Teilbaumes.
 > Tiefe von einem (Teil)Baum, ist einfach die maximale Anzahl Kanten nach unten. 
-$$BAL(N) = T(u_2) - T(u_1)$$
+$$BAL(Knoten) = T(u_2) - T(u_1)$$
 
-Dieser sollte $$-1 \leq BAL(N)\leq 1$$
+Dieser sollte entweder $\{-1; 0; 1\}$
 ## 5. Reelwertige Optimierung in einer Dimension
-
 Bisektion mit Sampling. I.e. man macht Bisektion mehrere Male, mit anderen Intervallen.
 Also z.B. komplettes intervall ist $I=[1, 10]$, und dort sind vielleicht 4 lokale Minima.
 Dann macht man halt $$I_1=[1, 4], I_2=[4,7], I_3=[7, 10]$$
 Und führt auf den Intervallen Bisektion aus und nimmt das beste Ergebnis.
 
-Ganz Normal Newton Verfahren mit Schrittweitensteuerung.
+Bei Newton: Einfach ganz Normal Newton mit Schrittweitensteuerung.
 
 ### Straf- (Penalty-) Funktionen
 
@@ -223,9 +222,8 @@ Je größer $\beta$, desto stärker die Strafe ⇒ höhere Genauigkeit am Rand,
 #### Beispiel
 
 $$
-\text{Min } e^x, \qquad 0 \le x \le 1.
+\text{Min } f(x), \qquad 0 \le x \le 1.
 $$
-
 Strafterme  
 
 $$
@@ -235,29 +233,30 @@ $$
 Gesamtfunktion  
 
 $$
-\Phi(x)=e^x + p_1(x) + p_2(x).
+\Phi(x)=f(x) + p_1(x) + p_2(x).
 $$
 
 *Ableitungen einsetzen → Newton-Iteration mit $\Phi$ anstelle von $f$.*
 
-> **Merke:** Die Wahl von $\beta$ ist ein Kompromiss zwischen Genauigkeit und numerischer Stabilität.
-
-
 ## 6. Bivariate Lineare Programmierung
 1. Nebenbedingungen Aufbauen (Ungleichungen)
-2. Nach $y$ auflösen und einzeichnen (Aufpassen)
-3. Lösung finden
+2. Nach $y$ auflösen und einzeichnen (Aufpassen auf Umformung)
+3. Lösung finden, indem die zu Optimierte Funktion folgendermaßen umgestellt wird.
 
->Werden beide Seiten einer Ungleichung mit einer negativen Zahl multipliziert oder durch eine negative Zahl dividiert, muss das Ungleichheitszeichen umgekehrt werden (z.B. aus $<$ wird $>$)
 
+$$min(x-y) \ |\ x=x_1, y=x_2$$
+$$x-y=c \Rightarrow y = x-c$$
+$$\lim_{c \ \rightarrow\ -\infty} \Rightarrow y=x+\infty  $$
+*Wenn $max(c)$, dann muss limes gegen $+\infty$ gehen!*
+
+Das sollte dann ne Gerade geben, $c$ ist normalerweise nicht $\infty$, da die *Feasable-Region* es beschränkt, dann nimmt man den Rand oder Eckpunkt. 
+
+>**Achtung**: Werden beide Seiten einer Ungleichung mit einer negativen Zahl multipliziert oder durch eine negative Zahl dividiert, muss das Ungleichheitszeichen umgekehrt werden (z.B. aus $<$ wird $>$)
 
 ## 7. Reelwertige Optimierung in N Dimensionen
-
 $$f(x_1, x_2,..., x_n)$$
-
 $$ f'(x) \longrightarrow \nabla f(x)$$
 $$f''(x) \longrightarrow H$$
-
 ### 7.2 Downhill-Simplex
 
 Besteht aus n+1 Punkten