Jonas_Jones/uni-tex-assignments
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

added algo1 assignments 2-3 and 5-8
Some checks failed
build-latex / build (push) Has been cancelled
Details

Browse source
This commit is contained in:
Jonas_Jones 2025-06-20 22:47:54 +02:00
parent b5ef7d1944
commit 3076cc12e6
6 changed files with 1753 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

317
algo1/assignment2/main.tex Normal file
View file

@ -0,0 +1,317 @@
\documentclass[a4paper]{article}
%\usepackage[singlespacing]{setspace}
\usepackage[onehalfspacing]{setspace}
%\usepackage[doublespacing]{setspace}
\usepackage{geometry} % Required for adjusting page dimensions and margins
\usepackage{amsmath,amsfonts,stmaryrd,amssymb,mathtools,dsfont} % Math packages
\usepackage{tabularx}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{subcaption}
\usepackage{float}
\usepackage[table,xcdraw]{xcolor}
\usepackage{changepage,titlesec,fancyhdr} % For styling Header and Titles
\pagestyle{fancy}
\usepackage{enumerate} % Custom item numbers for enumerations
\usepackage[ruled]{algorithm2e} % Algorithms
\usepackage[framemethod=tikz]{mdframed} % Allows defining custom boxed/framed environments
\usepackage{listings} % File listings, with syntax highlighting
\lstset{
basicstyle=\ttfamily, % Typeset listings in monospace font
}
\usepackage[ddmmyyyy]{datetime}
\geometry{
paper=a4paper, % Paper size, change to letterpaper for US letter size
top=2.5cm, % Top margin
bottom=3cm, % Bottom margin
left=2.5cm, % Left margin
right=2.5cm, % Right margin
headheight=25pt, % Header height
footskip=1.5cm, % Space from the bottom margin to the baseline of the footer
headsep=1cm, % Space from the top margin to the baseline of the header
%showframe, % Uncomment to show how the type block is set on the page
}
\lhead{ALGO-1\\Sommersemester 2024}
\chead{\bfseries{Übungsblatt 2}\\}
\rhead{7987847\\Jonas Werner}
\begin{document}
\section*{Aufgabe 2.1}
Verwenden Sie das Mastertheorem, um das Wachstum folgender rekursiver Funktionen T (n) asym-
ptotisch exakt zu bestimmen. Es kann angenommen werden, dass T (1) konstant und n eine Potenz
von b ist.
\subsection*{a)}
\[ T(n) = 4 \cdot T\left(\frac{n}{2}\right) + n \log^2 n \]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 4$
\item $b = 2$
\item $t(n) = n \log^2 n$
\item $2 > k > 1$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_2 4 = 2 > k = 1 \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (a) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(n^{\log_{b}a}\right) = \theta\left(n^2\right)\]
\subsection*{b)}
\[ T(n) = 3 \cdot T\left(\frac{n}{9}\right) + \sqrt{12n} \]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 3$
\item $b = 9$
\item $t(n) = \sqrt{12n}$
\item $k = \frac{1}{2}$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_9 3 = \frac{1}{2} = k = \frac{1}{2} \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (b) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(n^{\log_{b}a} \cdot \log_{b}n \right) = \theta\left(n^{\frac{1}{2}} \cdot \log_{9}n \right) = \theta\left(\sqrt{n} \cdot \log_{9}n \right)\]
\subsection*{c)}
\[ T(n) = 64 \cdot T\left(\frac{n}{16}\right) + n\sqrt[4]{n} \]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 64$
\item $b = 16$
\item $t(n) = n \sqrt[4]{n}$
\item $k = 1$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_2 4 = \frac{3}{2} > k = 1 \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (a) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(n^{\log_{b}a}\right) = \theta\left(n^{\frac{3}{2}}\right)\]
\subsection*{d)}
\[ T(n) = 4 \cdot T\left(0.99n\right) + 1.01n \]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 4$
\item $b = \frac{1}{0.99}$
\item $t(n) = 1.01n$
\item $k = 1$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_{\frac{1}{0.99}} 4 \approx 137.935 > k = 1 \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (a) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(n^{\log_{b}a}\right) = \theta\left(n^{\log_{(\frac{1}{0.99})}4}\right) \approx \theta\left(n^{137.935}\right)\]
\break
\section*{Aufgabe 2.2}
Wir betrachten den folgenden Algorithmus für eine ganzzahlige Eingabe $n > 0$:
\begin{verbatim}
x = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= f(i); j++) {
x = x + 1;
}
}
\end{verbatim}
Bestimmen Sie für jede der folgenden Funktionen $f(i)$ den Wert der Variable $x$ nach Ende des
Algorithmus exakt.
\subsection*{a)}
$f(i) = \frac{c}{n}$ für ein $c \in \mathbb{N}$.
$x = \mathlarger{\mathlarger{\sum}}_{i=0}^{n}\frac{c}{n} = c \cdot \frac{n}{n} = c$
\subsection*{b)}
$f(i) = \binom{n}{i}$
$x = \mathlarger{\mathlarger{\sum}}_{i = 1}^{n} \frac{n!}{(n - i) \cdot i!} = 2^n - 1$ weil $\mathlarger{\mathlarger{\sum}}_{i = 0}^{n} \frac{n!}{(n - i) \cdot i!} = 2^n$ und $\binom{n}{0} = 1$
\subsection*{c)}
$f(i) = \frac{n}{3^i}$
$x = \mathlarger{\mathlarger{\sum}}_{i = 1}^{\log{n}}\frac{n}{3^i} = n \cdot \mathlarger{\mathlarger{\sum}}_{i = 1}^{\log{n}}\frac{1}{3^i}$
\break
\section*{Aufgabe 2.3}
Geben Sie für folgende rekursive Gleichungen eine $geschlossene Form$ an und beweisen Sie deren
Korrektheit mittels Induktion.\\
\subsection*{a)}
$T(2) = 2, T(n) = T(n - 2) + n$ für $n = 2k, k \in \mathbb{N}, k > 1$\\
$T(n) = T(n - 2) + n = n + (n - 2) + (n - 4) + ... + 2 = 2 + 4 + 6 + ... + n$
$\mathlarger{\mathlarger{\sum}}_{i = 1}^{n/2}2i = 2 \cdot \mathlarger{\mathlarger{\sum}}_{i = 1}^{n/2}i = 2 \cdot \frac{1}{2} \cdot \frac{n}{2} \cdot \left(\frac{n}{2} + 1\right) = \frac{n \cdot \left(n + 2\right)}{4}$\\
\begin{proof}[\unskip\nopunct]
Beweis durch Vollständige Induktion:\\
Induktionsanfang ($k = 2$):
$T(n) = T(2k) \Rightarrow T(2 \cdot 2) = \frac{4 \cdot \left(4 + 2\right)}{4} = 6$\\
Induktionsvorraussetzung:
$T(n) = \frac{n \cdot \left(n + 2\right)}{4}$, $T(2) = 2$\\
Induktionsschritt ($k \Rightarrow k + 1$):
$T(2\cdot(k + 1)) = 2 \cdot \mathlarger{\mathlarger{\sum}}_{i = 1}^{(2k + 2)/2}i = 2 \cdot \left(\mathlarger{\mathlarger{\sum}}_{i = 1}^{k}i + (2k + 2)\right) = \frac{2k \cdot \left(2k + 2\right)}{4} + 2k + 2 = \frac{2k \cdot \left(2k + 2\right)}{4} + \frac{8k + 8}{4} = \frac{(2k)^2 + 4k + 8k + 12}{4} = \frac{(2k + 2)(2k + 4)}{4}$
\end{proof}
\subsection*{b)}
$T(2) = 2, T(n) = 2 \cdot T(\sqrt{n})$ für $n = 2^{2^k}, k \in \mathbb{N}, k > 0$\\
$T(n) = 2 \cdot T(\sqrt{n} = 2 \cdot T\left(2^{2^{k - 1}}\right) = 2 \cdot ... \cdot T\left(2^{2^{k - k}}\right) = 2^k \cdot T(2) = 2^{k + 1}$
\begin{proof}[\unskip\nopunct]
Beweis durch Vollständige Induktion:\\
Induktionsanfang ($k = 1$):
$T(n) = 2^{2 + 1} = 8$\\
Induktionsvorraussetzung:
$T(n) = 2^{k + 1}$, $T(2) = 2$\\
Induktionsschritt ($k \Rightarrow k + 1$):
$T(k + 1) = T\left(2^{2^{k + 2}}\right) = 2 \cdot T\left(2^{2^{k + 1}}\right) = 2 \cdot 2^{k + 1} = 2^{k + 2}$
\end{proof}
\subsection*{c)}
$T(1) = 1, T(n) = n \cdot T(\frac{n}{2})$, für $n = 2^k, k \in \mathbb{N}, k > 0$\\
$T\left(2^k\right) = 2^k \cdot T\left(2^{k-1}\right) = 2^k \cdot 2^{k - 1} \cdot T\left(2^{k - 2}\right) = 2^k \cdot 2^{k - 1} \cdot ... \cdot 2^{k - k} = \frac{k(k + 1)}{2} \cdot T(1) = \frac{k(k + 1)}{2}$
\begin{proof}[\unskip\nopunct]
Beweis durch Vollständige Induktion:\\
Induktionsanfang ($k = 1$):
$T(n) = \frac{k1(1 + 1)}{2} = 1$\\
Induktionsvorraussetzung:
$T(2^k) = 2^{\left(\frac{k(k + 1)}{2}\right)}$, $T(2) = 2$\\
Induktionsschritt ($k \Rightarrow k + 1$):
$T(k + 1) = T\left(2^{k + 1}\right) = 2^{k + 1} \cdot T(2^k) = 2^k \cdot 2^{\left(\frac{k(k + 1)}{2}\right)} = 2^{\left(\frac{k(k + 1)}{2}\right) + (k + 1)} = 2^{\left(\frac{k(k + 1) + 2k + 2}{2}\right)} = 2^{\left(\frac{k^2 + 3k + 2}{2}\right)} = 2^{\left(\frac{(k + 1)(k + 2)}{2}\right)}$
\end{proof}
\break
\section*{Aufgabe 2.4}
Wir betrachten die folgenden Funktionen.
\begin{figure}[H] % This forces the figure to appear exactly here in the document
\begin{subfigure}[b]{0.4\textwidth}
\begin{verbatim}
int mod(int x, int y) {
while(x >= y)
x = x - y;
return x;
}
\end{verbatim}
\end{subfigure}
\hfill
\begin{subfigure}[b]{0.4\textwidth}
\begin{verbatim}
int ggT(int a, int b) {
if(a == 0) {
return b;
} else {
return ggT(mod(b, a), a);
}
}
\end{verbatim}
\end{subfigure}
\end{figure}
\subsection*{a)}
Begründen Sie, warum $ggT$ für positive ganze Zahlen $a$ und $b$ terminiert.\\
Nach jedem Rekursionsaufruf ist $b > a$ und die Reihenfolge der beiden Zahlen wird vertauscht, sodass nach dem jeweils nächsten Rekursionsschritt wieder $b > a$ wird, aber mit vertauschten Werten, sodass beide Werte kleiner werden bis einer der beiden gleich 0 wird. Dann endet die Rekursion.
\subsection*{b)}
Zeigen Sie, dass $a + (b \mod{a}) \leq \frac{2}{3} \cdot (a + b)$, falls $0 < a \leq b.$\\
Sei $r = b \mod a$\\
$\Rightarrow b = ka + r$ für $k \geq 1$
\begin{align*}
a + r &\leq \frac{2}{3} \cdot (a + b) \\
a + r &\leq \frac{2}{3} \cdot ((k + 1)a + r)\\
3a + 3r &\leq 2(k + 1)a + 2r\\
0 &\leq 2ka − (a + r)\\
0 &\leq 2ka − 2a
\end{align*}
Da $k \geq 1$ gilt die Ungleichung und $a + (b \mod{a}) \leq \frac{2}{3} \cdot (a + b)$ ist bewiesen.
\subsection*{c)}
Bestimmen Sie die Worst-Case-Laufzeit $T(n)$ der Funktion $ggT$. Definieren Sie dafür zunächst
die Variable $n$ in Abhängigkeit von $a$ und $b$ und stellen Sie eine Rekursionsgleichung auf.\\
Beim Aufruf mit $mod(n, 1)$ wird die mod-Funktion n viele Schritte machen, weil in jeder Schleifenausführung $n - 1$ gerechnet wird, bis $n < 1$, also gleich 0 ist.
\subsection*{d)}
In Aufgabenteil $b)$ haben wir $a \leq b$ vorausgesetzt. Ändert sich $T(n)$ wenn wir $a \leq b$ nicht
mehr fordern? Begründen Sie Ihre Antwort.\\
Wenn $a \leq b$ nicht mehr vorrausgesetzt ist, also $a > b$ sein kann, so wird die mod-Funktion mit $a > b$ aufgerufen und die while-Schleife direkt übersprungen weil die $a = y, b = x$ und die Vorraussetzung des Schleifenaufrufs $x >= y$ nicht erfüllt ist. Somit kommt ein Rekursionsaufruf von $ggT()$ dazu, indem die Reihenfolge der beiden Zahlen "berichtigt", also in sofern angepasst wird, dass die Funktion ab dann normal ausgeführt wird, so wie als würde $a \leq b$ gelten.
\end{document}

