Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » aud » Forendiskussionen
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.
Beide Seiten, vorherige ÜberarbeitungVorherige ÜberarbeitungNächste Überarbeitung | Vorherige ÜberarbeitungNächste ÜberarbeitungBeide Seiten, nächste Überarbeitung | ||
pruefungen:bachelor:aud:loesungws09 [10.12.2017 17:49] – ep2910 | pruefungen:bachelor:aud:loesungws09 [17.05.2019 15:03] – SpeedyGonzalez | ||
---|---|---|---|
Zeile 10: | Zeile 10: | ||
* [[https:// | * [[https:// | ||
* [[https:// | * [[https:// | ||
+ | * [[https:// | ||
===== Lösungsversuch ===== | ===== Lösungsversuch ===== | ||
Zeile 32: | Zeile 33: | ||
**g)** Bucketsort, Mergesort | **g)** Bucketsort, Mergesort | ||
- | **h)** Richtig | + | **h)** Richtig, weil: \\ |
+ | \\ | ||
+ | Zusammenhänge für die Höhe h eines AVL-Baums mit n Knoten: \\ | ||
+ | log< | ||
+ | \\ | ||
+ | <=> O(log< | ||
+ | <=> O(log< | ||
+ | <=> O(log< | ||
+ | \\ | ||
+ | => h ∈ O(log< | ||
- | **i)** Falsch | + | |
+ | **i)** Falsch; nur bei gerader Anzahl an Elementen. | ||
**j)** O(1) | **j)** O(1) | ||
Zeile 49: | Zeile 60: | ||
**b)** | **b)** | ||
^ 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ | ^ 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ | ||
- | | 1 | 3 | 6 | 9 | 4 | 12 | 2 | 5 | | + | | 1< |
**c)** | **c)** | ||
Zeile 69: | Zeile 80: | ||
private static long[][] b = new long[MAX][MAX]; | private static long[][] b = new long[MAX][MAX]; | ||
// Vorinitialisierung des Felds b[][] mit -1 | // Vorinitialisierung des Felds b[][] mit -1 | ||
+ | // | ||
- | private static long binomFast(int n, int k) { | + | private static long binom(int n, int k) { |
if(k > n) | if(k > n) | ||
return 0; | return 0; | ||
Zeile 80: | Zeile 92: | ||
b[n][k] = binom(n - 1, k - 1) + binom(n - 1, k); | b[n][k] = binom(n - 1, k - 1) + binom(n - 1, k); | ||
- | return | + | return |
} | } | ||
</ | </ | ||
Zeile 139: | Zeile 151: | ||
return true; | return true; | ||
} | } | ||
+ | </ | ||
+ | |||
+ | oder rekursive Version: | ||
+ | |||
+ | <code java> | ||
+ | static boolean insertRec(BinTree b, int value) { | ||
+ | if (value > b.value) { | ||
+ | if (b.right == null) { | ||
+ | b.right = new BinTree(value); | ||
+ | return true; | ||
+ | } | ||
+ | return insertRec(b.right, | ||
+ | } else if (value < b.value) { | ||
+ | if (b.left == null) { | ||
+ | b.left = new BinTree(value); | ||
+ | return true; | ||
+ | } | ||
+ | return insertRec(b.left, | ||
+ | } | ||
+ | return false; | ||
+ | } | ||
</ | </ | ||
Zeile 156: | Zeile 189: | ||
* **O(n log n)** | * **O(n log n)** | ||
Sollte es nicht O(n) sein? In den VL-Folien steht, dass das Aufbauen einer Halde aus einem Array der Länge n nur O(n) ist. (Beweis wurde ausgelassen, | Sollte es nicht O(n) sein? In den VL-Folien steht, dass das Aufbauen einer Halde aus einem Array der Länge n nur O(n) ist. (Beweis wurde ausgelassen, | ||
+ | Ja, in der Klausur wurde nach der effizientesten Möglichkeit gesucht. Diese baut den Heap in O(n) auf, wie hier unter 4.2.4 beschrieben: | ||
**c)** | **c)** | ||
Zeile 170: | Zeile 204: | ||
} | } | ||
} | } | ||
+ | </ | ||
+ | |||
+ | Das ginge meines Erachtens (bei anderer Angabe noch leichter), oder??: | ||
+ | |||
+ | <code java> | ||
+ | |||
+ | public static void haldenSortierung(int[] feld){ | ||
+ | haldenEigenschaftHerstellen(feld); | ||
+ | | ||
+ | for(int i = feld.length - 1; i > 0; i--){ | ||
+ | tausche(feld, | ||
+ | versickern(feld, | ||
+ | } | ||
+ | } | ||
</ | </ | ||
Zeile 196: | Zeile 244: | ||
^ A ^ B ^ C ^ D ^ E ^ F ^ G ^ H ^ | ^ A ^ B ^ C ^ D ^ E ^ F ^ G ^ H ^ | ||
| [0] | ∞ | ∞ | ∞ | ∞ | ∞ | ∞ | ∞ | | | [0] | ∞ | ∞ | ∞ | ∞ | ∞ | ∞ | ∞ | | ||
- | | 0 | 4 | [2] | ∞ | ∞ | ∞ | ∞ | ∞ | | + | | | 4< |
- | | 0 | [3] | 2 | 7 | ∞ | ∞ | ∞ | ∞ | | + | | | [3< |
- | | 0 | 3 | 2 | 7 | ∞ | [4] | ∞ | ∞ | | + | | | | | 7< |
- | | 0 | 3 | 2 | 7 | [5] | 4 | ∞ | 8 | | + | | | | | 7< |
- | | 0 | 3 | 2 | [7] | 5 | 4 | 10 | 8 | | + | | | | | [7< |
- | | 0 | 3 | 2 | 7 | 5 | 4 | 10 | [8] | | + | | | | | | | | 10< |
- | | 0 | 3 | 2 | 7 | 5 | 4 | [9] | 8 | | + | | | | | | | | [9< |
- | | 0 | 3 | 2 | 7 | 5 | 4 | 9 | 8 | | + | |
+ | [9< | ||
+ | |||
+ | => A -> C -> B -> F -> H -> G | ||
**c) Euler** | **c) Euler** | ||
Zeile 227: | Zeile 278: | ||
contains(x, put(y, M)) = contains(x, M); | contains(x, put(y, M)) = contains(x, M); | ||
</ | </ | ||
+ | oder | ||
+ | \\ | ||
+ | < | ||
+ | axs | ||
+ | contains(s, create()) = FALSE | ||
+ | contains(s, put(a, m)) = { TRUE falls s = a | ||
+ | { contains(s, m) | ||
+ | </ | ||
**b)** | **b)** | ||
< | < | ||
Zeile 235: | Zeile 293: | ||
count(x, put(x, M)) = 1 + count(x, M) | count(x, put(x, M)) = 1 + count(x, M) | ||
count(x, put(y, M)) = count(x, M) | count(x, put(y, M)) = count(x, M) | ||
+ | </ | ||
+ | oder | ||
+ | \\ | ||
+ | < | ||
+ | ops | ||
+ | count: | ||
+ | |||
+ | axs | ||
+ | count(s, create()) = 0 | ||
+ | count(s, put(a, m)) = { 1 + count(s, m) falls s = a | ||
+ | { count(s, m) sonst | ||
</ | </ | ||
Zeile 244: | Zeile 313: | ||
purge(x, put(x, M)) = purge(x, M) | purge(x, put(x, M)) = purge(x, M) | ||
purge(x, put(y, M)) = put(y, purge(x, M)) | purge(x, put(y, M)) = put(y, purge(x, M)) | ||
+ | </ | ||
+ | oder | ||
+ | \\ | ||
+ | < | ||
+ | ops | ||
+ | purge: | ||
+ | |||
+ | axs | ||
+ | purge(s, create()) = create() | ||
+ | purge(s, put(a, m)) = { purge(s, m) falls s = a | ||
+ | { put(a, purge(s, m)) sonst | ||
</ | </ | ||
Zeile 255: | Zeile 335: | ||
< | < | ||
wp("a = a*3 - 1; b = 80 - a; b--;", b > 47) = | wp("a = a*3 - 1; b = 80 - a; b--;", b > 47) = | ||
+ | wp("a = a*3 - 1; b = 80 - a; b = b - 1;", b > 47) = | ||
wp("a = a*3 - 1; b = 80 - a;", b - 1 > 47) = | wp("a = a*3 - 1; b = 80 - a;", b - 1 > 47) = | ||
wp("a = a*3 - 1;", 80 - a - 1 > 47) = | wp("a = a*3 - 1;", 80 - a - 1 > 47) = | ||
Zeile 322: | Zeile 403: | ||
iii) | iii) | ||
- | </code> | + | < |
V = i | V = i | ||
i = n, n > 0 -> V > 0 zu Beginn | i = n, n > 0 -> V > 0 zu Beginn | ||
i = i - k, k > 0 -> i ist monoton fallend | i = i - k, k > 0 -> i ist monoton fallend | ||
</ | </ |