<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
  <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
  <link rel="stylesheet" type="text/css" media="all" href="stylesheet.css">
  <title>Prüfer-Profil: Fragen und Antworten</title>
  <style type="text/css">
    @media screen
    {
      .comment  { color: #FF0000; font-family: "Trebuchet MS", Georgia, serif; }
    }
  </style>
</head>
<body>
  <span id="menu"><a href="index.php">zurück zur Liste</a></span>
  
  <div id="buttons">
    <form action="edit.php" method="POST">
      <input type="hidden" name="filename" value="<?php echo $_SERVER['SCRIPT_FILENAME']?>">
      <p>
        <input type="submit" value="Seite bearbeiten">
      </p>
    </form>
  </div>
  
  <h1>Schweppe-Profil: Fragen und Antworten</h1>
  <h2>Bäume und Graphen</h2>
  <p>
    <ol>
      <li>
        <h3>Was für Arten von Bäumen kennen Sie?</h3>
        <p>
          Binärbäume, n-äre Bäume, AVL-Bäume, Rot-Schwarz-Bäume, B-Bäume (Mehrwegbäume)
        </p>
      </li>
      <li>
        <h3>Wie löscht man aus binären Bäumen?</h3>
        <p>
          Idee: Man ersetzt mit dem größten (rechtesten) Element aus dem linken Teilbaum (oder umgekehrt).<br>
          Lässt sich die Idee nicht sauber implementieren, kann es besser sein, den rechten Teilbaum einfach an das größte Element aus dem linken anzuhängen und dann den Baum wieder auszugleichen.
        </p>
      </li>
      <li>
        <h3>Implementieren Sie einen binären Baum in Haskell</h3>
        <p>
          <div id="syntax">
            data BinTree = E | N BinTree Int BinTree deriving Eq<br>
            <br>
            insertVal :: BinTree -> Int -> BinTree<br>
            insertVal E i = N E i E<br>
            insertVal (N l v r) i<br>
            &nbsp;&nbsp;| v == i = N l v r<br>
            &nbsp;&nbsp;| v < i = N l v (insertVal r i)<br>
            &nbsp;&nbsp;| otherwise = N (insertVal l i) v r<br>
            <br>
            delete :: BinTree -> Int -> BinTree <span class="comment">(saubere Implementierung)</span><br>
            delete E i = E<br>
            delete (N l v r) i<br>
            &nbsp;&nbsp;| v < i      = N l v (delete r i)<br>
            &nbsp;&nbsp;| v > i      = N (delete l i) v r<br>
            &nbsp;&nbsp;| l == E     = r<br>
            &nbsp;&nbsp;| r == E     = l<br>
            &nbsp;&nbsp;| otherwise  =  N (delete l (greatestElement l)) (greatestElement l) r<br>
            &nbsp;where greatestElement :: BinTree -> Int<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;greatestElement (N l v r)<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;| r == E = v<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;| otherwise = greatestElement r<br>
            <br>
            delete :: BinTree -> Int -> BinTree <span class="comment">(naive Implementierung)</span><br>
            delete E i = E<br>
            delete (N l v r) i<br>
            &nbsp;&nbsp;| v == i = insertLeftTree r l<br>
            &nbsp;&nbsp;| v < i = N l v (delete r i)<br>
            &nbsp;&nbsp;| otherwise = N (delete l i) v r<br>
            &nbsp;where insertLeftTree :: BinTree -> BinTree -> BinTree<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;insertLeftTree E t = t<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;insertLeftTree (N l v r) t = N (insertLeftTree l t) v r<br>
            <br>
            contains :: BinTree -> Int -> Bool<br>
            contains E i = False<br>
            contains (N l v r) i<br>
            &nbsp;&nbsp;| v == i = True<br>
            &nbsp;&nbsp;| v < i = contains r i<br>
            &nbsp;&nbsp;| otherwise = contains l i<br>
            <br>
            showT :: BinTree -> String<br>
            showT E = "*"<br>
            showT (N l v r) = "[" ++ showT l ++ "]" ++ " " ++ show v ++" " ++ "[" ++ showT r ++ "]"<br>
            <br>
            listTree :: BinTree -> [Int]<br>
            listTree E = []<br>
            listTree (N l v r) = v:(listTree l ++ listTree r)<br>
          </div>
        </p>
      <li>
        <h3>Welche durchschnittliche Höhe hat ein Binärbaum?</h3>
        <p>
          <span class="comment">Höhe ist logarithmisch, aber warum? &rarr; s. gprot18</span>
          Die mittlere Weglänge im Baum ist die Summe der Weglängen zu den Knoten durch die Anzahl der Knoten.<br>
          Die Höhe eines vollständigen binären Baumes wächst nur logarithmisch mit der Knotenzahl.
        </p>
      </li>
      <li>
        <h3>Implementieren Sie einen Binärbaum in Java (ADT)</h3>
        <p>
          <div id="syntax">
            class Node {<br>
              <br>
            &nbsp;&nbsp;protected Comparable  value;<br>
            &nbsp;&nbsp;protected Node        left;<br>
            &nbsp;&nbsp;protected Node        right;<br>
              <br>
            &nbsp;&nbsp;public Node(Comparable value, Node left, Node right) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;this.value  = value;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;this.left   = left;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;this.right  = right;<br>
            &nbsp;&nbsp;}<br>
            }<br>
            <br>
            public class BinTree implements BinaryTree {<br>
              <br>
            &nbsp;&nbsp;private Node root;<br>
              <br>
            &nbsp;&nbsp;public BinTree(Node root) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;this.root = root;<br>
            &nbsp;&nbsp;}<br>
              <br>
            &nbsp;&nbsp;public void insert(Comparable value) {<br>
                <br>
            &nbsp;&nbsp;&nbsp;&nbsp;Node temp = root;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;Node parent = null;<br>
                <br>
            &nbsp;&nbsp;&nbsp;&nbsp;while (temp != null) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;parent = temp;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (value.compareTo(temp.value) < 0) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;temp = temp.left;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;else {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;temp = temp.right;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
            &nbsp;&nbsp;&nbsp;&nbsp;}<br>
                <br>
            &nbsp;&nbsp;&nbsp;&nbsp;if (parent != null) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (value.compareTo(parent.value) > 0) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;parent.right = new Node(value, null, null);<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;else {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;parent.left = new Node(value, null, null);<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
            &nbsp;&nbsp;&nbsp;&nbsp;}<br>
            &nbsp;&nbsp;}<br>
            }
          </div>
        </p>
      </li>
      <li>
        <h3>Wann ist ein Binärbaum entartet?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Was ist ein AVL-Baum, welche Vor-und Nachteile hat er gegenüber einem Binärbaum?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Was ist ein B-Baum?</h3>
        <p>
          B-Bäume sind Mehrweg-Suchbäume. Alle Blätter eines B-Baums haben die gleiche Tiefe. (Baum ist vollständig.)<br>
          2-3-Bäume bzw. 2-4-Bäume sind B-Bäume der Ordnung 3 bzw. 4. Die 2 gibt die minimale Anzahl der Kinder pro Knoten an.
        </p>
      </li>
      <li>
        <h3>Sind B-Bäume binär?</h3>
        <p>
          Nein, es handelt sich ja um Mehrwegbäume. Ein B-Baum kann aber den Aufbau eines Binärbaums haben &rarr; jeder Knoten hat höchstens zwei Kinder.
        </p>
      </li>
      <li>
        <h3>Warum ist ein B-Baum ausgeglichen?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Was ist ein Rot-Schwarz-Baum?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Was sind die zwei wichtigsten Möglichkeiten, um Graphen zu speichern?</h3>
        <p>
          Adjazenzliste (Knotenliste), Adjazenzmatrix
        </p>
      </li>
    </ol>
  </p>
  
  
  <h2>Abstrakte Datentypen &amp; Programmierung</h2>
  <p>
    <ol>
      <li>
        <h3>Was sind abstrakte Datentypen, worin liegen ihre Vorteile</h3>
        <p>
          Abstrakte Datentypen beschreiben Wertemengen ausschließlich durch die darauf zulässigen Operationen.<br>
          Datenabstraktion ist die Anwendung des Geheimnisprinzips auf Datenstrukturen. Bestimmte Programmteile sind für den Benutzer nicht sichtbar, bzw. der Zugriff nicht gestattet. Man abstrahiert von der Implementierung und charakterisiert die Datenstruktur über die Operationen auf ihr. (Der Zugriff erfolgt dann nur noch über eine Schittstelle.)
        </p>
      </li>
      <li>
        <h3>Was ist Polymorphie?</h3>
        <p>
          Man unterscheidet Universelle Polymorphie (mit Inklusions- und Parametrischer Polymorpie) und Ad-hoc-Polymorphie (&rarr; gleiche Funktionsnamen mit verschiedenen formalen Parametern).
        </p>
      </li>
      <li>
        <h3>Stellen Klassen in Java ADTs dar?</h3>
        <p>
          Können, müssen aber nicht. (&rarr; s. 1.)
        </p>
      </li>
      <li>
        <h3>Was ist Hashing?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Implementieren Sie eine Menge mit Hashes und offener Adressierung</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Was für Parameterübergabe-Mechanismen gibt es?</h3>
        <p>
          Call-by-value, Call-by-reference, Call-by-result (=Call-by-value-return), Call-by-name. (<i>+Erklärung</i>)
        </p>
      </li>
      <li>
        <h3>Welchen Parameterübergabe-Mechanismus nutzt Java?</h3>
        <p>
          Call-by-value für primitive Datentypen, Call-by-reference für Objekte.
        </p>
      </li>
      <li>
        <h3>Was ist <i>lazy evaluation</i>?</h3>
        <p>
          Bei der <i>verzögerten Auswertung</i> wird ein Ausdruck erst dann durch seinen Wert ersetzt, wenn er gebraucht wird. Dadurch lassen sich z.B. in Haskell unendlich große Datenstrukturen definieren (<span id="syntax">liste = 'a':liste</span>). <span class="comment">&rarr; s. gprot40</span>
        </p>
      </li>
      <li>
        <h3>Was ist <i>late binding</i>?</h3>
        <p>
          Dynamische Typzuordnung zur Laufzeit (&rarr; Polymorphie)
        </p>
      </li>
      <li>
        <h3>Was ist das Factory Pattern?</h3>
        <p>
          Ein <i>design pattern</i> zur Entkoppelung von der Implementierung - nur die Funktionalität ist wichtig.
        </p>
      </li>
      <li>
        <h3>Implemetieren Sie die Fakultätsfunktion in Haskell</h3>
        <p>
          <div id="syntax">
            fak 0 = 1<br>
            fak x = x * fak(x-1)<br>
          </div>
        </p>
      </li>
      <li>
        <h3>Wie kann man die Fakultätsfunktion noch einfacher implementieren? (&rarr; Endrekursion)</h3>
        <p>
          <div id="syntax">
            fak2 x = faka x 1<br>
            &nbsp;where faka 0 a = a<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;faka x a = faka (x-1) (a*x)
          </div>
        </p>
      </li>
      <li>
        <h3>Wie kann man diese Funktion entrekursieren?</h3>
        <p>
          <div id="syntax">
            int fak(int x) {<br>
            &nbsp;&nbsp;int akk = 1;<br>
            &nbsp;&nbsp;while (x > 1) {<br>
            &nbsp;&nbsp;&nbsp;&nbsp;akk = akk * x;<br>
            &nbsp;&nbsp;&nbsp;&nbsp;x--;<br>
            &nbsp;&nbsp;}<br>
            }
          </div>
        </p>
      </li>
    </ol>
  </p>
  
  
  <h2>Laufzeit</h2>
  <p>
    <ol>
      <li>
        <h3>Was ist Laufzeit?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Definition der Laufzeit?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Warum ist die Laufzeit von Quicksort im schlechtesten Fall O(n²)?</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Was besagt die Church'sche These?</h3>
        <p>
        </p>
      </li>
    </ol>
  </p>
  
  
  <h2>Algorithmen</h2>
  <p>
    <ol>
      <li>
        <h3>Was ist ein Greedy-Algorithmus?</h3>
        <p>
          Das Prinzip des Greedy-Algorithmus ist es, in jedem Teilschritt so viel wie möglich zu erreichen (lokales Optimum). Unter Umständen wird dadurch jedoch das globale Optimum nicht erreicht.(<i>Bsp.: Wechselgeld</i>)
        </p>
      </li>
      <li>
        <h3>Was ist der Dijkstra-Algorithmus?</h3>
        <p>
          Algorithmus zum finden kürzester Wege in Graphen. (<i>+Erklärung</i>)
        </p>
      </li>
      <li>
        <h3>Was ist der Kruskal-Algorithmus?</h3>
        <p>
          Algorithmus zum finden des kleinsten aufspannenden Baums. (<i>+Erklärung</i>)
        </p>
      </li>
      <li>
        <h3>Was ist der Algorithmus von Prim?</h3>
        <p>
         Auch ein Algorithmus zum finden des kleinsten aufspannenden Baums. (<i>+Erklärung</i>)
        </p>
      </li>
      <li>
        <h3>Was ist der Huffman-Algorithmus?</h3>
        <p>
         Ein Algorithmus zum finden einer optimalen Binärcodierung von Zeichen. Erzeugt wird ein sog. kommafreier Präfixcode. (<i>+Erklärung</i>)
        </p>
      </li>
    </ol>
  </p>
  
  
  <h2>Rekursion</h2>
  <p>
    <ol>
      <li>
        <h3>Welche Arten von Rekursion gibt es?</h3>
        <p>
          Linare Rekursion und nicht lineare Rekursion. Bei der linearen Rekursion unterscheidet man noch endrekursive und nicht endrekursive Funktionen.
        </p>
      </li>
    </ol>
  </p>
  
  
  <h2>Spezifikation</h2>
  <p>
    <ol>
      <li>
        <h3>Was ist eine Spezifikation und wie kann man Spezifizieren?</h3>
        <p>
          Modellierende / algebraische Spezifikation
        </p>
      </li>
      <li>
        <h3>Was ist der Nachteil der modellierenden gegenüber der axiomatischen Spezifikation?</h3>
        <p>
          Man legt sich bereits auf eine Implementierung fest.
        </p>
      </li>
      <li>
        <h3>Spezifizieren Sie einen Stack (algebraisch &amp; modellierend)</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Spezifizieren Sie eine Schlange algebraisch</h3>
        <p>
        </p>
      </li>
      <li>
        <h3>Wie kann man die Korrektheit eines imperativen Programms (Java) beweisen?</h3>
        <p>
          Verifikation mit Hoare Kalkül &rarr; Vorbedingung {P} wird in Nachbedingung {Q} überführt.<br>
          {P} S {Q} mit Zuweisungsaxiom {P}x = e{P[e/x]} &rarr; alles was vorher für e galt, gilt jetzt für x
        </p>
      </li>
      <li>
        <h3>Ist der Algorithmus dann korrekt?</h3>
        <p>
          ...partielle Korrektheit nachgewiesen, totale Korrektheit mit Terminierungsfunktion...
        </p>
      </li>
      <li>
        <h3>Was kann man nicht automatisch beweisen?</h3>
        <p>
          Die Invariante
        </p>
      </li>
    </ol>
  </p>
  
  
  <h2>Sonstiges</h2>
  <p>
    <ol>
      <li>
        <h3></h3>
        <p>
        </p>
      </li>
    </ol>
  </p>
  
  
  
  
</body>
</html>