282
algo1/assignment3/main.tex Normal file
View file

@ -0,0 +1,282 @@
\documentclass[a4paper]{article}
%\usepackage[singlespacing]{setspace}
\usepackage[onehalfspacing]{setspace}
%\usepackage[doublespacing]{setspace}
\usepackage{geometry} % Required for adjusting page dimensions and margins
\usepackage{amsmath,amsfonts,stmaryrd,amssymb,mathtools,dsfont} % Math packages
\usepackage{tabularx}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{subcaption}
\usepackage{float}
\usepackage[table,xcdraw]{xcolor}
\usepackage{tikz-qtree}
\usepackage{changepage,titlesec,fancyhdr} % For styling Header and Titles
\pagestyle{fancy}
\usepackage{enumerate} % Custom item numbers for enumerations
\usepackage[ruled]{algorithm2e} % Algorithms
\usepackage[framemethod=tikz]{mdframed} % Allows defining custom boxed/framed environments
\usepackage{listings} % File listings, with syntax highlighting
\lstset{
basicstyle=\ttfamily, % Typeset listings in monospace font
}
\usepackage[ddmmyyyy]{datetime}
\geometry{
paper=a4paper, % Paper size, change to letterpaper for US letter size
top=2.5cm, % Top margin
bottom=3cm, % Bottom margin
left=2.5cm, % Left margin
right=2.5cm, % Right margin
headheight=25pt, % Header height
footskip=1.5cm, % Space from the bottom margin to the baseline of the footer
headsep=1cm, % Space from the top margin to the baseline of the header
%showframe, % Uncomment to show how the type block is set on the page
}
\lhead{ALGO-1\\Sommersemester 2024}
\chead{\bfseries{Übungsblatt 3}\\}
\rhead{7987847\\Jonas Werner}
\begin{document}
\section*{Aufgabe 3.1}
Wir kennen aus der Vorlesung die Datenstrukturen $Stack$, $Queue$ und $Array$. Im Folgenden betrachten
wir einige Anwendungen und Modifikationen dieser Datenstrukturen.
\subsection*{a)}
Ein String sei wohlgeformt, wenn jede nach rechts geöffnete Klammer - {, [, ( - auch durch eine
nach links geöffnete Klammer des gleichen Typs - }, ], ) - an passender Stelle geschloßen wird.
Beispiele:
\begin{align*}
"\{[]()()\}" &\Rightarrow \text{wohlgeformt}\\
"\{(\})" &\Rightarrow \text{nicht wohlgeformt}
\end{align*}
Zeigen Sie, wie mithilfe eines Stacks geprüft werden kann, ob ein gegebener String wohlgeformt
ist.
\begin{verbatim}
function ist_wohlgeformt(string) {
while string not empty {
elem = last element in string and remove it from list
if elem is the opposite bracket to string[-1] {
remove string[-1]
} else {
stack.push(elem)
}
}
if stack is empty {
return true;
}
return false;
}
\end{verbatim}
Der Vergleich der Klammerpaare kann in einem Dictionary $hardcoded$ werden.
\subsection*{b)}
Zeigen Sie, wie eine Queue erweitert werden kann, um folgende Operation mit Laufzeit O(1)
zu unterstützen:
\begin{itemize}
\item avg(): Gebe den Durchschnitt der in der Queue enthaltenen Elemente zurück.
\end{itemize}
Die Queue kann als Tupel mit der Queue und einem weiteren Tupel mit Länge und Summe der Summe der Elemente dargestellt werden:
\begin{verbatim}
queue = (Queue, (Länge, Summe))
function enqueue(queue, elem) {
queue[0].enqueue(elem)
queue[1][0] += 1
queue[1][1] += elem
return queue
}
function dequeue(Queue) {
elem = queue[0].dequeue()
queue[1][0] -= 1
queue[1][1] -= elem
return queue
}
function avg(queue) {
return queue[1][1] / queue[1][0]
}
\end{verbatim}
\subsection*{c)}
ntwerfen Sie eine Datenstruktur Multiset auf Basis eines Arrays A. Die Datenstruktur sollte
Elemente $x \in {1, 2, . . . , m}$ speichern und folgende Operationen unterstützen:
\begin{itemize}
\item insert($x$): Füge einen Eintrag mit Wert $x$ in A ein
\item remove($x$): Entferne einen Eintrag mit Wert $x$ aus A (falls vorhanden).
\end{itemize}
Die Operation insert($x$) soll dabei in Zeit $\mathcal{O}(1)$ (amortisiert1), und die Operation remove($x$) in
Zeit $\mathcal{O}(l_x)$ laufen, wobei $l_x$ die Anzahl der Vorkommen von $x$ in A ist. Zudem soll bei insgesamt $n$ enthaltenen Elementen der Speicherverbrauch höchstens $\mathcal{O}(max(n, m))$ sein.
\begin{figure}[H] % This forces the figure to appear exactly here in the document
\begin{subfigure}[b]{0.4\textwidth}
\begin{verbatim}
function insert(array, elem) {
array.append(elem)
return array
}
\end{verbatim}
\end{subfigure}
\hfill
\begin{subfigure}[b]{0.4\textwidth}
\begin{verbatim}
function remove(array, x) {
for elem in array {
if elem == x {
array.remove(x)
}
}
}
\end{verbatim}
\end{subfigure}
\end{figure}
\break
\section*{Aufgabe 3.2}
Betrachten Sie den geordneten Baum B.
Geben Sie an, in welcher Reihenfolge die Knoten in B in einem
\subsection*{a)}
Präorder-Durchlauf:
k, r, o, a, l, g, i, i, m, t, h
\subsection*{b)}
Inorder-Durchlauf:
a, l, g, o, r, i, i, t, m, h
\subsection*{c)}
Postorder-Durchlauf:
a, l, g, o, r, i, t, h, m, i, k
\subsection*{d)}
Ein anderer Baum $B^{\prime}$ wurde mit Postorder traversiert. Die resultierende Reihenfolge der Besuche ist A, L, G, O, 1. Geben Sie einen möglichen Baum $B^{\prime}$ an, der diese Reihenfolge produziert. Begründen Sie außerdem, ob $B^{\prime}$ eindeutig ist oder nicht.
\begin{figure}[H] % This forces the figure to appear exactly here in the document
\begin{subfigure}[b]{0.4\textwidth}
\begin{tikzpicture}
\tikzset{every tree node/.style={align=center, anchor=north}}
\Tree [.1
[.A ]
[.L ]
[.G ]
[.O ]
]
\end{tikzpicture}
\end{subfigure}
\hfill
\begin{subfigure}[b]{0.4\textwidth}
\begin{tikzpicture}
\tikzset{every tree node/.style={align=center, anchor=north}}
\Tree [.1
[.O
[.G
[.L
[.A ]
]
]
]
]
\end{tikzpicture}
\end{subfigure}
\end{figure}
Die beiden Beispiele ergeben A, L, G, O, 1 in Postorder und $B^{\prime}$ ist nicht eindeutig.
\break
\section*{Aufgabe 2.3}
Ein Binärbaum hat die Eigenschaft, dass jeder Knoten höchstens 2 Kinder besitzt. Dieser wird als vollständig bezeichnet, wenn zusätzlich gilt, dass alle Blätter die gleiche Tiefe haben und jeder innere Knoten genau 2 Kinder besitzt. Beweisen oder widerlegen Sie folgende Aussagen:
\subsection*{a)}
Wenn $T$ ein Binärbaum mit $\left|V\right|$ Knoten ist, so besitzt $T$ genau $\left|V\right| - 1$ Kanten.
\subsection*{b)}
Jeder Binärbaum der Tiefe $t$ besitzt $^{t+1} - 1$ Knoten.
Gegenbeispiel: Wenn der Binärbaum nicht vollständig ist
\subsection*{c)}
Vollständige Binärbäume mit $\left|V\right|$ Knoten haben Tiefe $\log_2(\left|V\right| + 1) - 1$.
\begin{proof}[\unskip\nopunct]
uwu
\end{proof}
\break
\section*{Aufgabe 3.4}
Gegeben sei ein ungerichteter gewurzelter Baum $B = (V, E$) in Kind-Geschwister-Darstellung. Die Wurzel sei r.
Entwerfen Sie einen möglichst effizienten Algorithmus, der die Länge eines längsten einfachen Weges in B berechnet. Geben Sie Ihren Algorithmus in Pseudocode an, analysieren Sie seine Laufzeit und begründen Sie seine Korrektheit.
\begin{verbatim}
function longest_path(node) {
if node.child and node.sibling are none {
height = temp_longest_path = 0
return (height, temp_longest_path)
} else if node.child is none but node.sibling exists {
height, temp_longest_path = longest_path(node.sibling)
if height == temp_longest_path == 0 {
height += 1
temp_longest_path += 1
}
} else if node.sibling is none but node.child exists {
height, temp_longest_path = longest_path(node.child)
height += 1
temp_longest_path += 1
} else if node.child and node.sibling exist {
height_c, temp_longest_path_c = longest_path(node.child)
height_s, temp_longest_path_s = longest_path(node.sibling)
height = max(height_s, height_c + 1)
path_parent = height_c + height_s + 3
temp_longest_path = max(path_c, path_s, path_parent)
}
return (height, temp_longest_path)
}
\end{verbatim}
Die Laufzeit des Algorithmus ist $\mathcal{O}(n^2)$, da es sich um eine Baumrekursion handelt und im Worst-case-Szenario die Funktion pro Rekursionsaufruf zwei mal Aufgerufen wird.\\
Bei den rekursiven Aufrufen kann es bei den Knoten zu den folgenden Szenarien kommen:
\begin{itemize}
\item weder Kind noch Geschwister: der Knoten ist ein Blatt und der Elternknoten hat nur ein Kind. Die Höhe ist dann 0 und der längste Pfad über diesen Knoten bisher auch 0.
\item kein Kind aber ein Geschwister: der Konten ist ein Blatt aber es geht beim Geschwister noch weiter. Da der Knoten selbst, als auch sein Geschwister mit dem gleichen Elternknoten verbunden ist, spielt es keine Rolle ob der Teilbaum des Geschwisterknoten am Knoten selbst sein kann. Wir übernehmen daher einfach nur die Werte die die Rekursion über den Geschwisterknoten zurückgibt.
\item Wenn Kind aber kein Geschwister: die Anordnung der Knoten ist hier in einer einfachen Kette. Wir erhöhen die Höhe um 1 und den längsten Pfad um 1
\item Wenn Kind und Geschwister: Der Entscheidungsfall. Hier treffen 2 Äste des Baums zusammen und der Algorithmus muss entscheiden was übernommen wird. Die Höhe ist einfach berechnet. Sie ist die größere Höhe der beiden Höhen $height\_c$ und $height\_s$. Der längste Weg ist komplexer. Wir berechnen hier den Weg vom tiefesten Blatt des Kind-Teilbaums zum tiefesten Blatt des Geschwister-Teilbaums. Da Zwischen dem Knoten selbst und dem Geschwisterknoten jedoch keine Kante vorliegt, müssen wir den Elternknoten dazunehmen. Wenn es einen Geschwisterknoten gibt, so gibt es automatisch auch einen Elternknoten. Somit addieren wir die beiden Höhen. Der Elternknoten muss jedoch auch noch im Weg miteinbezogen werden. Dei extra-Kanten sind dann vom Kind zum Knoten selbst, vom Knoten selbst zum Elternknoten und vom Elternknoten zum Geschwister. Daher die Konstante 3.
\end{itemize}
\break
\end{document}

