Fortgeschrittene Programmiertechnik Klausur SS 2015 Angewandte

Fortgeschrittene Programmiertechnik
Klausur SS 2015
Angewandte Informatik Bachelor
Name
Matrikelnummer
Aufgabe
Punkte
Aufgabe
Punkte
1
6
6
9
2
8
7
17
3
12
8
18
4
18
9
12
5
20
Summe
120
Zwischensumme
64
Note
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
1/11
Aufgabe 1
(6 Punkte)
Beschreiben Sie mit einem Speicherbelegungsbild, was durch die main()-Methode geleistet wird. Es
genügt das Speicherbelegungsbild anzugeben, nachdem alle Anweisungen der main()-Methode
ausgeführt worden sind.
class Node {
Node next;
int data;
Node(int x, Node p) {
data = x;
next = p;
}
public static void main(String[] a) {
Node p = new Node(3, null);
p.next = new Node(5, p.next);
Node q = p.next;
q.next = new Node(7, q.next);
q = new Node(1, null);
}
}
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
2/11
Aufgabe 2
(8 Punkte)
Die Knoten eines Binärbaums sind durch folgende Klasse definiert:
class Node {
int data;
Node left;
Node right;
// Referenz auf linkes Kind
// Referenz auf rechtes Kind
Node(int x, Node l, Node r) {
data = x;
left = l;
right = r
}
}
a) Der Binärbaum (2) entsteht aus dem Binärbaum (1), indem die Zahl „6“ durch „66“ ersetzt und
ein neuer Knoten mit der Zahl „2“ eingefügt wird. Schreiben Sie genau 2 Java-Anweisungen, die
das leisten.
root.right.right.data = 66;
root.left = new Node(2, null, root.left);
b) Der Binärbaum (3) entsteht aus dem Binärbaum (2), indem der linke Teilbaum der Wurzel root
an den Knoten „3“als linkes Kind eingehängt und dann die Wurzel gelöscht wird. Schreiben Sie
genau 2 Java-Anweisungen, die das leisten.
root.right.left = root.left;
root = root.right;
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
3/11
Aufgabe 3
QuickSort mit 3-Median-Strategie
(12 Punkte)
Das 11-elementige Feld a = {5, 4, 13, 11, 3, 10, 2, 8, 6, 9, 12} wird mit Quicksort mit 3-MedianStrategie sortiert. Beschreiben Sie, wie sich dabei das Feld a ändert. Benutzen Sie eine tabellenartige
Darstellung wie in der Vorlesung. Geben Sie außerdem die Aufrufstruktur von Quicksort an.
5
4
13 11 3
10 2
12
8
6
9
11
8
4
9
6
3
2
4
2
3
3
3
3
4
4
3
8
2
5
9
5
5
9
6
6
Prof. Dr. O. Bittel, HTWG Konstanz
12
10
13
6
5
2
9
8
6
9
8
8
6
6
8
12
10
12
10 11 13 12
12
12 13
11 12 13
9
9
SS 2015
4/11
Aufgabe 4
Java-Collection Map
(18 Punkte)
Für einen Text läßt sich die Häufigkeitsverteilung der vorkommenden Wörter durch eine Map
darstellen:
Map<String,Integer> hauefigkeit;
Kommt z.B. das Wort „und“ im Text 35-mal vor, dann enthält die Map einen Eintrag mit dem
Schlüssel „und“ und dem Wert 35.
a) Schreiben Sie eine Funktion merge, die aus der Häufigkeitsverteilung h1 für einen Text t1 und
der Häufigkeitsverteilung h2 für einen Text t2 eine Häufigkeitsverteilung für beide Texte
zusammen berechnet und zurückliefert. Hinweis: Die Häufigkeiten müssen dazu lediglich addiert
werden.
b) Welche Komplexität hat die Laufzeit Ihrer Funktion (O-Notation), wenn Sie davon ausgehen,
dass Ihre beiden Häufigkeitsverteilungen etwa n Wörter umfassen? Geben Sie eine kurze
Begründung Ihrer Antwort.
c) Um welchen Faktor wächst die Laufzeit, wenn die Eingabegröße n = 1000 um den Faktor 10
wächst?
a)
static Map<String,Integer>
merge(Map<String,Integer> h1, Map<String,Integer> h2) {
Map<String,Integer> h = new TreeMap<>(h1);
for (Map.Entry<String,Integer> e : h2.entrySet()) {
String key = e.getKey();
if (h.containsKey(key))
h.put(key, h.get(key)+e.getValue());
else
h.put(key, e.getValue());
}
return h;
}
b)
T(n) = O (n log n)
Konstruktoraufruf in O(n).
for-Schleife läuft n-mal. put- und get-Aufrufe benötigen O(log n).
c)
10 *1000 * log(10 *1000)
1000 * log(1000)
= 10 *
Prof. Dr. O. Bittel, HTWG Konstanz
€
4
3
≈ 13.3
SS 2015
5/11
Aufgabe 5
Sortierte, verkettete Liste mit Hilfskopfknoten
(20 Punkte)
Die Klasse LinkedListSet speichert int-Zahlen in einer linear verketteten Liste mit
Hilfskopfknoten in einer absteigend sortierten Reihenfolge. Elemente dürfen höchstens einfach
vorkommen. Ergänzen Sie die Klasse um die folgenden Methoden. Achten Sie dabei auf die
Effizienz der Methoden, indem die Sortierung der Liste ausgenutzt wird. Ausdrücke sollten nicht
unnötig kompliziert geschrieben werden.
a) Parameterloser Konstruktor.
b) contains(x) prüft, ob das Element x vorkommt.
c) add(x) fügt das Element x ein.
d) remove(x) löscht das Element x.
public class LinkedListSet {
static private class Node {
private int data;
private Node next;
private Node(Node p, int x) {data = x; next = p;}
}
private Node head;
public LinkedListSet() {
head = new Node(null,0);
}
public boolean contains(int x) {
Node p = head.next;
while (p != null && p.data > x)
p = p.next;
if (p == null || p.data < x)
return false;
else
return true;
}
public void add(int x) {
Node p = head;
while (p.next != null && p.next.data > x)
p = p.next;
if (p.next == null || p.next.data < x)
p.next = new Node(p.next,x);
}
public void remove(int x) {
Node p = head;
while (p.next != null && p.next.data > x)
p = p.next;
if (p.next != null && p.next.data == x)
p.next = p.next.next;
}
}
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
6/11
Aufgabe 6
Arrays.Sort
(9 Punkte)
Die Java Klasse Arrays bietet eine Methode zum Sortieren eines Felds an:
static <T> void sort(T[] a, Comparator<? super T> c);
Ergänzen Sie folgenden Programm-Code so, dass ein Feld von Punkten aufsteigend sortiert wird.
Ein Punkt p ist kleiner als ein Punkt q, falls die x-Koordinate von p kleiner als die x-Koordinate von
q ist oder die x-Koordinaten gleich sind, aber dafür die y-Koordinate von p kleiner als die yKoordinate von q ist.
class Point {
public double x;
public double y;
public Point (double x, double y) {
this.x = x;
this.y = y;
}
}
public static void main(String[] args) {
Point[] a = new Point[4];
a[0] = new Point(2,3);
a[1] = new Point(2,1);
a[2] = new Point(1,3);
a[3] = new Point(4,1);
Arrays.sort(a, new Comparator<Point>() {
public int compare(Point p, Point q) {
if (p.x < q.x || p.x == q.x && p.y < q.y)
return -1;
else if (p.x == q.x && p.y == q.y)
return 0;
else
return +1;
});
}
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
7/11
Aufgabe 7
Java-Collection List
(17 Punkte)
a) Schreiben Sie eine generische Methode disjoint(l1,l2), die prüft ob die Listen l1 und l2
disjunkt sind. Die Methode liefert true zurück, falls l1 und l2 keine gemeinsamen Elemente
enthalten, sonst false. Die Methode darf auf die Listen nur über Iteratoren zugreifen.
b) Welche Komplexität hat die Methode disjoint(l1,l2) (O-Notation), wenn Sie davon
ausgehen, dass die beiden Listen n Elemente enthalten?
c) Schreiben Sie eine generische Methode isSorted(l), die prüft, ob die Liste l aufsteigend
sortiert ist. Die Methode darf auf die Liste nur über Iteratoren zugreifen. Ergänzen Sie die
Typbeschränkung für T.
a)
static <T> boolean disjoint(List<T> l1, List<T> l2) {
for (T x : l1)
for (T y : l2) {
if (x.equals(y))
return false;
return true;
}
b)
T(n) = O(n2)
c)
static <T extends Comparable<? super T>> boolean isSorted(List<T> l)
{
T prev = null;
for (T x : l) {
if (prev == null)
prev = x;
else
if (prev.compareTo(x) > 0)
return false;
}
return true;
}
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
8/11
Aufgabe 8
Bäume
(18 Punkte)
Ein Baum besteht aus einem Bezeichner (String) und einer (evtl. leeren) Liste mit Teilbäumen.
a) Ergänzen Sie die gegebene Klasse (siehe nächste Seite) um geeignete Instanzvariablen und
vervollständigen Sie den Konstruktor.
b) Definieren Sie eine Methode add(Baum b), die den Baum b zur Liste mit Teilbäumen
dazufügt.
c) Schreiben Sie ein kleines Hauptprogramm, das den oben gezeigten Baum zusammenbaut.
d) Schreiben Sie eine Methode height(), die die maximale Höhe des Baums zurückgibt. Der
oben gezeigte Baum hat die Höhe 2.
e) Schreiben Sie eine Methode search(String s) die zurückgibt, wie oft der Bezeichner s im
Baum vorkommt. Im oben gezeigten Baum kommt der Bezeichner „aa“ dreimal vor.
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
9/11
class Baum {
private List<Baum> teilBaeume;
private String bezeichner;
public Baum(String bez) { // Neuer Baum mit Bezeichner bez
bezeichner = bez;
teilBaeume = new LinkedList<Baum>();
}
public void add(Baum b){
teilBaeume.add(b);
}
public int height() {
if (teilBaeume.isEmpty())
return 0;
int h = 0;
for (Baum b : teilBaeume) {
int h1 = b.height();
if (h1 > h)
h = h1;
}
return h+1;
}
public int search(String bez) {
int n = 0;
if (bez.equals(bezeichner))
n++;
for (Baum b : teilBaeume)
n += b.search(bez);
return n;
}
public static void main(String[] args) {
Baum b = new Baum("aa");
Baum b1 = new Baum("bb");
b.add(b1);
b.add(new Baum("cc"));
b.add(new Baum("dd"));
b1.add(new Baum("aa"));
b1.add(new Baum("aa"));
}
}
Prof. Dr. O. Bittel, HTWG Konstanz
SS 2015
10/11
Aufgabe 9
Subtyping
(12 Punkte)
a) Die Methode copy(dest, src) aus der Klasse Collections kopiert alle Elemente aus der
Liste src in die Liste dest.
static <T> void copy(List<? super T> dest, List<? extends T> src)
Von welchem Typ dürfen die Parameter sein? Geben Sie dazu in folgender Tabelle an, ob die
angegebene Parametertypen korrekt („+“) oder nicht korrekt („-“) sind.
dest
List<Integer>
ArrayList<Integer>
LinkedList<Object>
ArrayList<Double>
LinkedList<Number>
Set<Object>
List<Integer>
src
LinkedList<Integer>
List<Integer>
ArrayList<Double>
ArrayList<Integer>
List<Integer>
List<Integer>
LinkedList<Number>
Korrekt?
+
+
+
+
-
b) Die Klassen Vektor, 2DVektor und 3DVektor seien wie folgt definiert:
class Vektor { ... }
class Vektor2D extends Vektor implements Comparable<Vektor2D> { ... }
class Vektor3D extends Vektor implements Comparable<Vektor3D> { ... }
Geben Sie für diese drei Typen alle Untertypbeziehungen an. Berücksichtigen Sie dabei die Klasse
Object.
c) Welche Parametertypen sind beim Aufruf der Methode sort aus der Klasse Collections
erlaubt?
static <T extends Comparable<? super T>> void sort(List<T> l);
Parametertyp
LinkedList<Vektor2D>
ArrayList<Vektor3D>
List<Object>
ArrayList<Vektor>
ArrayDeque<Vektor2D>
List<? extends Vektor2D>
Prof. Dr. O. Bittel, HTWG Konstanz
Korrekt („+“ oder „-“)?
+
+
+
SS 2015
11/11