279
algo1/assignment5/main.tex Normal file
View file

@ -0,0 +1,279 @@
\documentclass[a4paper]{article}
%\usepackage[singlespacing]{setspace}
\usepackage[onehalfspacing]{setspace}
%\usepackage[doublespacing]{setspace}
\usepackage{geometry} % Required for adjusting page dimensions and margins
\usepackage{amsmath,amsfonts,stmaryrd,amssymb,mathtools,dsfont} % Math packages
\usepackage{tabularx}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{subcaption}
\usepackage{float}
\usepackage[table,xcdraw]{xcolor}
\usepackage{tikz-qtree}
\usepackage{changepage,titlesec,fancyhdr} % For styling Header and Titles
\pagestyle{fancy}
\usepackage{array}
\usepackage{enumerate} % Custom item numbers for enumerations
\usepackage[ruled]{algorithm2e} % Algorithms
\usepackage[framemethod=tikz]{mdframed} % Allows defining custom boxed/framed environments
\usepackage{listings} % File listings, with syntax highlighting
\lstset{
basicstyle=\ttfamily, % Typeset listings in monospace font
}
\usepackage[ddmmyyyy]{datetime}
\geometry{
paper=a4paper, % Paper size, change to letterpaper for US letter size
top=2.5cm, % Top margin
bottom=3cm, % Bottom margin
left=2.5cm, % Left margin
right=2.5cm, % Right margin
headheight=25pt, % Header height
footskip=1.5cm, % Space from the bottom margin to the baseline of the footer
headsep=1cm, % Space from the top margin to the baseline of the header
%showframe, % Uncomment to show how the type block is set on the page
}
\lhead{ALGO-1\\Sommersemester 2024}
\chead{\bfseries{Übungsblatt 5}\\}
\rhead{7987847\\Jonas Werner}
\begin{document}
\section*{Aufgabe 5.1}
Bestimmen Sie für jeden leeren Eintrag aus der folgenden Tabelle das richtige Verhältnis zwischen
$f$ und $g$. Eine Begründung ist nicht nötig.\\
\begin{tabular}{| c | c | c | c | c | c |}
\hline
& $g(n) = 3n$ & $g(n) = n \sqrt{n}$ & $g(n) = 1$ & $g(n) = log^2(n)$ & $g(n) = \binom{n}{2}$ \\
\hline
$f(n) = n^2$ & $g = o(f)$ & $g = o(f)$ & $g = o(f)$ & $g = o(f)$ & $g = \theta(f)$ \\
\hline
$f(n) = \sqrt{n}$ & $f = o(g)$ & $f = o(g)$ & $g = o(f)$ & $g = o(f)$ & $f = o(g)$ \\
\hline
$f(n) = log(log(n))$ & $f = o(g)$ & $f = o(g)$ & $g = o(f)$ & $f = o(g)$ & $f = o(g)$ \\
\hline
\end{tabular}
\section*{Aufgabe 5.2}
\subsection*{a)}
\[ T(n) = T\left(\frac{n}{3}\right) + n\]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 1$
\item $b = 3$
\item $t(n) = n $
\item $k = 1$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_3 1 = 0 < k = 1 \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (c) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(t(n)\right) = \theta\left(n\right)\]
\break
\subsection*{b)}
\[ T(n) = 2 \cdot T\left(\frac{n}{4}\right) + 2 \cdot \sqrt{n} + log^3n \]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 2$
\item $b = 4$
\item $t(n) = 2 \cdot \sqrt{n} + \log^3 n$
\item $k = \frac{1}{2}$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_4 2 = \frac{1}{2} = k \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (b) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(n^{log_b a} \cdot \log n\right) = \theta\left(n^{log_4 2} \cdot \log n\right) = \theta\left(\sqrt{n} \cdot \log n\right)\]
\subsection*{c)}
\[ T(n) = 10 \cdot T\left(\frac{n}{3}\right) + n^2\log_2n \]
Daraus lassen sich folgende Werte ablesen:
\begin{itemize}
\item $a = 10$
\item $b = 3$
\item $t(n) = n^2\log_2n$
\item $1 < k < 2$
\end{itemize}
Damit berechnen wir:
\[ \log_b a = \log_3 10 \approx 2.1 > k \]
Daraus folgt:
\[
\Rightarrow \text{Es tritt Fall (a) ein.}
\]
Somit gilt die folgende Gleichung:
\[ T(n) = \theta\left(n^{\log_{b}a}\right) = \theta\left(n^{\log_{3}10}\right)\]
\break
\section*{Aufgabe 5.3}
Gegeben ist eine Datenstruktur für einfach verkettete Listen, wobei die Listenelemente ein Feld $next$
mit dem Zeiger auf das nächste Element und ein Feld $data$ mit dem Schlüssel haben. Die Elemente der
Liste sind absteigend nach $data$ sortiert. Beschreiben Sie für jede der folgenden Aufgabenstellungen
einen möglichst effizienten Algorithmus in Pseudocode und analysieren Sie die Worst-Case Laufzeit:
\subsection*{a)}
Entferne Elemente mit gleichem Schlüssel, so dass in der resultierenden Liste jeder Schlüssel
nur einmal vorkommt.
Die Node Klasse ist wie folgt definiert:
\begin{verbatim}
class Node {
data: int
next: Node
}
\end{verbatim}
\begin{verbatim}
function removeDuplicates(head) {
if head == null {
return null
}
current = head
while current != null and current.next != null {
if current.data == current.next.data {
current.next = current.next.next
} else {
current = current.next
}
}
return head
}
\end{verbatim}
Die worstcase Laufzeit beträgt $\mathcal{O}(n)$ mit $n$ der Anzahl an Elementen.
\break
\subsection*{b)}
Invertiere die Liste, sodass die Elemente aufsteigend nach $data$ sortiert sind. Dazu steht zu-
sätzlich nur konstant viel Speicherplatz zur Verfügung.
\begin{verbatim}
function reverseList(head) {
prev = null
current = head
while current != null {
next = current.next
current.next = prev
prev = current
current = next
}
return prev
}
\end{verbatim}
\subsection*{c)}
ngenommen wir erweitern die Listenelemente um das Feld $rang$. Dieses Feld soll die Anzahl
der Elemente in der Liste mit größerem Schlüssel angeben. Berechne für jedes Element den
richtigen Eintrag für $rang$.
\begin{verbatim}
function calculateRank(head) {
if head == null {
return null
}
current = head
rank = 0
while current != null {
current.rang = rank
rank += 1
current = current.next
}
return head
}
\end{verbatim}
\break
\section*{Aufgabe 5.4}
Wir betrachten den rechts dargestellten Baum $B$.
\subsection*{a)}
Geben Sie $B$ als Eltern-Array an.\\
\begin{tabular}{| c | c | c | c | c | c | c | c | c | c | c | c | c | c |}
\hline
1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 \\
\hline
0 & 1 & 2 & 2 & 1 & 5 & 6 & 6 & 6 & 1 & 10 & 10 & 12 & 12 \\
\hline
\end{tabular}
\subsection*{b)}
Welche Tiefe hat $B$? Welche Tiefe hat der Knoten 12?
\begin{itemize}
\item Tiefe $B$: 3
\item Tiefe Knoten 12: 2
\end{itemize}
Für einen anderen Baum $B'$ ergeben sich folgende Traversierungen:\\
InOrder($B'$) = 1, 9, 2, 8, 3, 4, 7, 5, 6\\
PostOrder($B'$) = 1, 2, 3, 4, 5, 6, 7, 8, 9
\subsection*{c)}
Geben Sie B' an.\\
\begin{tikzpicture}[level distance=1.5cm, sibling distance=2.5cm,
every node/.style={circle, draw, minimum size=0.7cm, inner sep=0}]
\node {9}
child {node {1}}
child {node {8}
child {node {2}}
child {node {7}
child {node {4}
child {node {3}}
child[missing] {}
}
child {node {6}
child {node {5}}
child[missing] {}
}
}
};
\end{tikzpicture}
\end{document}

448
algo1/assignment6/main.tex Normal file
View file

@ -0,0 +1,448 @@
\documentclass[a4paper]{article}
%\usepackage[singlespacing]{setspace}
\usepackage[onehalfspacing]{setspace}
%\usepackage[doublespacing]{setspace}
\usepackage{geometry} % Required for adjusting page dimensions and margins
\usepackage{amsmath,amsfonts,stmaryrd,amssymb,mathtools,dsfont} % Math packages
\usepackage{tabularx}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{subcaption}
\usepackage{float}
\usepackage[table,xcdraw]{xcolor}
\usepackage{tikz-qtree}
\usepackage{changepage,titlesec,fancyhdr} % For styling Header and Titles
\pagestyle{fancy}
\usepackage{enumerate} % Custom item numbers for enumerations
\usepackage[ruled]{algorithm2e} % Algorithms
\usepackage[framemethod=tikz]{mdframed} % Allows defining custom boxed/framed environments
\usepackage{listings} % File listings, with syntax highlighting
\lstset{
basicstyle=\ttfamily, % Typeset listings in monospace font
}
\usepackage[ddmmyyyy]{datetime}
\geometry{
paper=a4paper, % Paper size, change to letterpaper for US letter size
top=2.5cm, % Top margin
bottom=3cm, % Bottom margin
left=2.5cm, % Left margin
right=2.5cm, % Right margin
headheight=25pt, % Header height
footskip=1.5cm, % Space from the bottom margin to the baseline of the footer
headsep=1cm, % Space from the top margin to the baseline of the header
%showframe, % Uncomment to show how the type block is set on the page
}
\lhead{ALGO-1\\Sommersemester 2024}
\chead{\bfseries{Übungsblatt 6}\\}
\rhead{7987847\\Jonas Werner}
\begin{document}
\section*{Aufgabe 6.1}
Wir betrachten die folgende Liste von Integern
\begin{center}
12, 30, 60, 8, 14, 55, 90, 10
\end{center}
\subsection*{a)}
Hat die Liste Heap-Order?
\begin{tikzpicture}[level/.style={sibling distance=60mm/#1, circle, draw}]
\node {12}
child {
node {30}
child {
node {8}
child {
node {10}
}
}
child {
node {14}
}
}
child {
node {60}
child {
node {55}
}
child {
node {90}
}
};
\end{tikzpicture}
Nein, die Liste hat keine Heap-Order. Die Kinder der Wurzel sind beide größer als die Wurzel, daher kann ab diesem Punkt die Heap-Order nur der eines Min-Heaps entsprechen, jedoch ist sind Prioritäten der Kinder des Knoten $30$ kleiner als die des Knoten selbst. Dadurch kann die Liste keine Heap-Order haben.
\subsection*{b)}
Fügen Sie die Integer der Reihe nach in einen zu Beginn leeren Max-Heap ein. Geben Sie den
Heap nach jeder $repair\_up()$ Operation als Array an.\\
Liste $\rightarrow$ Liste nach $repair\_up()$
\begin{enumerate}
\item $[] \rightarrow []$
\item $[12] \rightarrow [12]$
\item $[12, 30] \rightarrow [30, 12]$
\item $[30, 12, 60] \rightarrow [60, 12, 30]$
\item $[60, 12, 30, 8] \rightarrow [60, 12, 30, 8]$
\item $[60, 12, 30, 8, 14] \rightarrow [60, 14, 30, 8, 12]$
\item $[60, 14, 30, 8, 12, 55] \rightarrow [60, 14, 55, 8, 12, 30]$
\item $[60, 14, 55, 8, 12, 30, 90] \rightarrow [90, 14, 60, 8, 12, 30, 55]$
\item $[90, 14, 60, 8, 12, 30, 55, 10] \rightarrow [90, 14, 60, 10, 12, 30, 55, 8]$
\end{enumerate}
\subsection*{c)}
Führen Sie auf dem Heap aus Aufgabenteil b) $change\_priority(3, 40)$ aus. Welche Operationen sind zur Reparatur auszuführen? Geben Sie den Heap nach der Ausführung von $change\_priority()$ sowie nach jeder weiteren ausgeführten Operation als Array an.\\
[90, 14, 60, 10, 12, 30, 55, 8]\\
$change\_priority(3, 40) \rightarrow$ [90, 14, 40, 10, 12, 30, 55, 8]\\
Um die Heap-Order zu reparieren muss folgender Schritt gemacht werden:\\
$repair\_up(55) \rightarrow$ [90, 14, 55, 10, 12, 30, 40, 8]
\break
\section*{Aufgabe 6.2}
Im Folgenden betrachten wir eine Verallgemeinerung der in der Vorlesung diskutieren binären Heaps. In sogenannten \textit{k-nären} Heaps, wobei $k \geq 3$, gilt weiterhin die Heap-Ordnung. Jedoch ändert sich die Heap-Struktur: In einem \textit{k-nären} Heap der Tiefe $t$ hat jeder Knoten in Tiefe höchstens $t - 2$ genau $k$ Kinder (statt genau zwei Kindern bei binären Heaps). In Tiefe $t - 1$ gibt es einen Knoten $v$ mit höchstens $k$ Kindern. Alle Knoten in Tiefe $t - 1$ links des Knotens $v$ haben genau $k$ Kinder; alle Knoten in Tiefe $t - 1$ rechts von $v$ sind Blätter.
\subsection*{a)}
Zeigen Sie, dass die Tiefe des zugehörigen Baums mit n Knoten $\theta(\log_k n)$ beträgt.
TODO
\subsection*{b)}
Geben sie an,
\subsubsection*{i)}
in welcher Position im Array sich die Kinder von Knoten $i$ für $1 \leq i \leq n$ befinden (sofern sie existieren),\\
Wir benötigen eine Hilfsvariable $s$ welche das $s-te$ Kind des Knoten $i$ meint.\\
$s \in \mathbb{N} | (1, k)$\\
Somit ist die Formel um den Index für das $s-te$ Kind des Knoten $i$ zu bekommen:
$index = i \cdot k - (k-s + 1)$
\subsubsection*{ii)}
in welcher Position im Array sich der Elternknoten von Knoten $j$ für $2 \leq j \leq n$ befindet.\\
Für diese Formel benötigen wir die floor-Notation $\lfloor \cdot \rfloor$ weil je nachdem bei welchem Kind wir sind, ist der Index dieses Kindes näher bei dem des Vaters oder weiter weg. Dabei muss dann abgerundet werden.\\
Die Formel lautet dann:\\
$index = \lfloor \frac{i + (k - 2)}{k}\rfloor$
\subsection*{c)}
Passen Sie die Prozedur $repair\_down()$ so an, dass sie für \textit{k-näre} Heaps funktioniert. Beschreiben Sie
die geänderte Prozedur in Pseudocode und analysieren Sie die Laufzeit Ihres Verfahrens asymptotisch in $k$ und $n$.
\begin{verbatim}
void heap::repair_down (int wo, k)
{
int kind; int p = H[wo];
while (wo <= n/2 && wo * k - (k - kind + 1) > p)
{
kind = 2 * wo;
if ((kind < n) && (H[kind] < H[kind + 1])) kind ++;
if (p >= H[kind]) break;
H[wo] = H[kind]; wo = kind;
}
H[wo] = p;
}
\end{verbatim}
Die Laufzeit verändert sich nicht. Sie bleibt $\theta(\log n)$, weil die Schleife immer noch gleich oft ausgeführt wird und nur eine Kondition der Schleife hinzugfügt wird.
\subsection*{d)}
Passen Sie die Prozedur $repair\_up()$ so an, dass sie für \textit{k-näre} Heaps funktioniert. Beschreiben
Sie die geänderte Prozedur in Pseudocode und analysieren Sie die Laufzeit Ihres Verfahrens
asymptotisch in $k$ und $n$.
\begin{verbatim}
void heap::repair_up (int wo, k)
{
int p = H[wo];
while ((wo > 1) && floor((wo + k - 2)/k) < p))
{
H[wo] = H[wo/2];
wo = wo/2;
}
H[wo] = p;
}
\end{verbatim}
Die Laufzeit verändert sich nicht. Sie bleibt $\theta(\log n)$, weil die Schleife immer noch gleich oft ausgeführt wird und nur eine Kondition der Schleife hinzugfügt wird.
\break
\section*{Aufgabe 6.3}
Im Folgenden betrachten wir Eigenschaften von binären Suchbäumen.
\subsection*{a)}
Welche Tiefe hat ein binärer Suchbaum in den man $n$ verschiedene natürliche Zahlen in absteigender Reihenfolge einfügt?\\
Ein binärer Suchbaum ist nicht ungedingt ein vollständiger Baum. Daher gilt die folgende Formel:
$\text{Tiefe } t = \lfloor \log_2(n + 1) - 1 \rfloor$
\subsection*{b)}
Geben Sie eine Reihenfolge der ersten 15 Primzahlen an, sodass nach Einfügen in einen binären Suchbaum dieser minimale Tiefe hat. Ist diese Reihenfolge eindeutig?\\
Die ersten 15 Primzahlen lauten: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47\\
\textbf{Die Vorgehensweise bei der Konstruktion des binären Suchbaumes lautet wie folgt:}
\begin{enumerate}
\item Der Median ist die Wurzel des (Teil-) Baums.
\item Alle Zahlen links vom Median bilden den linken Teilbaum
\item Alle Zahlen rechts vom Median bilden den rechten Teilbaum\\
\end{enumerate}
\textbf{Somit können wir den Suchbaum aufbauen:}
\begin{itemize}
\item Die Wurzel des Suchbaums ist $19$
\item Der linke Teilbaum besteht aus den Knoten [2, 3, 5, 7, 11, 13, 17]
\item Der rechte Teilbaum besteht aus den Knoten [23, 29, 31, 37, 41, 43, 47]
\item Vom linken Teilbaum ist die Wurzel $7$
\item Von der Wurzel des linken Teilbaums besteht der linke Teilbaum aus [2, 3, 5]
\item Von der Wurzel des linken Teilbaums besteht der rechte Teilbaum aus [11, 13, 17]
\item Vom reichten Teilbaum ist die Wurzel $37$
\item Von der Wurzel des rechten Teilbaums besteht der linke Teilbaum aus [23, 29, 31]
\item Von der Wurzel des rechten Teilbaums besteht der rechte Teilbaum aus [41, 43, 47]\\
\end{itemize}
\textbf{Also sieht der Baum aus wie folgt:}\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {19}
child {node {7}
child {node {3}
child {node {2}}
child {node {5}}
}
child {node {13}
child {node {11}}
child {node {17}}
}
}
child {node {37}
child {node {29}
child {node {23}}
child {node {31}}
}
child {node {43}
child {node {41}}
child {node {47}}
}
};
\end{tikzpicture}
\break
\section*{Aufgabe 6.4}
\subsection*{a)}
Fügen Sie die Schlüssel
\begin{center}
21, 15, 5, 33, 28, 30\\
\end{center}
in dieser Reihenfolge in einen anfangs leeren AVL-Baum ein. Stellen Sie den Baum inklusive der Balancegrade aller Knoten nach jeder Einfüge-Operation dar. Sofern nach einer Einfügung (mindestens) eine Rotation notwendig ist, stellen Sie den Baum zusätzlich vor jeder Rotation dar. Geben Sie in diesem Zusammenhang außerdem an, welcher Rotationsfall (Zick-Zick, Zick-Zack, Zack-Zick oder Zack-Zack) vorliegt und welche Rotation(en) ausgeführt wird bzw. werden.\\
\textbf{1.} $21$\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {21};
\end{tikzpicture}
\textbf{2.} $15$\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {21}
child[anchor=north east] {
node{15}
};
\end{tikzpicture}
\textbf{3.} $5$\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {21}
child[anchor=north east] {
child{node{15}
child{node{5}
}
}
};
\end{tikzpicture}
\textbf{Zick-Zack (Rechts-Rotation):}\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {15}
child {node {5}}
child {node {21}
};
\end{tikzpicture}
\textbf{4.} $33$\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {15}
child {node {5}}
child {node {21}
child[anchor=north west] {node{33}}
};
\end{tikzpicture}
\textbf{Zick-Zack (Rechts-Rotation):}\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {15}
child {node {5}}
child {node {33}
child[anchor=north east] {node{21}}
};
\end{tikzpicture}
\textbf{5.} $28$\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {15}
child {node {5}}
child {node {33}
child[anchor=north east] {node{21}
child[anchor=north west] {node{28}}}
};
\end{tikzpicture}
\textbf{Zick-Zick (Rechts-Rotation):}\\
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {15}
child {node {5}}
child {node {21}
child {node{28}
child[anchor=north west] {node{30}}}
child {node{33}
}
};
\end{tikzpicture}
\textbf{(Links-Rotation)}
\begin{tikzpicture}[
level distance=1.5cm,
level 1/.style={sibling distance=6cm},
level 2/.style={sibling distance=3cm},
level 3/.style={sibling distance=1.5cm},
every node/.style={circle, draw, minimum size=1.5em, inner sep=1pt}
]
\node {15}
child {node {5}}
child {node {30}
child {node{21}
child[anchor=north west] {node{28}}}
child {node{33}
}
};
\end{tikzpicture}
\subsection*{b)}
Betrachten Sie die im Folgenden explizit dargestellte Doppelrotation für einen AVL-Baum (Zick-Zack-Fall). Die Bezeichnungen w, v, u und x geben die Adresse des jeweiligen Knotens im Speicher an. Wir nehmen an, dass jeder Knoten im Baum zwei Zeiger besitzt, links und rechts, die auf das linke bzw. rechte Kind des Knotens zeigen. Geben Sie eine gültige Folge von notwendigen Zeigeraktualisierungen für diese Doppelrotation an. Sie brauchen Ihre Antwort nicht weiter zu begründen.
\begin{verbatim}
x.rechts = w.rechts
x.links = w.links
w.links = v.links
v.rechts = B1
v.links = B2
\end{verbatim}
\end{document}

182
algo1/assignment7/main.tex Normal file
View file

@ -0,0 +1,182 @@
\documentclass[a4paper]{article}
%\usepackage[singlespacing]{setspace}
\usepackage[onehalfspacing]{setspace}
%\usepackage[doublespacing]{setspace}
\usepackage{geometry} % Required for adjusting page dimensions and margins
\usepackage{amsmath,amsfonts,stmaryrd,amssymb,mathtools,dsfont} % Math packages
\usepackage{tabularx}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{subcaption}
\usepackage{float}
\usepackage[table,xcdraw]{xcolor}
\usepackage{tikz-qtree}
\usepackage{changepage,titlesec,fancyhdr} % For styling Header and Titles
\pagestyle{fancy}
\usepackage{enumerate} % Custom item numbers for enumerations
\usepackage[ruled]{algorithm2e} % Algorithms
\usepackage[framemethod=tikz]{mdframed} % Allows defining custom boxed/framed environments
\usepackage{listings} % File listings, with syntax highlighting
\lstset{
basicstyle=\ttfamily, % Typeset listings in monospace font
}
\usepackage[ddmmyyyy]{datetime}
\geometry{
paper=a4paper, % Paper size, change to letterpaper for US letter size
top=2.5cm, % Top margin
bottom=3cm, % Bottom margin
left=2.5cm, % Left margin
right=2.5cm, % Right margin
headheight=25pt, % Header height
footskip=1.5cm, % Space from the bottom margin to the baseline of the footer
headsep=1cm, % Space from the top margin to the baseline of the header
%showframe, % Uncomment to show how the type block is set on the page
}
\lhead{ALGO-1\\Sommersemester 2024}
\chead{\bfseries{Übungsblatt 6}\\}
\rhead{7987847\\Jonas Werner}
\begin{document}
\section*{Aufgabe 7.1}
Gegeben sei der folgende (a, b)-Baum $T_{ab}$:
\begin{center}
\begin{tikzpicture}[
every node/.style = {draw, circle, minimum size=8mm, inner sep=0pt},
level 1/.style={sibling distance=35mm},
level 2/.style={sibling distance=20mm}
]
\node {F, N}
child {node {A, E}}
child {node {H, I}}
child {node {X}};
\end{tikzpicture}
\end{center}
Fügen Sie für die beiden folgenden Spezifikationen von Tab jeweils die Schlüssel C, Y, T, S und Q ein und entfernen Sie anschließend die Schlüssel N, A und S (jeweils in dieser Reihenfolge).
\begin{enumerate}
\item[ a)] Tab ist ein (2, 3)-Baum.
\item[ b)] Tab ist ein (2, 4)-Baum.
\end{enumerate}
Geben Sie jeweils die Zwischenschritte in graphischer Darstellung an und beschreiben Sie kurz, was - aus welchem Grund - geschieht.
\textbf{Hinweis:} Es kann für das Verständnis helfen, die Operationen noch einmal in kleinere Zwischenschritte aufzuspalten. Es genügt jedoch, eine Grafik für den Zustand nach jeder Operation anzugeben.
\subsection*{a)}
\begin{verbatim}
(F,N) insert(C) (F,N) (C,F,N) (F) insert(Y)
/ | \ -> / | \ -> / | \ -> / \ ->
(A,E) (H,I) (X) (A,C,E) (H,I) (X) (A,E) (H,I) (X) (C) (N)
/ \ / \
(A) (E) (H,I) (X)
(F) (F) (F)
/ \ insert(T) / \ / \ insert(S)
(C) (N) -> (C) (N) -> (C) (N,X) ->
/ \ / \ / \ / \ / \ / | \
(A) (E) (H,I) (X,Y) (A) (E) (H,I) (T,X,Y) (A) (E) (H,I) (T) (Y)
(F) (F) (F)
/ \ insert(Q) / \ / \
(C) (N,X) -> (C) (N,X) -> (C) (N,S,X) ->
/ \ / | \ / \ / | \ / \ / | | \
(A) (E) (H,I)(S,T) (Y) (A) (E)(H,I)(Q,S,T) (Y) (A) (E)(H,I)(Q)(T) (Y)
\end{verbatim}
\break
\begin{verbatim}
(F,S) (F,S)
/ | \ remove(N) / | \
(C) (N) (X) -> (C) ( ) (X) ->
/ \ / \ / \ / \ / \ / \
(A) (E)(H,I)(Q) (T) (Y) (A) (E)(H,I)(Q) (T) (Y)
(F,S) (F,S)
/ | \ / | \ remove(A)
(C) (Q) (X) -> (C) (I) (X) ->
/ \ | / \ / \ / \ / \
(A) (E)(H,I) (T) (Y) (A) (E) (H)(Q) (T) (Y)
(F,S) (F,S)
/ | \ / | \
(C) (Q) (X) -> ( ) (I) (X) ->
/ \ | / \ / / \ / \
( ) (E)(H,I) (T) (Y) (C,E) (H) (Q) (T) (Y)
(S) ( )
/ \ remove(s) / \
(F,I) (X) -> (F,I) (X) ->
/ | \ / \ / | \ / \
(C,E)(H) (Q) (T) (Y) (C,E)(H) (Q) (T) (Y)
(T) (T)
/ \ / \
(F,I) (X) -> (F,I) ( ) ->
/ | \ / \ / | \ |
(C,E)(H) (Q) ( ) (Y) (C,E)(H) (Q) (X,Y)
(I)
/ \
(F) (T)
/ \ / \
(C,E) (H) (Q) (X,Y)
\end{verbatim}
\subsection*{b)}
\begin{verbatim}
(F,N) insert(C) (F,N) insert(Y) (F,N) insert(T) (F,N) insert(S)
/ | \ -> / | \ -> / | \ -> / | \ ->
(A,E) (H,I) (X) (A,C,E) (H,I) (X) (A,C,E) (H,I) (X,Y) (A,C,E) (H,I) (T,X,Y)
(F,N) (F,N,T) insert(Q) (F,N,T) remove(N)
/ | \ -> / | | \ -> / | | \ ->
(A,C,E) (H,I) (S,T,X,Y) (A,C,E)(H,I)(S)(X,Y) (A,C,E)(H,I)(Q,S)(X,Y)
(F,T) (F,Q,T) remove(S) (F,Q,T)
/ | | \ -> / | | \ -> / | | \
(A,C,E) (H,I)(Q,S)(X,Y) (A,C,E)(H,I)(S)(X,Y) (A,C,E)(H,I) ( )(X,Y)
(F,Q,T) (F,I,T)
/ | | \ -> / | | \
(A,C,E) (H,I)( )(X,Y) (A,C,E)(H)(Q)(X,Y)
\end{verbatim}
\section*{Aufgabe 7.2 Nahezu sortiert (18 Punkte)}
Sei A ein Array mit \( n > 0 \) natürlichen Zahlen, wobei keine Zahl mehr als einmal vorkommt. Die Einträge in A seien bezüglich eines Parameters \( k \leq n \) "nahezu" sortiert, d.h., jeder Eintrag ist höchstens um \( k \) Positionen von seiner eigentlich korrekten Position in der Sortierung entfernt.
Entwerfen Sie einen Algorithmus, der die Einträge im Array A in die korrekte Sortierung überführt. Die Laufzeit sollte \( O(n \log k) \) nicht überschreiten. Beschreiben Sie wie immer zuerst die Idee Ihres Algorithmus und geben Sie ihn dann in Pseudocode an. Zeigen Sie, dass der Algorithmus korrekt arbeitet und die genannte Laufzeitschranke einhält.
\end{document}

245
algo1/assignment8/main.tex Normal file
View file

@ -0,0 +1,245 @@
\documentclass[a4paper]{article}
%\usepackage[singlespacing]{setspace}
\usepackage[onehalfspacing]{setspace}
%\usepackage[doublespacing]{setspace}
\usepackage{geometry} % Required for adjusting page dimensions and margins
\usepackage{amsmath,amsfonts,stmaryrd,amssymb,mathtools,dsfont} % Math packages
\usepackage{tabularx}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{subcaption}
\usepackage{float}
\usepackage[table,xcdraw]{xcolor}
\usepackage{tikz-qtree}
\usepackage{changepage,titlesec,fancyhdr} % For styling Header and Titles
\pagestyle{fancy}
\usepackage{enumerate} % Custom item numbers for enumerations
\usepackage[ruled]{algorithm2e} % Algorithms
\usepackage[framemethod=tikz]{mdframed} % Allows defining custom boxed/framed environments
\usepackage{listings} % File listings, with syntax highlighting
\lstset{
basicstyle=\ttfamily, % Typeset listings in monospace font
}
\usepackage[ddmmyyyy]{datetime}
\geometry{
paper=a4paper, % Paper size, change to letterpaper for US letter size
top=2.5cm, % Top margin
bottom=3cm, % Bottom margin
left=2.5cm, % Left margin
right=2.5cm, % Right margin
headheight=25pt, % Header height
footskip=1.5cm, % Space from the bottom margin to the baseline of the footer
headsep=1cm, % Space from the top margin to the baseline of the header
%showframe, % Uncomment to show how the type block is set on the page
}
\lhead{ALGO-1\\Sommersemester 2024}
\chead{\bfseries{Übungsblatt 7}\\}
\rhead{7987847\\Jonas Werner}
\begin{document}
\section*{Aufgabe 8.1}
Gegeben sind die Funktionen $f (x) = (3 \cdot x) mod 5$ und $g(x) = 4 - (x mod 4)$. Fügen Sie die Zahlen $58, 93, 15, 41, 27$ in dieser Reihenfolge in eine Hashtabelle der Größe 5 ein. Dabei sollen die Zahlen mit.
\subsection*{a)}
Verketten, d.h., $h(x) = f (x)$,\\
\begin{tabular}{c|c|c|c|c}
0 & 1 & 2 & 3 & 4 \\
15 & 27 & & 41 & 58 \\
& & & & 93
\end{tabular}\\
\begin{itemize}
\item $h(58) = f(58) = (3 \cdot 58) \mod 5 = 4$\\
\item $h(93) = f(93) = (3 \cdot 93) \mod 5 = 4$\\
\item $h(15) = f(15) = (3 \cdot 15) \mod 5 = 0$\\
\item $h(41) = f(41) = (3 \cdot 41) \mod 5 = 3$\\
\item $h(27) = f(27) = (3 \cdot 27) \mod 5 = 1$\\
\end{itemize}
\subsection*{b)}
linearem Austesten, d.h., $h_i(x) = (f (x) + i) \mod 5$,\\
\begin{tabular}{c|c|c|c|c}
0 & 1 & 2 & 3 & 4 \\
93 & 15 & 27 & 41 & 58
\end{tabular}\\
\begin{itemize}
\item $h_0(58) = (f(x) + i) \mod 5 = ((3 \cdot 58) \mod 5) + 0 = 4$
\item $h_0(93) = (f(x) + i) \mod 5 = ((3 \cdot 93) \mod 5) + 0 = 4 \xrightarrow{i + 1} h_1(93) = 5 \xrightarrow{\text{max 4 daher zurück zu 0}} 0$
\item $h_0(15) = (f(x) + i) \mod 5 = ((3 \cdot 15) \mod 5) + 0 = 0 \xrightarrow{i + 1} h_1(15) = 1$
\item $h_0(41) = (f(x) + i) \mod 5 = ((3 \cdot 41) \mod 5) + 0 = 3$
\item $h_0(27) = (f(x) + i) \mod 5 = ((3 \cdot 27) \mod 5) + 0 = 1 \xrightarrow{i + 1} h_1(27) = 2$
\end{itemize}
\subsection*{c)}
doppeltem Hashing, d.h., $h_i(x) = (f (x) + i \cdot g(x)) mod 5$,\\
\begin{tabular}{c|c|c|c|c}
0 & 1 & 2 & 3 & 4 \\
15 & 27 & 93 & 41 & 58
\end{tabular}\\
\begin{itemize}
\item $h_0(58) = (3 \cdot 58) \mod 5 + 0 \cdot (4 - (58 \mod 4)) = 4$
\item $h_0(93) = (3 \cdot 93) \mod 5 + 0 \cdot (4 - (93 \mod 4)) = 2$
\item $h_0(15) = (3 \cdot 15) \mod 5 + 0 \cdot (4 - (15 \mod 4)) = 0$
\item $h_0(41) = (3 \cdot 41) \mod 5 + 0 \cdot (4 - (41 \mod 4)) = 3$
\item $h_0(27) = (3 \cdot 58) \mod 5 + 0 \cdot (4 - (27 \mod 4)) = 3 \\\xrightarrow{i + 1} h_1(27) = (3 \cdot 27) \mod 5 + 1 \cdot (4 - (27 \mod 4)) = 4 \\\xrightarrow{i + 1} h_2(27) = (3 \cdot 27) \mod 5 + 1 \cdot (4 - (27 \mod 4)) = 0 \\\xrightarrow{i + 1} h_3(27) = (3 \cdot 27) \mod 5 + 1 \cdot (4 - (27 \mod 4)) = 1$
\end{itemize}
\section*{8.2}
Gegeben ist eine leere Hashtabelle H der Größe m = 2 zusammen mit den Hashfunktionen $hi(x) = (7 · x + i) \mod m$. Fügen Sie die folgende Sequenz von Schlüsseln in der gegebenen Reihenfolge in die Hashtabelle ein und vergrößern Sie die Hashtabelle, wann immer der Auslastungsfaktor $\lambda$ wenigstens $\frac{1}{2}$ erreicht. Stellen Sie die Hashtabelle vor und nach jeder Reorganisation sowie nach der Einfügung aller Schlüssel dar. Wenn Sie die Hashtabelle vergrößern müssen, wählen Sie als neue Größe die kleinste Primzahl, sodass sich die Größe wenigstens verdoppelt. Fügen Sie Schlüssel, die bereits in der Hashtabelle waren, in der ursprünglichen Reihenfolge in die größere Tabelle ein, in der sie in der kleineren Tabelle standen (vom kleinen zum großen Index).
\begin{center}
15, 78, 34, 91, 66, 48, 25, 53, 80, 9.
\end{center}
$Hinweis$: Für eine bessere Übersicht können Sie leere Indizes der Hashtabelle weglassen.\\
\begin{tabular}{c|c}
0 & 1 \\
& 15
\end{tabular}\\
\begin{itemize}
\item $h_0(15) = (7 \cdot 15) \mod 2 = 1$
\end{itemize}\\
$\lambda$ erreicht $\xrightarrow{\text{nächstgrößere Primzahl}} m = 5$\\
\begin{tabular}{c|c|c|c|c}
0 & 1 & 2 & 3 & 4 \\
15 & 78 & & 34
\end{tabular}\\
\begin{itemize}
\item $h_0(15) = (7 \cdot 15) \mod 5 = 5$
\item $h_0(78) = (7 \cdot 78) \mod 5 = 1$
\item $h_0(34) = (7 \cdot 34) \mod 5 = 3$
\end{itemize}\\
$\lambda$ erreicht $\xrightarrow{\text{nächstgrößere Primzahl}} m = 11$\\
\begin{tabular}{c|c|c|c|c|c|c|c|c|c|c}
0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \\
66 & & & & & & 15& 78 & 34 & 48 & 91
\end{tabular}\\
\begin{itemize}
\item $h_0(15) = (7 \cdot 15) \mod 11 = 6$
\item $h_0(78) = (7 \cdot 78) \mod 11 = 7$
\item $h_0(34) = (7 \cdot 34) \mod 11 = 7 \xrightarrow{i + 1} h_1(34) = 8$
\item $h_0(91) = (7 \cdot 91) \mod 11 = 10$
\item $h_0(66) = (7 \cdot 66) \mod 11 = 0$
\item $h_0(48) = (7 \cdot 48) \mod 11 = 6 \xrightarrow{i + 1 + 1 + 1} h_3(48) = 9$
\end{itemize}\\
$\lambda$ erreicht $\xrightarrow{\text{nächstgrößere Primzahl}} m = 23$\\
\begin{tabular}{c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c}
0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17 & 18 & 19 & 20 & 21 & 22 \\
& & 66 & 53 & & & & & 34 & 80 & & & & 15 & 48 & 25 & 91 & 78 & 9
\end{tabular}\\
\begin{itemize}
\item $h_0(15) = (7 \cdot 15) \mod 23 = 13$
\item $h_0(78) = (7 \cdot 78) \mod 23 = 17$
\item $h_0(34) = (7 \cdot 34) \mod 23 = 8$
\item $h_0(91) = (7 \cdot 91) \mod 23 = 16$
\item $h_0(66) = (7 \cdot 66) \mod 23 = 2$
\item $h_0(48) = (7 \cdot 48) \mod 23 = 14$
\item $h_0(25) = (7 \cdot 25) \mod 23 = 14 \xrightarrow{i + 1} h_1(25) = 15$
\item $h_0(53) = (7 \cdot 53) \mod 23 = 3$
\item $h_0(80) = (7 \cdot 80) \mod 23 = 8 \xrightarrow{i + 1} h_1(80) = 9$
\item $h_0(9) = (7 \cdot 9) \mod 23 = 17 \xrightarrow{i + 1} h_1(9) = 18$
\end{itemize}\\
\section*{Aufgabe 8.4}
Betrachten Sie den gerichteten Graphen G.
\subsection*{a)}
Bestimmen Sie die In- und Out-Grade aller Knoten in G.
\begin{tabular}{ c c c c c c c c c }
& a & b & c & d & e & f & g & h \\
in & 0 & 1 & 2 & 1 & 2 & 2 & 1 & 3 \\
out & 2 & 1 & 2 & 3 & 2 & 0 & 2 & 0
\end{tabular}
\subsection*{b)}\
Geben Sie eine topologische Sortierung für G an.
Topologische Sortierung mithilfe von Kahn's Algorithmus:\\
\begin{tabular}{ c|c|c|c|c|c|c|c|c|c}
a & \textbf{0} & -1 & -1 & -1 & -1 & -1 & -1 & -1 \\
b & 1 & 1 & \textbf{0} & -1 & -1 & -1 & -1 & -1 \\
c & 2 & 2 & 2 & 1 & \textbf{0} & -1 & -1 & -1 \\
d & 1 & \textbf{0} & -1 & -1 & -1 & -1 & -1 & -1 \\
e & 2 & 2 & 1 & 1 & 1 & \textbf{0} & -1 & -1 \\
f & 2 & 1 & 1 & 1 & 1 & 1 & \textbf{0} & -1 \\
g & 1 & 1 & \textbf{0} & -1 & -1 & -1 & -1 & -1 \\
h & 3 & 3 & 3 & 2 & 1 & \textbf{0} & -1 & -1 \\
\end{tabular}\\
Somit ist eine mögliche topologische Reihenfolge: a, d, b, g, c, e, f, h
\subsection*{c)}
Stellen Sie den Graphen G als Adjazenzliste dar. Die direkten Nachfolger jedes Knotens v sind
dabei in lexikographisch aufsteigender Reihenfolge in die Liste von v einzutragen.
\begin{itemize}
\item a: \{d,f\}
\item b: \{c\}
\item c: \{e,h\}
\item d: \{b,e\}
\item e: \{f,h\}
\item f: \{\}
\item g: \{c,h\}
\item h: \{\}
\end{itemize}
\subsection*{d)}
\begin{tabular}{ c|c|c|c|c|c|c|c|c}
& a & b & c & d & e & f & g & h \\
\hline
a & 0 & 0 & 0 & \textbf{1} & 0 & \textbf{1} & 0 & 0 \\
\hline
b & 0 & 0 & \textbf{1} & 0 & 0 & 0 & 0 & 0 \\
\hline
c & 0 & 0 & 0 & 0 & \textbf{1} & 0 & 0 & \textbf{1} \\
\hline
d & 0 & \textbf{1} & 0 & 0 & \textbf{1} & 0 & \textbf{1} & 0 \\
\hline
e & 0 & 0 & 0 & 0 & 0 & \textbf{1} & 0 & \textbf{1} \\
\hline
f & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
\hline
g & 0 & 0 & \textbf{1} & 0 & 0 & 0 & 0 & \textbf{1} \\
\hline
h & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
\end{tabular}\\
\end{document}