Inital commit
This commit is contained in:
Tilman
Binary file not shown.
|
After Width: | Height: | Size: 2.4 KiB |
@@ -0,0 +1,97 @@
|
||||
|
||||
interface Queue {
|
||||
|
||||
public void enqueue(Object o) throws Exception;
|
||||
|
||||
public Object dequeue();
|
||||
|
||||
public boolean isFull();
|
||||
|
||||
}
|
||||
|
||||
|
||||
// Implementiert eine Schlange mit einem Array, der
|
||||
// eine Art Kreis simuliert
|
||||
class ArrayQueue implements Queue {
|
||||
|
||||
Object[] ar;
|
||||
int start = 0;
|
||||
int elements = 0;
|
||||
|
||||
public ArrayQueue(int capacity) {
|
||||
|
||||
ar = new Object[capacity];
|
||||
|
||||
}
|
||||
|
||||
public void enqueue(Object o) throws Exception {
|
||||
|
||||
if (!isFull()) {
|
||||
|
||||
ar[(start + elements) % ar.length] = o;
|
||||
elements++;
|
||||
|
||||
}
|
||||
else throw new Exception("Queue is full.");
|
||||
|
||||
}
|
||||
|
||||
public Object dequeue() {
|
||||
|
||||
if (elements > 0) {
|
||||
|
||||
elements--;
|
||||
|
||||
int i = start;
|
||||
start = (start+1) % ar.length;
|
||||
|
||||
return ar[i];
|
||||
|
||||
}
|
||||
|
||||
// alternativ könnte man auch eine Exception werfen
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
// pre: elements <= ar.length
|
||||
public boolean isFull() {
|
||||
return (elements == ar.length);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
Queue st = new ArrayQueue(3);
|
||||
|
||||
try {
|
||||
st.enqueue(new Integer(1));
|
||||
st.enqueue(new Integer(2));
|
||||
st.enqueue(new Integer(3));
|
||||
|
||||
// der wirft 'ne Exception
|
||||
st.enqueue(new Integer(4));
|
||||
}
|
||||
catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
// dann nehmen wir den ersten wieder raus
|
||||
System.out.println((Integer) st.dequeue());
|
||||
|
||||
try {
|
||||
// jetzt passe die 4 auch noch rein
|
||||
st.enqueue(new Integer(4));
|
||||
}
|
||||
catch (Exception e) {
|
||||
// won't happen
|
||||
}
|
||||
|
||||
System.out.println((Integer) st.dequeue());
|
||||
System.out.println((Integer) st.dequeue());
|
||||
System.out.println((Integer) st.dequeue());
|
||||
|
||||
// jetzt ist der Stack leer
|
||||
System.out.println((Integer) st.dequeue());
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
|
||||
interface Stack {
|
||||
|
||||
public void push(Object o) throws Exception;
|
||||
|
||||
public Object pop();
|
||||
|
||||
public Object peek();
|
||||
|
||||
public boolean isFull();
|
||||
|
||||
}
|
||||
|
||||
|
||||
class ArrayStack implements Stack {
|
||||
|
||||
Object[] ar;
|
||||
int index = 0;
|
||||
|
||||
public ArrayStack(int capacity) {
|
||||
|
||||
ar = new Object[capacity];
|
||||
|
||||
}
|
||||
|
||||
public void push(Object o) throws Exception {
|
||||
|
||||
if (!isFull()) {
|
||||
|
||||
ar[index] = o;
|
||||
index++;
|
||||
|
||||
}
|
||||
else throw new Exception("Stack is full.");
|
||||
|
||||
}
|
||||
|
||||
public Object pop() {
|
||||
|
||||
if (index > 0) {
|
||||
|
||||
index--;
|
||||
return ar[index];
|
||||
|
||||
}
|
||||
|
||||
// alternativ könnte man auch eine Exception werfen
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
public Object peek() {
|
||||
|
||||
if (index > 0) {
|
||||
|
||||
return ar[index-1];
|
||||
|
||||
}
|
||||
|
||||
// alternativ könnte man auch eine Exception werfen
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
// pre: index <= ar.length
|
||||
public boolean isFull() {
|
||||
return (index == ar.length);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
Stack st = new ArrayStack(3);
|
||||
|
||||
try {
|
||||
st.push(new Integer(1));
|
||||
st.push(new Integer(2));
|
||||
st.push(new Integer(3));
|
||||
|
||||
// der wirft 'ne Exception
|
||||
st.push(new Integer(4));
|
||||
}
|
||||
catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
System.out.println((Integer) st.pop());
|
||||
System.out.println((Integer) st.pop());
|
||||
|
||||
// die 1 kommt doppelt
|
||||
System.out.println((Integer) st.peek());
|
||||
System.out.println((Integer) st.pop());
|
||||
|
||||
// jetzt ist der Stack leer
|
||||
System.out.println((Integer) st.pop());
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
/*
|
||||
* Eine Knoten-Klasse für die Implementierung von Bäumen.
|
||||
* Hab's mal ganz edel mit Comparables statt einfach mit
|
||||
* int-Werten gemacht.
|
||||
*/
|
||||
class Node {
|
||||
|
||||
/*
|
||||
* Wir definieren alle unsere Bäume in derselben Package,
|
||||
* deswegen sind die Variablen durch das protected-Attribut
|
||||
* vor Zugriff von außen (aus anderen Packages) geschützt.
|
||||
* Man könnte auch "ordentlich" kapseln und Getter- & Setter-
|
||||
* Methoden verwenden, was den Code aber extrem aufblähen
|
||||
* würde.
|
||||
*/
|
||||
protected Comparable value; // Wert
|
||||
protected Node left; // linker Kind-Knoten
|
||||
protected Node right; // rechter Kind-Knoten
|
||||
|
||||
|
||||
public Node(Comparable value, Node left, Node right) {
|
||||
this.value = value;
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Dieses Interface dient dazu, Baumimplementierungen vor
|
||||
* "unqualifizierten" Zugriffen von außen zu schützen. (Damit
|
||||
* z.B. nicht irgendwelche Knoten direkt in die Datenstruktur
|
||||
* eingefügt werden, ohne die Sortierung zu beachten, etc.
|
||||
*/
|
||||
interface BinaryTree {
|
||||
|
||||
public void insert(Comparable value);
|
||||
|
||||
public void remove(Comparable value);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Eine Implementierung des BinaryTree-Interface
|
||||
*/
|
||||
public class BinTree implements BinaryTree {
|
||||
|
||||
Node root;
|
||||
|
||||
public BinTree(Node root) {
|
||||
this.root = root;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Fügt ein Element in den Binärbaum ein.
|
||||
* (Mehrfaches einfügen ist erlaubt.)
|
||||
*/
|
||||
public void insert(Comparable value) {
|
||||
|
||||
Node temp = root;
|
||||
Node parent = null;
|
||||
|
||||
while (temp != null) {
|
||||
|
||||
parent = temp;
|
||||
|
||||
if (value.compareTo(temp.value) < 0) {
|
||||
temp = temp.left;
|
||||
}
|
||||
else {
|
||||
temp = temp.right;
|
||||
}
|
||||
}
|
||||
|
||||
if (parent != null) {
|
||||
if (value.compareTo(parent.value) > 0) {
|
||||
parent.right = new Node(value, null, null);
|
||||
}
|
||||
else {
|
||||
parent.left = new Node(value, null, null);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Ersetzt das zu löschende Element mit dem
|
||||
* größten Element aus dem linken Unterbaum
|
||||
*/
|
||||
public void remove(Comparable value) {
|
||||
|
||||
Node temp = root;
|
||||
Node parent = null;
|
||||
|
||||
// Knoten suchen
|
||||
while ((temp != null) && (temp.value.compareTo(value) != 0)) {
|
||||
|
||||
parent = temp;
|
||||
|
||||
if (value.compareTo(temp.value) < 0) {
|
||||
temp = temp.left;
|
||||
}
|
||||
else {
|
||||
temp = temp.right;
|
||||
}
|
||||
}
|
||||
|
||||
// wenn gefunden, Knoten löschen
|
||||
if (temp != null) {
|
||||
|
||||
// wenn linker Unterbaum existiert, mit größtem Element daraus ersetzen
|
||||
if (temp.left != null) {
|
||||
|
||||
Node temp2 = temp.left; // der Knoten, der nach oben versetzt wird
|
||||
Node parent2 = temp; // der Elternknoten von dem, der nach oben versetzt wird
|
||||
|
||||
while (temp2.right != null) {
|
||||
parent = temp2;
|
||||
temp2 = temp2.right;
|
||||
}
|
||||
|
||||
if (temp2 != temp.left) temp2.left = temp.left;
|
||||
temp2.right = temp.right;
|
||||
parent2.right = temp2.left;
|
||||
|
||||
if (parent.left == temp) {
|
||||
parent.left = temp2;
|
||||
}
|
||||
else {
|
||||
parent.right = temp2;
|
||||
}
|
||||
|
||||
}
|
||||
else { // sonst einfach mit rechtem Unterbaum ersetzen
|
||||
|
||||
if (parent.left == temp) {
|
||||
parent.left = temp.right;
|
||||
}
|
||||
else {
|
||||
parent.right = temp.right;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Gibt den Baum als AVL-Baum zurück
|
||||
*/
|
||||
public static BinTree getAvlTree(BinTree b) {
|
||||
// TODO
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Wir überschreiben die toString-Methode von
|
||||
* Object, damit sich der Baum leicht ausgeben lässt
|
||||
* (s. main-Methode).
|
||||
*
|
||||
* ACHTUNG: Die Methode is HÖLLE langsam, weil massen-
|
||||
* haft Strings konkateniert werden. Schnell implementiert,
|
||||
* aber extrem unperformant.
|
||||
*/
|
||||
public String toString() {
|
||||
|
||||
return getTreeAsString(root);
|
||||
}
|
||||
|
||||
private String getTreeAsString(Node n) {
|
||||
|
||||
if (n != null) {
|
||||
//System.out.println(n.value);
|
||||
return "(" + getTreeAsString(n.left) + ") " + n.value + " (" + getTreeAsString(n.right) + ")";
|
||||
}
|
||||
|
||||
return "*";
|
||||
}
|
||||
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
/*
|
||||
* Also - Bau'n wir'n Baum:
|
||||
*
|
||||
* 10
|
||||
* .----------'---------.
|
||||
* 7 12
|
||||
* .----'----. .----'----.
|
||||
* 5 9 11 15
|
||||
* .-' .-'
|
||||
* 2 8
|
||||
*
|
||||
* ...und dann löschen wir die 7:
|
||||
*
|
||||
* 10
|
||||
* .----------'---------.
|
||||
* 5 12
|
||||
* .----'----. .----'----.
|
||||
* 2 9 11 15
|
||||
* .--'
|
||||
* 8
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
BinTree tree = new BinTree( new Node(new Integer(10), null, null) );
|
||||
|
||||
tree.insert(new Integer(7));
|
||||
tree.insert(new Integer(12));
|
||||
tree.insert(new Integer(5));
|
||||
tree.insert(new Integer(9));
|
||||
tree.insert(new Integer(11));
|
||||
tree.insert(new Integer(15));
|
||||
tree.insert(new Integer(2));
|
||||
tree.insert(new Integer(8));
|
||||
|
||||
System.out.println(tree);
|
||||
|
||||
tree.remove(new Integer(7));
|
||||
|
||||
System.out.println(tree);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
<!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>Spezifikation</title>
|
||||
</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>Spezifikation</h1>
|
||||
|
||||
<h2>Algebraische Spezifikation</h2>
|
||||
Abstrakte Datentypen werden festgelegt durch:<br><br>
|
||||
1. Syntax: Typen (types), Signaturen der Operationen (operations)<br>
|
||||
2. Semantik: Definierende Gleichungen (axioms), die Beziehungen zwischen den Operationen festlegen (und evtl. preconditions)<br><br>
|
||||
Die praktische Relevanz der Algebraischen Spezifikation ist eher gering, da es oft schwierig ist, Axiome zu
|
||||
finden bzw. die Vollständigkeit oder Redundanz der Axiome zu überprüfen.<br><br>
|
||||
einige algebraische Spezifikationen: <a href="algebraischeSpez.txt">Beispiele</a><br>
|
||||
und noch mehr <a href="algebraischeSpez2.txt">Beispiele</a>
|
||||
<br><br>
|
||||
|
||||
<h2>Modellierende Spezifikation</h2>
|
||||
|
||||
Abstrakte Datentypen werden festgelegt durch:<br><br>
|
||||
1. Typen: Wertemengen<br>
|
||||
2. Methoden: Kopf oder Signaturen inkl. pre- und postconditions (ggf. return/result)<br>
|
||||
3. Modell: mathematische Mengen, Folgen, (funktionale) Programmiersprache<br>
|
||||
4. Invariante: Modell muss bestimmte Invariante erfüllen<br>
|
||||
Die Spezifikation kann über Mittel der Prädikatenlogik, (Pseudo)-Code oder nat¨urliche Sprache erfolgen.<br><br>
|
||||
einige modellierende Spezifikationen: <a href="modelSpez.txt">Beispiele</a><br><br>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.vameo.de/uni/tutorium/adt.pdf">Merkblatt zu abstrakte Datentypen und Spezifikation von Augustin</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,56 @@
|
||||
<!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>Abstrakte Datentypen</title>
|
||||
</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>Abstrakter Datentyp (ADT)</h1>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
Eng verknüpft mit dem Begriff der Schnittstelle ist das Konzept des abstrakten Datentyps (ADT). Ein ADT besteht aus<br><br>
|
||||
|
||||
* einer Menge von Objekten, und<br>
|
||||
* einem Satz von Operationen auf dieser Menge, sowie<br>
|
||||
* einer genauen Beschreibung der Semantik der Operationen.<br><br>
|
||||
|
||||
Das Konzept des ADT ist unabhängig von einer Programmiersprache, die Beschreibung kann in natürlicher Sprache abgefasst werden.<br><br>
|
||||
|
||||
Der ADT beschreibt <i><b>was</i></b> die Operationen tun, aber nicht <i><b>wie</i></b> sie das tun. Getreu dem Prinzip der versteckten Information ist die Realisierung nicht Teil des ADT.<br><br>
|
||||
|
||||
Vom Standpunkt des Abstraktionsgedankens aus ist der ADT ein mächtigeres Konzept als die Funktion.<br><br>
|
||||
|
||||
<b>Man unterscheidet</b><br>
|
||||
|
||||
* konkrete Datentypen: als Datentypen, die im allgemeinen aus Basisdatentypen konstruiert werden.<br>
|
||||
* abstrakte Datentypen: als Beschreibung von Schnittstellen zu Datenstrukturen mit ihren Operationen, die unabhängig von ihrer Implementation (in einer konkreten Programmiersprache) vorgenommen wird.<br><br>
|
||||
|
||||
Ein abstrakter Datentyp stellt in der Regel eine Zusammenfassung dar, z.B. als Programmmodul. Dabei werden folgende allgemeine Prinzipien berücksichtigt:<br><br>
|
||||
* <b>Kapselung</b>: Die Operationen des Datentyps werden über eine wohldefinierte Schnittstelle benutzt.<br>
|
||||
* <b>Geheimnisprinzip</b> (Information Hiding): Die interne Realisierung bleibt dem Anwender verborgen.<br><br>
|
||||
|
||||
<b>Anderes ausgedrückt</b>:<br>
|
||||
Ein abstrakter Datentyp (ADT) ist ein Schema, zur Bildung geschützter Variablen.<br><br>
|
||||
|
||||
<b>Ein ADT besteht aus</b>:<br><br>
|
||||
|
||||
* dem Namen des Typs, dessen innere Struktur nicht sichtbar ist.<br>
|
||||
* der Menge der zulässigen Operationen auf Objekten dieses Typs<br><br>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
<h2>Links</h2>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,32 @@
|
||||
<!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>Abstraktionsprinzip</title>
|
||||
</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>Abstraktionsprinzip</h1>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
<b>Abstraktionsfunktion</b>: legt explizit fest, welchem abstrakten Wert ein konkreter, erlaubter Wert der gewählten Repräsentation entspricht.
|
||||
<br>
|
||||
<b>Repräsentationsinvariante</b>: macht alle Annahmen, die der Implementierung der Operationen des ADT zugrund liegen explizit und definiert die erlaubten Werte.
|
||||
|
||||
<h2>Links</h2>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,62 @@
|
||||
<!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>Adjazenzmatrix und Adjazenzliste</title>
|
||||
</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>Darstellungen von Graphen</h1>
|
||||
|
||||
<div class="quelle">Grafiken entnommen aus Saake, Sattler: "Algorithmen & Datenstrukturen"</div>
|
||||
|
||||
<h2>Adjazenzmatrix</h2>
|
||||
Insbesondere bei sehr vielen Kanten ist eine Speicherung der Verbindung als nxn-Matrix sinnvoll, wobei n = Knotenanzahl |V|. Eine derartige Matrix wird als <b>Adjazenzmatrix</b> bezeichnet.<br>
|
||||
Gibt es eine Kante von Knoten a zu Knoten b, wird in der Matrix in der a-ten Zeile an der b-ten Stelle ein True bzw. eine 1 eingetragen.<br><br>
|
||||
|
||||
<b>Beispiel eines gerichteten Graphen</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="gerichtetergraph.gif"></td>
|
||||
<td><img src="gg.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<br><br>
|
||||
<b>Beispiel eines ungerichteten Graphen</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="ungerichtetergraph.gif"></td>
|
||||
<td><img src="gu.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<br>
|
||||
Bei ungerichteten Graphen muss eigentlich nur die Hälfte gespeichert werden, da sich die andere Hälfte durch Spiegelung ergibt.
|
||||
<br><br>
|
||||
|
||||
<h2>Adjazenzliste</h2>
|
||||
Die Möglichkeit einen Graphen in einer dynamischen Datenstrucktur zu realisieren ist zum Beispiel die <b>Adjazenzliste</b>.<br>
|
||||
Ein Graph wird dabei durch |V| + 1 verkette Listen dargestellt. Die Basisstruktur bildet die Liste aller Knoten. Für jeden Knoten wird eine Liste der Nachfolger entlnag gerichteter Kanten abgespeichert.<br><br>
|
||||
|
||||
<b>Beispiel eines gerichteten Graphen</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="gerichtetergraph.gif"></td>
|
||||
<td><img src="adjazenzliste.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 4.7 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 7.0 KiB |
@@ -0,0 +1,121 @@
|
||||
Algebraische Spezifikation
|
||||
|
||||
Stack
|
||||
|
||||
- types
|
||||
Stack, t, Bool
|
||||
|
||||
- operators
|
||||
createStack :: Stack
|
||||
push :: t -> Stack -> Stack
|
||||
pop :: Stack -> Stack
|
||||
top :: Stack -> t
|
||||
isEmpty :: Stack -> Bool
|
||||
|
||||
- axioms
|
||||
s of type Stack, x of type t
|
||||
|
||||
isEmpty(createStack) = True
|
||||
isEmpty(push x s) = False
|
||||
|
||||
top(push x s) = x
|
||||
pop(push x s) = s
|
||||
|
||||
- preconditions
|
||||
top: isEmpty s == False
|
||||
pop: isEmpty s == False
|
||||
|
||||
Queue
|
||||
|
||||
- types
|
||||
Queue, t, Bool
|
||||
|
||||
- operators
|
||||
createQueue :: Queue
|
||||
enqueue :: t -> Queue -> Queue
|
||||
dequeue :: Queue -> Queue
|
||||
first :: Queue -> t
|
||||
isEmpty :: Queue -> Bool
|
||||
|
||||
- axioms
|
||||
q of type Queue, x of type t
|
||||
|
||||
isEmpty(createQueue) = True
|
||||
isEmpty(enqueue x q) = False
|
||||
|
||||
first(enqueue x createQueue) = x
|
||||
first(enqueue x q) = first q
|
||||
|
||||
dequeue (enqueue x q) = enqueue x (dequeue q)
|
||||
|
||||
- preconditions
|
||||
first : isEmpty q == False
|
||||
dequeue: isEmpty q == False
|
||||
|
||||
|
||||
Menge
|
||||
|
||||
- types
|
||||
Set, t, Bool
|
||||
|
||||
- operators
|
||||
createSet :: Set
|
||||
insert :: t -> Set -> Set
|
||||
delete :: t -> Set -> Set
|
||||
isElement :: t -> Set -> Bool
|
||||
isEmpty :: Set -> Bool
|
||||
|
||||
- axioms
|
||||
s of type Set, x,y of type t
|
||||
|
||||
isEmpty(createSet) = True
|
||||
isEmpty(insert x s) = False
|
||||
|
||||
delete(createSet) = createSet
|
||||
delete x (insert y s)
|
||||
| (x == y) = s
|
||||
| otherwise = insert y (delete x s)
|
||||
|
||||
isElement x (createSet) = False
|
||||
isElement x (insert y s)
|
||||
| (x == y) = True
|
||||
| otherwise = isElement x s
|
||||
|
||||
- preconditions
|
||||
|
||||
Priority Queue
|
||||
|
||||
- types
|
||||
PQueue, t, Bool
|
||||
|
||||
- operators
|
||||
createPQueue :: PQueue
|
||||
enqueue :: t -> PQueue -> PQueue
|
||||
dequeue :: PQueue -> PQueue
|
||||
min :: PQueue -> t
|
||||
isEmpty :: PQueue -> Bool
|
||||
|
||||
- axioms
|
||||
q of type PQueue, x of type t
|
||||
|
||||
isEmpty(createQueue) = True
|
||||
isEmpty(enqueue x q) = False
|
||||
|
||||
min(enqueue x createPQueue) = x
|
||||
|
||||
dequeue(enqueue x createPQueue) = createPQueue
|
||||
|
||||
if (x < min q) then min(enqueue x q) = x
|
||||
else min(enqueue x q) = min q
|
||||
|
||||
min(enqueue x q)
|
||||
| (x < min q) = x
|
||||
| otherwise = min q
|
||||
|
||||
dequeue(enqueue x q)
|
||||
| (x < min q) = q
|
||||
| otherwise = enqueue(x (dequeue q))
|
||||
|
||||
- preconditions
|
||||
min : isEmpty q == False
|
||||
dequeue: isEmpty q == False
|
||||
@@ -0,0 +1,162 @@
|
||||
1a. alg. Menge (Haskell data)
|
||||
2a. alg. Queue (Haskell data)
|
||||
3a. alg. Stack (Haskell data)
|
||||
4a. alg. Baum (Haskell data)
|
||||
|
||||
|
||||
|
||||
1a. Algebraische Spezifikation einer Menge (types,operators,axioms)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
types : Menge m,m,Bool //Menge,element,Bool
|
||||
|
||||
data Menge m = E | (In m (Menge m)) //Empty | Menge mit e
|
||||
|
||||
operators : createM :: Menge m
|
||||
isEmpty :: Menge m -> Bool
|
||||
insert :: m -> Menge m -> Menge m
|
||||
delete :: m -> Menge m -> Menge m
|
||||
isIn :: m -> Menge m -> Bool
|
||||
|
||||
Alle x <- m , s <- Menge m
|
||||
|
||||
axioms : createM () = E
|
||||
|
||||
isEmpty (E) = True
|
||||
isEmpty (insert x s) = False
|
||||
|
||||
insert (x,E) = (In x E) //x:E
|
||||
insert (x,s)
|
||||
| isIn (x,s) = s
|
||||
| otherwise = (In x s) //x:M
|
||||
|
||||
delete (x,E) = E
|
||||
delete (y,(In x m))
|
||||
|y == x = m
|
||||
|otherwise = Insert x (delete (y,m))
|
||||
|
||||
isIn (x,E) = False
|
||||
isIn (y,(In x m))
|
||||
|y == x = True
|
||||
|otherwise = isIn (y,m)
|
||||
|
||||
|
||||
2a. Algebraische Spezifikation einer Schlange (types,operators,axioms)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
types : Queue q,q,Bool //Schlange,element,Bool
|
||||
|
||||
data Queue q = E | NeQ q (Queue q) //Empty | Queue mit elem
|
||||
|
||||
operators : createQ :: Queue q
|
||||
isEmpty :: Queue q -> Bool
|
||||
enqueue :: q -> Queue q -> Queue q
|
||||
dequeue :: Queue q -> Queue q
|
||||
first :: Queue q -> q
|
||||
|
||||
Alle x <- q, s <- Queue q
|
||||
|
||||
axioms : createQ () = E
|
||||
|
||||
isEmpty (E) = True
|
||||
isEmpty (s) = False
|
||||
|
||||
enqueue (x,s) = (NeQ x s)
|
||||
|
||||
dequeue (NeQ x s) = s
|
||||
|
||||
first (NeQ x s) = x
|
||||
|
||||
|
||||
|
||||
3a. Algebraische Spezifikation eines Stacks (types,operators,axioms)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
types Stack,e,Bool,int
|
||||
|
||||
data Stack s = E | NeS e (Stack s)
|
||||
|
||||
operators : createS :: Stack s
|
||||
isEmpty :: Stack s -> Bool
|
||||
push :: e -> Stack s -> Stack s
|
||||
pop :: Stack s -> Stack s
|
||||
top :: Stack s -> e
|
||||
size :: Stack s -> int
|
||||
|
||||
axioms : create () = E
|
||||
|
||||
isEmpty (E) = True
|
||||
isEmpty (NeS x s) = False
|
||||
|
||||
push (x,s) = (NeS x s)
|
||||
|
||||
pop (E) = error "Stack ist leer!"
|
||||
pop (NeS x s) = s
|
||||
|
||||
top (E) = error "Stack ist leer!"
|
||||
top (NeS x s) = x
|
||||
|
||||
size (E) = 0
|
||||
size (NeS x s) = 1 + size(s)
|
||||
|
||||
|
||||
|
||||
4a. Algebraische Spezifikation eines Baumes (types,operators,axioms)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
types BTree,n,Bool,int
|
||||
|
||||
data BTree t = E | N (BTree t) t (BTree t)
|
||||
|
||||
operators : insert :: n -> BTree t -> BTree t
|
||||
delete :: n -> BTree t -> BTree t
|
||||
hoehe :: BTree t -> int
|
||||
isIn :: t -> BTree t -> Bool
|
||||
isEmpty :: BTree t -> Bool
|
||||
leftTree :: BTree t -> BTree t
|
||||
rightTree :: BTree t -> BTree t
|
||||
|
||||
axioms : insert x E = (N E x E)
|
||||
insert x (N l v r)
|
||||
| x == v = (N l x r)
|
||||
| x < v = (N (insert x l) v r)
|
||||
| x > v = (N l v (insert x r))
|
||||
|
||||
delete :: (Ord t) => t -> BTree t -> BTree t
|
||||
delete x E = error "ist bereits leer"
|
||||
delete y (N E x E)
|
||||
| y == x = E
|
||||
| otherwise = (N E x E)
|
||||
delete y (N l x r)
|
||||
| y < x = (N (delete y l) x r)
|
||||
| y > x = (N l x (delete y r))
|
||||
| (l==E)&&(x==y)= r
|
||||
| (r==E)&&(x==y)= l
|
||||
| y == x = (N (delete (maxi l) l)(maxi l) r)
|
||||
|
||||
where max :: BTree t -> t
|
||||
max (N E x E) = x
|
||||
max (N l v r) = max l
|
||||
|
||||
hoehe E = 0
|
||||
hoehe (N E x E) = 1
|
||||
hoehe (N l v r) = 1 + max (hoehe l)(hoehe r)
|
||||
|
||||
where max :: int -> int
|
||||
max x y
|
||||
| x <= y = y
|
||||
|otherwise = x
|
||||
|
||||
isIn x E = False
|
||||
isIn x (N l v r)
|
||||
| x == v = True
|
||||
| otherwise = (isIn x l) || (isIn x r)
|
||||
|
||||
isEmpty E = True
|
||||
isEmpty t = False
|
||||
|
||||
leftTree E = error "alles Leer -> links auch"
|
||||
leftTree (N l v r) = l
|
||||
|
||||
rightTree E = error "alles Leer -> rechts auch"
|
||||
rightTree (N l v r) = r
|
||||
@@ -0,0 +1,33 @@
|
||||
<!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>Allgemeines</title>
|
||||
</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>Allgemeines</h1>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.inf.fu-berlin.de/lehre/WS01/ALPI/">ALP I</a><br>
|
||||
<a href="http://www.inf.fu-berlin.de/lehre/SS02/alp2/">ALP II</a><br>
|
||||
<a href="http://www.inf.fu-berlin.de/lehre/WS02/ALP3/index.html">ALP III</a><br>
|
||||
<a href="http://www.zwergmaster.de/index.php?site=40&cat=downloads">study auf zwergmaster.de</a><br>
|
||||
<a href="http://www.pi.informatik.tu-darmstadt.de/studarb/JochenSchroeder/Kategorien/Algorithmentypen.html"> Algorithmen ohne Ende</a><br>
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 1.8 KiB |
@@ -0,0 +1,151 @@
|
||||
<!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>Aufgaben</title>
|
||||
</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>Allgemeine Aufgaben in Haskell</h1>
|
||||
|
||||
<h2>Sortieren</h2>
|
||||
<ol start="1" type="1">
|
||||
<li>Quicksort</li>
|
||||
<li>Mergesort</li>
|
||||
<li>Insertionsort</li>
|
||||
<li>Selectionsort</li>
|
||||
</ol>
|
||||
|
||||
<h2>Suchen</h2>
|
||||
<ol start="5" type="1">
|
||||
<li>lineares Suchen</li>
|
||||
<li>binäre Suche</li>
|
||||
</ol>
|
||||
|
||||
<h2>diverses in Haskell</h2>
|
||||
<ol start="7" type="1">
|
||||
<li>reverse</li>
|
||||
<li>Fibonacci</li>
|
||||
<li>Fakultät</li>
|
||||
<li>Summe einer Liste</li>
|
||||
<li>map Funktion selbst schreiben</li>
|
||||
<li>Binärer Suchbaum mit insert, delete, contains, sum, gib Baum als sortierte List aus...</li>
|
||||
<li>Ein Stack in Haskell</li>
|
||||
<li>Eine Queue in Haskell</li>
|
||||
<li>Eine Menge in Haskell</li>
|
||||
</ol>
|
||||
|
||||
<a href="loesungen.hs">Lösungen</a>
|
||||
|
||||
<h1>Allgemeine Aufgaben in Java</h1>
|
||||
<ol>
|
||||
<li>
|
||||
<a href="BinTree.java">Binärbaum</a> - ein ziemlicher Klopper, aber man sollte das mal gemacht haben.
|
||||
</li>
|
||||
<li>
|
||||
"1. Spezifizieren Sie ein Interface für einen Stack und implementieren Sie den Stack in Java mit einem Array" - <a href="ArrayStack.java">Lösung</a>
|
||||
</li>
|
||||
<li>
|
||||
"1. Spezifizieren Sie ein Interface für eine Schlange und implementieren Sie die Schlange in Java mit einem Array" - <a href="ArrayQueue.java">Lösung</a>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<h1>Allgemeine Aufgaben</h1>
|
||||
|
||||
<a href="loesungenvonbettina.php">Lösungen der folgenden Aufgaben</a>
|
||||
<h2>Vollständige Induktion</h2>
|
||||
Um die Behauptungen zu beweisen, kann man die vorherigen Aussagen und die bewiesenen Behauptungen mitbenutzen.
|
||||
<ol>
|
||||
<li>Um das Prinzip zu verstehen: <b>1 + 3 + 5 + ... + (2n-1) = n²</b>, wobei n > 0.</li>
|
||||
<li><b>x ++ [] = x</b>, wobei (a) [] ++ v = v und (b) (a:v) ++ w = a:(v ++ w)</li>
|
||||
<li><b>rev (a ++ b)= (rev b) ++ (rev a)</b>, wobei (a) rev [] = [] und (b) rev (a:v) = (rev v) ++ [a]</li>
|
||||
<li><b>rev (rev xs) = xs</b>, wobei (a) rev [] = [] und (b) rev (a:v) = (rev v) ++ [a] und (c) rev [x] = [x] und (d) [x] = x:[]</li>
|
||||
</ol>
|
||||
|
||||
<h2>Primitiv rekursive Funktion</h2>
|
||||
<ol>
|
||||
<li>Vorgängerfunktion <b>pred</b></li>
|
||||
<li>Gleichheit mit Null <b>eq0</b>, wobei True 1 und False 0 entspricht</li>
|
||||
<li>Subtraktion <b>sub</b> von zwei Zahlen, wobei bei Rojas x-y = sub(y, x)</li>
|
||||
<li><b>and</b>, <b>not</b>, größer-gleich <b>≥</b></li>
|
||||
<li><b>if (x, y, z)</b>, wobei if x then y else z</li>
|
||||
</ol>
|
||||
|
||||
<h2>O-Notation</h2>
|
||||
<ol>
|
||||
<li>Sortieren Sie die folgenden Laufzeiten aufsteigend.<br>
|
||||
(a) n<sup>3</sup> (b) log<sub>2</sub> n (c) 1,8<sup>n</sup> (d) n (e) 3<sup>n</sup> (f) √n (g) n(log<sub>2</sub> n)<sup>2</sup> (h) n<sup>2</sup></li>
|
||||
<li>Finden Sie möglichst einfache Ausdrücke der Form Θ(·) für folgende Funktionen:<br>
|
||||
(a) 3n<sup>2</sup> − 4n + 32 + 27 n · ⌈log<sub>2</sub> n⌉ / 2<br>
|
||||
(b) max{n⌈log<sub>2</sub> n⌉, (⌈log<sub>2</sub> n⌉)<sup>4</sup>}<br>
|
||||
(c) 2<sup>2n + ⌈log<sub>2</sub> n⌉</sup></li>
|
||||
</ol>
|
||||
|
||||
<h2>Algorithmen</h2>
|
||||
<ol>
|
||||
<li><b>Dijkstra</b><br>
|
||||
a ist der Startknoten.<br>
|
||||
<img src="dijkstra-aufgabe.gif">
|
||||
</li>
|
||||
<li><b>Kleinster aufspannender Baum</b><br>
|
||||
Prim und Kruskal am obigen Graphen.
|
||||
</li>
|
||||
<li><b>Huffman</b><br>
|
||||
Für das Wort <b>ABRACADABRASIMSALABIM</b> die Wahrscheinlichkeiten der einzelnen Buchstaben bestimmen und dann einen Binärcode nach dem Huffman-Algorithmus erstellen.
|
||||
</li>
|
||||
<li><b>Verschiebefunktion</b><br>
|
||||
Aufstellen der Verschiebefunktion des Musters <b>babcabb</b> und überprüfen ob es im Text <b>abbababcababcabbbca</b> entghalten ist.
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<h2>Graphen und Bäume</h2>
|
||||
<ol>
|
||||
<li><b>AVL-Baum</b><br>
|
||||
Erstelle einen neuen AVL-Baum und füge folgende Werte nacheinander ein: 3, 2, 1, 4, 5, 6, 7, 16, 15<br>
|
||||
Nun lösche die Werte 4 und 2.
|
||||
</li>
|
||||
<li><b>B-Baum</b><br>
|
||||
Erstelle einen neuen (2,3)-Baum und füge folgende Werte nacheinander ein: 1, 5, 2, 6, 7, 4, 8, 3<br>
|
||||
Ich denke, dass man Löschen nicht können muss. Das ist ziemlich kompliziert!
|
||||
</li>
|
||||
<li><b>Rot-Schwarz-Baum</b><br>
|
||||
Wandle den folgenden Rot-Schwarz-Baum in einen einen (2,4)-Baum um.<br>
|
||||
<img src="rotschwarz-aufgabe.gif">
|
||||
<div class="quelle">Die Grafik ist ein Screenshot von Arsen Gogeshvilis <a href="http://webpages.ull.es/users/jriera/Docencia/AVL/AVL%20tree%20applet.htm">Binärbaum-Applet</a></div>
|
||||
</li>
|
||||
<li><b>Suffixbaum</b><br>
|
||||
Erstelle einen Suffixbaum des Wortes <b>ananas$</b>.
|
||||
</li>
|
||||
<li><b>Adjazenzliste und -matrix</b><br>
|
||||
Gebe für folgenden Graphen eine Adjazenzliste und eine Adjazenzmatrix an und überlege welche Darstellung hier sinnvoller ist.<br>
|
||||
<img src="adjazenzaufgabe.gif">
|
||||
<div class="quelle">Grafik entnommen aus Saake, Sattler: "Algorithmen & Datenstrukturen"</div>
|
||||
</li>
|
||||
<li><b>Konvexe Hülle</b><br>
|
||||
Folgende Punkte im Koordinatenkreuz bilden einen Graphen: <b>A(1/9), B(3/7), C(4/8), D(5/1), E(7/5), F(7/7), G(9/3), H(10/8)</b><br>
|
||||
Nenne die Punkte, die in der komplexen Hülle enthalten sind.
|
||||
</li>
|
||||
<li><b>Infix, Prefix und Postfix</b><br>
|
||||
Folgende Terme in Pre- und Postoder darstellen.<br>
|
||||
(a) <b>2 + 3 * 6 - 4 / 1</b><br>
|
||||
(b) <b>5 * (6 + 2) - 7 / 4 + 2 * 5</b><br>
|
||||
Am Einfachsten geht das mit Hilfe eines Termbaums.<br>
|
||||
(c) <b>Pre-, In- und Postorder</b> von folgendem Termbaum<br>
|
||||
<img src="prepost3.gif">
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.8 KiB |
@@ -0,0 +1,272 @@
|
||||
<!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>Bäume</title>
|
||||
</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>Bäume</h1>
|
||||
|
||||
<h2>AVL-Bäume</h2>
|
||||
AVL-Bäume (Adelson-Velskii und Landis) sind eine Form von binären Suchbäumen, die das Entarten vermeiden und dabei den Aufwand beim Ausgleichen begrenzt halten.<br><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>AVL-Kriterium:</b></td>
|
||||
<td>Ein AVL-Baum ist ein ausgeglichener/balancierter Binärbaum, d.h. für jeden Knoten unterscheidet sich die Höhe (= Weg von der Wurzel bis zum Knoten) seiner beiden Nachfolger um höchstens 1.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
Durch diese Bedingung eignen sich AVL-Bäume besonders zur Suche, da im worst case eine Laufzeit von O(log n) entsteht.<br>
|
||||
Bei jeder Einfüge- oder Löschoperation muss die AVL-Bedingung über eine oder zwei Rotationen wieder hergestellt werden.<br><br>
|
||||
|
||||
<h4>Einfügen in einen AVL-Baum</h4>
|
||||
Das grundsätzliche Vorgehen beim Einfügen eines Elements entspricht dem Algorithmus vom binären Suchbaum. Als Folge dieser Operation kann jedoch die AVL-Eigenschaft verletzt sein, was man durch Vertauschen von Knoten (Rotation bzw. Doppelrotation) wieder behebt.<br><br>
|
||||
|
||||
<b>Rotation</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="rotation1.gif"></td>
|
||||
<td><img src="rotation2.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
Wenn es nach dem Einfügen eines neuen Wertes einen Knoten <b>k<sub>0</sub></b> gibt, dessen linker Teilbaum <b>a</b> des linken Kindes <b>k<sub>1</sub></b> und <b>k<sub>1</sub></b> (bzw. dessen rechter Teilbaum des rechten Kindes und das rechte Kind) eine um zwei größere Höhe hat als der rechte Teilbaum <b>c</b> (bzw. der linke Teilbaum), dann wird <b>k<sub>0</sub></b> mit <b>k<sub>1</sub></b> vertauscht.<br><br>
|
||||
|
||||
<b>Doppelrotation</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="doppelrotation1.gif"></td>
|
||||
<td><img src="doppelrotation2.gif"></td>
|
||||
<td><img src="doppelrotation3.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
Wenn es nach dem Einfügen eines neuen Wertes einen Knoten <b>k<sub>0</sub></b> gibt, dessen rechter Teilbaum <b>b</b> des linken Kindes <b>k<sub>1</sub></b> und <b>k<sub>1</sub></b> (bzw. dessen linker Teilbaum des rechten Kindes und das rechte Kind) eine um zwei größere Höhe hat als der rechte Teilbaum <b>d</b> (bzw. der linke Teilbaum), dann wird zunächst <b>k<sub>1</sub></b> mit seinem rechten Kind <b>k<sub>2</sub></b> (bzw. linken Kind) vertauscht und dann <b>k<sub>2</sub></b> nach oben rotiert, so dass dieser Knoten nun die neue Wurzel dieses Teilbaums ist.<br><br>
|
||||
|
||||
<h4>Löschen in einen AVL-Baum</h4>
|
||||
Ein gelöschter Knoten wird durch den linkesten Knoten seines rechten Teilbaums ersetzt. Hat der Knoten keinen rechten Teilbaum, wird er durch sein linkes Kind ersetzt. Der Baum wird danach durch Rotation und Doppelrotation wieder ausgeglichen falls nötig.
|
||||
|
||||
<br><br>
|
||||
<h2>B-Bäume</h2>
|
||||
B-Bäume sind keine Binärbaume, sondern ausgeglichene Mehrwegbäume. D.h. sie sind Bäume, die in einem Knoten mehrere Elemente speichern können.<br>
|
||||
Ein B-Baum der Ordnung m kann m-1 Elemente in einem Knoten speichern und hat folgende Eigenschaften:
|
||||
<ol>
|
||||
<li>Jeder Knoten hat höchstens m Kinder.</li>
|
||||
<li>Jeder Knoten mit Ausnahme der Wurzel und der Blattknoten hat mindestens m/2 Kinder.</li>
|
||||
<li>Die Wurzel hat mindestens 2 Kinder (oder ist ein Blattknoten).</li>
|
||||
<li>Alle Blattknoten sind auf der gleichen Ebene, und tragen keine weiteren Informationen</li>
|
||||
<li>Ein innerer Knoten mit k Kindern besitzt k-1 Schlüssel.</li>
|
||||
</ol>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Beispiel:</b></td>
|
||||
<td><img src="bbaum.gif"></td>
|
||||
<td><div class="quelle" style="text-align: right;">Grafik entnommen aus Saake, Sattler: "Algorithmen & Datenstrukturen"</div></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
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.
|
||||
<br><br>
|
||||
|
||||
<h4>Suchen in einen B-Baum</h4>
|
||||
Nehmen wir an, dass wir einen (2,3)-Baum haben und einen Eintrag mit dem Wert w suchen. <br>
|
||||
Ein Knoten mit drei Elementen enthält die Werte a, b und c, wobei a ≤ b ≤ c, und vier Verweise, wobei v<sub>1</sub> auf alle Elemente e verweist, die kleiner a sind, v<sub>2</sub> auf alle a ≤ e < b, v<sub>3</sub> auf alle b ≤ e < c und v<sub>4</sub> auf alle c ≤ e.<br>
|
||||
Man fängt also wie gewohnt in der Wurzel an, überprüft, ob es dort einen Wert gibt, der gleich w ist. Wenn nicht nimmt man den jeweiligen Veweis zum nächsten Knoten und fährt rekursiv fort. Wenn man in einem Blatt angekommen ist und der Wert bis jetzt nicht gefunden wurde, ist er nicht im Baum gespeichert.
|
||||
<br><br>
|
||||
|
||||
<h4>Einfügen in einen B-Baum</h4>
|
||||
Zunächst wird das Blatt gesucht, in das das Element eingetragen werden soll und wird (der Sortierung entsprechend) eingefügt.
|
||||
<table>
|
||||
<tr>
|
||||
<td>Dann gibt es zwei Fälle:</td>
|
||||
<td>
|
||||
<ol>
|
||||
<li>Die Anzahl der Einträge des Knotens ist immernoch < m</li>
|
||||
<li>Die Anzahl der Einträge ist ≥ m</li>
|
||||
</ol>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
Im ersten Fall freut man sich, dann ist man nämlich mit dem Einfügen fertig.<br>
|
||||
Im zweiten Fall nimmt man das mittlere Element e<sub>i</sub> in den Elternknoten, teilt den Knoten in zwei und verweist jeweils recht und links von e<sub>i</sub> auf die neuen Knoten. Wenn nun der Elternknoten mehr als m-1 Elemente speichert, fährt man rekursiv fort. Dies kann sich bis zur Wurzel hochziehen. Hat die Wurzel nun mehr als m-1 Elemente wird e<sub>i</sub> nicht in den Elternknoten (gibt ja keinen), sondern wird in einen neuen Knoten geschrieben, der jetzt die Wurzel ist. Der B-Baum wächst also nach oben.<br><br>
|
||||
|
||||
<h4>Löschen in einen B-Baum</h4>
|
||||
Zunächst wird der Knoten gesucht, in das das Element gespeichert ist und der Eintrag gelöscht.
|
||||
<table>
|
||||
<tr>
|
||||
<td>Dann gibt es drei Fälle:</td>
|
||||
<td>
|
||||
<ol>
|
||||
<li>Die Anzahl der Einträge des Knotens aus dem gelöscht wurde ist immernoch ≥ m/2</li>
|
||||
<li>Die Anzahl der Einträge des <b>Knotens</b> ist < m/2</li>
|
||||
<li>Die Anzahl der Einträge des <b>Blattes</b> ist < m/2</li>
|
||||
</ol>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
Im ersten Fall freut man sich, dann ist man nämlich mit dem Löschen fertig.<br>
|
||||
Im zweiten Fall wird das Element durch den nächstkleineren aus einem Blatt ersetzt. Wenn sich für das Blatt nun ein Unterlauf ergibt, wird wie im dritten Fall fortgefahren.<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>Im dritten Fall gibt es wiederum zwei Möglichkeiten:</td>
|
||||
<td>
|
||||
<ol>
|
||||
<li>Ein Nachbarknoten hat <b>mehr als m/2</b> Elemente</li>
|
||||
<li>Die Nachbarknoten haben <b>nur m/2</b> Einträge</li>
|
||||
</ol>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
Im ersten Fall werden der Knoten, der Nachbarknoten und e<sub>i</sub> aus dem Elternknoten, von dem aus rechts und links die beiden Verweise zu den Knoten ausgehen, kurzzeitig zu einem Knoten zusammengefasst, wieder halbiert und ein neues e<sub>i</sub>, was in den Elternknoten geschrieben wird, festgelegt.<br>
|
||||
Im zweiten Fall wird der Knoten, der Nachbarknoten und e<sub>i</sub> aus dem Elternknoten zusammengelegt. Einer der Verweise vom Elternknoten fällt weg (ist ja nur noch ein Knoten). Der neue Knoten hat m Einträge: (m/2)-1 vom ursprünglichen Knoten + m/2 vom Nachbarknoten + 1 der Knoten aus dem Elternknoten e<sub>i</sub>.<br>
|
||||
Möglicherweise gibt es nun im Elternknoten einen Unterlauf. Dieser wird rekursiv behandelt.<br>
|
||||
<i>Darf ein Knoten nicht nur m-1 Einträge speichern?</i>
|
||||
<br><br>
|
||||
|
||||
<h2>Rot-Schwarz-Bäume</h2>
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Eigenschaften:</b></td>
|
||||
<td>
|
||||
<ol>
|
||||
<li>Knoten sind rot oder schwarz.</li>
|
||||
<li>Die Wurzel ist schwarz.</li>
|
||||
<li>Externe Knoten sind schwarz.</li>
|
||||
<li>Die Kinder von roten Knoten sind schwarz. (Rotbedingung)</li>
|
||||
<li>
|
||||
Jeder Pfad von einem Knoten x zu einem externen Knoten besitzt die gleiche Anzahl schwarzer Knoten.<br>
|
||||
Diese Anzahl (x nicht mitgezählt gezählt) heißt schwarze Höhe bh(x) eines Knotens.
|
||||
</li>
|
||||
</ol>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Rot-Schwarz-Baum</b></td>
|
||||
<td><img src="rotschwarz1.gif"></td>
|
||||
<td><img src="rotschwarz2.gif"></td>
|
||||
<td><img src="rotschwarz3.gif"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td colspan="4"><div class="quelle" style="text-align: right;">Die Grafik ist ein Screenshot von Arsen Gogeshvilis <a href="http://webpages.ull.es/users/jriera/Docencia/AVL/AVL%20tree%20applet.htm">Binärbaum-Applet</a></div><br /></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>(2,3)-Baum</b></td>
|
||||
<td><img src="bbaum1.gif"></td>
|
||||
<td><img src="bbaum2.gif"></td>
|
||||
<td><img src="bbaum3.gif"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td colspan="4"><div class="quelle" style="text-align: right;">Grafik entnommen aus Saake, Sattler: "Algorithmen & Datenstrukturen"</div><br /></td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
Jeder Rot-Schwarz-Baum lässt sich durch einen (2,3)-Baum darstellen und umgekehrt.<br>
|
||||
Ein 1-Knoten lässt sich durch einen schwarzen Knoten ersetzen, ein 2-Knoten durch einen schwarzen Knoten mit einem roten Kind und ein 3-Knoten durch einen schwarzen Knoten mit zwei roten Kindern.<br>
|
||||
Suchen, einfügen und löschen funktionieren also nach dem gleichen Prinzip wie im (2,3)-Baum.
|
||||
<br><br>
|
||||
|
||||
<h2>Digitalbäume</h2>
|
||||
<div class="quelle">Die Grafiken zu Digitalbäumen wurden den Folien zur <a href="http://www.inf.fu-berlin.de/lehre/WS02/ALP3/index.html">Vorlesung</a> entnommen.</div>
|
||||
Es gibt verschiedene Möglichkeiten einen Digitalbaum darzustellen.<br><br>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td>
|
||||
<b>Digitalbaum</b><br>
|
||||
<img src="digitalbaum.gif"></td>
|
||||
<td><img src="digitalbaum2.gif"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>Binärer Digitalbaum</b><br>
|
||||
<img src="binaererdigitalbaum.gif"></td>
|
||||
<td><img src="binaererdigitalbaum2.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
|
||||
<h3>Patricia-Bäume</h3>
|
||||
Patricia-Bäume (Practical Algorithm To Retrieve Information Coded In Alphanumeric) sind binäre Digitalbäume. <br>
|
||||
Das Prinzip ist sehr einfach:<br>
|
||||
<img src="patricia1.gif"><br>
|
||||
Alle Schlüssel werden in den Blättern gespeichert. In den Knoten steht die Anzahl der Zeichen (Bits), die auf den Wegen zu den Blättern überspringen werden können.<br><br>
|
||||
|
||||
Ein richtiger Patricia-Baum sieht so aus:<br>
|
||||
<img src="patricia2.gif"><br>
|
||||
Der Schlüssel HEINZ ist z.B. folgendemaßen abgespeichert: 10010001000101100100110011101011010<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>Wegfindung:</td>
|
||||
<td>
|
||||
100100010<br>
|
||||
0<br>
|
||||
0<br>
|
||||
1<br>
|
||||
011001<br>
|
||||
0<br>
|
||||
011001110<br>
|
||||
1<br>
|
||||
01<br>
|
||||
1<br>
|
||||
010
|
||||
</td>
|
||||
<td>
|
||||
9 Bits überspringen<br>
|
||||
links<br>
|
||||
links<br>
|
||||
rechts<br>
|
||||
6 Bits überspringen<br>
|
||||
links<br>
|
||||
9 Bits überspringen<br>
|
||||
rechts<br>
|
||||
2 Bits überspringen<br>
|
||||
rechts ⇒ bei HEINZ angekommen
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h3>Suffix-Bäume</h3>
|
||||
In einem Suffuixbaum sind alle Suffixe eines Wortes gespeichert.<br><br>
|
||||
<b>Beispiel: Mississippi</b><br>
|
||||
<img src="mississippi.gif"><br>
|
||||
|
||||
<h3>Anmerkungen</h3>
|
||||
|
||||
<b>Digitalbaum allgemein:</b> zeichenweiser Schlüsselvergleich entscheidet über Pfad im Baum.<br>
|
||||
<b>Digitalbaum speziell (Radix tree):</b> Schlüssel in inneren Knoten und Blättern, zeichenweiser Schlüsselvergleich, keine Schlüsselordnung.<br>
|
||||
<b>Trie:</b> Schlüssel nur in Blättern, geordnet nach Schlüsseln.<br>
|
||||
<b>Patricia Trie</b> (Compressed Trie), (manchmal Patricia Tree): Redundanz eliminiert: jeder innere Knoten hat mindestens zwei Nachfolger.<br>
|
||||
<b>Suffix Trie:</b> Trie, der alle Suffixe einer Zeichenkette enthält (eher unwichtig, kommt selten vor).<br>
|
||||
<b>Suffixbaum (Suffix Tree):</b> Patricia Trie, der alle Suffixe einer Zeichenkette enthält, also: jeder innere Knoten mit zwei Nachfolgern. (wichtig)<br>
|
||||
<b>Suffix-Feld (Suffix Array):</b> Felddarstellung eines Suffixbaums (nicht behandelt).<br>
|
||||
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://webpages.ull.es/users/jriera/Docencia/AVL/AVL%20tree%20applet.htm">Das Applet zu AVL- und Rot-Schwarz-Bäumen</a>
|
||||
<br>
|
||||
<a href="http://alfi.ira.uka.de/lehre/sommer2002/AVLTreeApplet/avl.html">AVL-Applet mit einzelnen Umsortierungsschritten (zum Mitverfolgen)</a>
|
||||
<br>
|
||||
<a href="http://www.vameo.de/uni/tutorium/binaryandavl.pdf">Merkblatt zu Binäre Suchbäume & AVL-Bäume von Augustin</a>
|
||||
<br>
|
||||
<a href="http://www.vameo.de/uni/tutorium/redblack.pdf">Merkblatt zu Rot-Schwarz-Bäume von Augustin</a>
|
||||
<br>
|
||||
<a href="http://www.vameo.de/uni/tutorium/23tree.pdf">Merkblatt zu 2-3-Bäume von Augustin</a>
|
||||
<br>
|
||||
<a href="http://www.vameo.de/uni/tutorium/digibaum.pdf">Merkblatt zu Digitalbäume von Augustin</a>
|
||||
<a href="http://dbs.uni-leipzig.de/en/skripte/ADS2/HTML/kap1-32.html">Patricia-Bäume</a>
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 4.2 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.3 KiB |
@@ -0,0 +1,102 @@
|
||||
<!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>Prozedurale Programmierung: Begriffe</title>
|
||||
</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>Begriffe in Haskell</h1>
|
||||
|
||||
<h2>Erklärungen</h2>
|
||||
<b>Lazy Evaluation</b>: In "Haskell" werden Ausdrücke grundsätzlich nicht strikt ausgewertet. Ein (Teil-)Ausdruck wird erst durch seinen Wert ersetzt, wenn dieser zum Beispiel für einen arithmetischen Vergleich benötigt wird. Demzufolge wird auch ein als aktueller Parameter einer Funktion übergebener Ausdruck erst ausgewertet, wenn sein Wert innerhalb des Funktionsrumpfes verwendet wird. Wurde der Wert einmal berechnet, werden alle namentlichen Vorkommen des Ausdrucks durch seinen Wert ersetzt. Ein einfaches Beispiel verdeutlicht diese Strategie.<br><br>
|
||||
<code>const1 a = 1 </code>
|
||||
<br><br>
|
||||
Definiert ist eine konstante Funktion "const1" mit einem beliebigen Parameter "a" und dem Rückgabewert 1. Der Rückgabewert folgender beispielhafter Funktionsaufrufe ist also immer 1.<br><br>
|
||||
<code>
|
||||
(Pseudocode)<br>
|
||||
const1 10 => 1<br>
|
||||
const1 (1+4) => 1<br>
|
||||
const1 'A' => 1<br>
|
||||
const1 (1/0) => 1<br>
|
||||
</code><br><br>
|
||||
Für das Ergebnis der Funktion ist der Wert des aktuellen Parameters irrelevant. Er wird von einem Interpreter deshalb nie ausgewertet. Aus diesem Grund führt der letzte Aufruf mit der Division durch Null als Parameter nicht zu einem Fehler.
|
||||
<br>
|
||||
Solange also der Wert eines Ausdrucks (einer Funktion) nicht benötigt wird, behandelt "Haskell" diesen als eine Definition. Als solche werden auch entsprechende Teilausdrücke behandelt.<br><br>
|
||||
|
||||
<b>Pattern Matching</b>: Ein Funktion kann mehrere Definitionen haben. Es wird per Pattern Matching anhand der aufrufenden Parameter entschieden, welche Definition angewendet wird. <br>
|
||||
|
||||
Beispiel: Rekursive Funktion zum Berechnen von <code>x</code> Exponent <code>y</code><br><br>
|
||||
<code>
|
||||
xHochY :: Int -> Int -> Int<br>
|
||||
xHochY x 0 = 1<br>
|
||||
xHochY x _ = x * xHochY x (y-1)<br>
|
||||
</code><br>
|
||||
Wenn <code>y = 0</code> ist, wird die erste Definition verwendet. In allen anderen Fällen (_ ist Wildcard) wird die untere Definition verwendet. Die Funktion ist rekursiv und bricht nach <code>y = 0</code> ab. Es wird jedoch nicht geprüft, ob kein <code>y < 0</code> Parameter ist.<br><br>
|
||||
|
||||
<b>Currying</b>: eine Funktion in gecurrieter Form erhält alle ihre Argumente auf einmal, also z. B. wenn wir x und y multiplizieren wollen, übergeben wir gleichzeitig x und y.<br><br>
|
||||
<code>
|
||||
mult :: Int -> Int -> Int<br>
|
||||
mult x y = x * y
|
||||
</code>
|
||||
<br><br>
|
||||
Die ungecurrierte Form sähe so aus:<br><br>
|
||||
<code>
|
||||
mult :: (Int, Int) -> Int<br>
|
||||
mult (x, y) = x * y
|
||||
</code>
|
||||
<br><br>
|
||||
|
||||
<b>Formale Parameter (FP)</b>: Namen für Parameter in der Funktionsdefinition, also die abstrakten.<br><br>
|
||||
|
||||
<b>Aktuelle Parameter (AP)</b>: Ausdrücke im Aufruf, deren Werte oder Stellen übergeben werden, also die konkreten, die beim Funktionsaufruf übergeben werden.<br><br>
|
||||
|
||||
<b>Call-by-Name</b>: Bei der Parameterübergabe nach dem Mechanismus des call-by-name wird der Parameter als Referenz übergeben. In der aufgerufenen Methode kann man sich an jeder Stelle, wo der Parameter als lokale Variable verwendet wird, den Namen der beim Aufruf übergebenen Variable ersetzt denken. Kommt in der aufgerufenen Methode ein lokaler Name mit demselben Namen vor, so kann dies leicht zu ungewollten Effekten führen.<br>
|
||||
Beispiel:<br><br>
|
||||
<code>
|
||||
int x = 3;<br>
|
||||
Function abc (int a)<br>
|
||||
{<br>
|
||||
int x = 5;<br>
|
||||
a = a + 5;<br>
|
||||
}<br>
|
||||
abc(x);<br>
|
||||
print(x);<br><br>
|
||||
</code>
|
||||
Bei diesem Beispiel wird am Schluss nicht, wie man vielleicht vermutet, <code>8</code> ausgegeben, sondern <code>10</code>, da in der Methode <code>abc</code> jedes Vorkommen von <code>a</code> durch <code>x</code> ersetzt werden kann und somit <code>x = x + 5 = 5 + 5</code> berechnet wird.<br><br>
|
||||
|
||||
|
||||
<b>Call-by-Value</b>: Bei der Parameterübergabe nach dem Mechanismus des call-by-value wird eine Kopie der Variable übergeben. Wenn in der Methode der übergebene Parameter geändert wird, hat dies keine Auswirkung auf den Originalparameter. <br><br>
|
||||
|
||||
<b>Call-by-result</b>: Bei der Parameterübergabe nach dem Mechanismus des call-by-value/result (auch call-by-copy/restore genannt) wird zunächst wie beim call-by-value verfahren, d.h. es wird nur eine Kopie der Variable übergeben. Wenn in der Methode der übergebene Parameter geändert wird, hat dies zunächst keine Auswirkung auf den Originalparameter. Am Ende der Methode wird allerdings der Wert der übergebenen Variable aus der aufrufenden Methode mit dem aktuellen Wert des Parameters überschrieben <br><br>
|
||||
|
||||
<b>Call-by-reference</b>: Bei der Parameterübergabe nach dem Mechanismus des call-by-reference wird der Parameter als Referenz übergeben. Wird in der Methode der Wert des Parameters geändert, so wirkt sich dies auch auf den Wert der übergebenen Variable in der aufrufenden Methode aus. Die beiden Objekte zeigen auf dieselbe Speicheradresse, statt einer Kopie des Wertes wird die Speicheradresse übergeben.Dieser Übergabemechanismus wird beispielsweise in der Programmiersprache Java verwendet.<br><br>
|
||||
|
||||
<b>Higher-Order-Function</b>: Eine Funktion, die als Parameter eine Funktion verarbeiten kann und auch eine Funktion zurück geben kann.<br>
|
||||
Beispiel:<br><br>
|
||||
<code>squareList list = map (^2) list</code><br><br>
|
||||
Die Funktion <code>squareList</code> bekommt <code>^2</code> als Parameter übergeben.<br><br>
|
||||
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://en.wikipedia.org/wiki/Lazy_evaluation">lazy evaluation bei Wikipedia (engl.)</a><br>
|
||||
<a href="http://www.fh-wedel.de/~si/seminare/ss02/Ausarbeitung/3.lazy/lazy2.htm">weiterführendes zum Thema "lazy evaluation"</a><br>
|
||||
<a href="http://ag-kastens.uni-paderborn.de/lehre/material/gdp/folien/Folie715.html">Folie zu Currying</a><br>
|
||||
<a href"http://en.wikipedia.org/wiki/Higher-order_function">higer order function bei Wikipedia (engl.)</a><br><br>
|
||||
|
||||
<h2>Dokumente</h2>
|
||||
<a href="haskellbegriffe.doc">als doc zum Drucken</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 5.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
@@ -0,0 +1,25 @@
|
||||
<!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>Ausgeschlossene Themen</title>
|
||||
</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>Deprecated</h1>
|
||||
Kombinatorentheorie<br>
|
||||
Turingmaschinen
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.1 KiB |
@@ -0,0 +1,17 @@
|
||||
<!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>Edit</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<span id="menu"><a href="index.php">zurück zur Liste</a></span>
|
||||
|
||||
<p>
|
||||
Das ALP-Vordiplom-Projekt wurde erfolgreich abgeschlossen, die Seiten können nicht mehr verändert werden.
|
||||
</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,51 @@
|
||||
<!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>Eigenschaften von Algorithmen</title>
|
||||
</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>Eigenschaften von Algorithmen</h1>
|
||||
|
||||
<h3>Abstraktion</h3>
|
||||
Durch einen Algorithmus wird ein Problemlösungsprozess auf einem bestimmten Abstraktionsniveau beschrieben, das durch die elementaren Algorithmen, die elementaren Objekte und den verwendeten Formalismus festgelegt wird.<br>
|
||||
Eine der wichtigsten Möglichkeiten der Abstraktion besteht darin, (Teil-) Algorithmen einen Namen zu geben und diesen Namen dann stellvertretend für die detaillierte Realisierung des Algorithmus zu verwenden.<br><br>
|
||||
|
||||
<h3>Diskretheit</h3>
|
||||
Ein diskreter Algorithmus arbeitet schrittweise das Problem ab, d.h. er ist aus elementaren Operationen zusammengesetzt.<br><br>
|
||||
|
||||
<h3>Finitheit (= Endlichkeit)</h3>
|
||||
Statische Finitheit: Die Beschreibung eines Algorithmus besitzt nur eine endliche Länge.<br> Ein Dynamische Finitheit: Ein Algorithmus nimmt während seiner Ausführung nur endlich viel Platz zur Speicherung von Zwischenresultaten in Anspruch.<br><br>
|
||||
|
||||
<h3>Terminierung</h3>
|
||||
Einen Algorithmus nennt man terminierend, wenn er bei jeder Anwendung nach endlich vielen Verarbeitungsschritten anhält und ein Resultat liefert.<br><br>
|
||||
|
||||
<h3>Finitheit vs. Terminierung</h3>
|
||||
Das Terminieren einen Algorithmus darf nicht mit seiner Finitheit verwechslet werden. Es ist durchaus möglich, durch eine endliche Beschreibung (finit) einen Prozeß (z.B. mit Endlosschleife) zu definieren, der nicht nach endlicher Zeit beendet wird, also nicht terminiert.<br>
|
||||
Es gibt sogar Algorithmen mit praktischem Nutzen, die (potentiell) "endlos laufen", z.B. Algorithmen zur Steuerung "nichtabbrechender" Vorgänge (z.B. in chemischen Produktionsstätten) oder das zentrale Steuerungsprogramm (Betriebssystem) einen Computers, der Tag und Nacht in Verwendung steht.<br><br>
|
||||
|
||||
<h3>Determinismus</h3>
|
||||
Einen Algorithmus nennt man deterministisch, wenn zu jedem Zeitpunkt seiner Ausführung höchstens eine Möglichkeit der Fortsetzung besteht, also der Folgeschritt eindeutig bestimmt ist. Besteht keine Möglichkeit zur Fortsetzung der Ausführung, so vereinbart man, daß der Algorithmus terminiert.<br>
|
||||
Hat ein Algorithmus an mindestens einer Stelle zwei oder mehr Möglichkeiten der Fortsetzung, von denen eine nach belieben ausgewählt werden kann, so heißt er nicht-deterministisch.<br>
|
||||
Enthält ein Algorithmus also elementare Anweisungen, deren Ergebnis durch einen Zufallsmechanismus beeinflußt wird, so heißt dieser Algorithmus nicht-deterministisch. Liefert er bei der gleichen Eingabe immer die gleiche Ausgabe, so heißt er deterministisch.<br><br>
|
||||
|
||||
<h3>Determiniertheit</h3>
|
||||
Ein Algorithmus heißt determiniert, wenn er mit den gleichen Parametern und Startbedingungen stets das gleiche Ergebnis liefert.<br><br>
|
||||
|
||||
<h3>Determinismus vs. Determiniertheit</h3>
|
||||
Determinismus und Determiniertheit sind auseinanderzuhalten: Determinismus kennzeichnet einen Algorithmus, bei dem der gesamte Ablauf eindeutig bestimmt ist. Determiniertheit bezieht sich nur auf die eindeutige Bestimmtheit des Resultats. Deterministische Algorithmen haben durch ihren eindeutigen Ablauf auch ein eindeutiges Resultat, sie sind daher stets determiniert. Die Umkehrung gilt jedoch nicht. Es gibt nicht-deterministische Algorithmen, die über verschiedene Wege stets zum gleichen Ziel kommen, also determiniert sind.<br><br>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 7.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 5.0 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
@@ -0,0 +1,63 @@
|
||||
<!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>Graphen und Bäume</title>
|
||||
</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>Graphen und Bäume</h1>
|
||||
<div class="quelle">Grafiken entnommen aus Saake, Sattler: "Algorithmen & Datenstrukturen"</div>
|
||||
|
||||
<h2>Graphen</h2>
|
||||
|
||||
<h3>Gerichteter Graph</h3>
|
||||
<img src="gerichtetergraph.gif"><br>
|
||||
Als gerichteten Graph bezeichnet man einen Graph, der gerichtete Kanten enthält.<br><br>
|
||||
|
||||
<h3>Ungerichteter Graph</h3>
|
||||
<img src="ungerichtetergraph.gif"><br>
|
||||
Als ungerichteten Graph bezeichnet man einen Graph, der nur ungerichtete Kanten enthält. Dies schließt in der Regel auch Schleifen aus. Normalerweise gibt man den Zusatz <i>ungerichtet</i> nicht mit an, da man in der Regel meist nur ungerichteten Graphen meint, wenn man von Graphen spricht.<br><br>
|
||||
|
||||
<h3>Gewichteter Graph</h3>
|
||||
<img src="gewichtetergraph.gif"><br>
|
||||
Als gewichteter Graph bezeichntet man einen Graph, der Knoten- oder Kantengewichte hat.
|
||||
<br><br>
|
||||
|
||||
<h3>Planarer Graph</h3>
|
||||
Ein planarer Graph (auch plättbarer Graph) ist ein Graph, der auf einer Ebene mit Punkten für die Knoten und Linien für die Kanten dargestellt werden kann, so dass sich die Kanten nur in den Knoten schneiden.
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Planarer Graph</b></td>
|
||||
<td><b>Kein planarer Graph</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><img src="planarergraph.gif"></td>
|
||||
<td><img src="nichtplanarergraph.gif"></td>
|
||||
</tr>
|
||||
</table><br>
|
||||
|
||||
<h3>Bipartiter Graph</h3>
|
||||
<img src="bipartitergraph.gif"><br>
|
||||
Ein Graph heißt bipartit (auch paar), falls seine Knoten sich in zwei Teilmengen aufteilen lassen (Bipartition), so dass es zwischen den Knoten innerhalb einer Teilmenge keine Kanten gibt. Damit sind die Teilmengen stabile Mengen und die Bipartition impliziert eine mögliche 2-Färbung des Graphen. Umgekehrt sind alle 2-färbbaren Graphen bipartit.<br><br>
|
||||
|
||||
|
||||
|
||||
<h2>Bäume</h2>
|
||||
<a href="baeume.php">... weiter zu Bäume</a>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.vameo.de/uni/tutorium/graphen.pdf">Merkblatt zu Graphen von Augustin (u.a. Adjazenzliste, Adjazenzmatrix, Dijkstra, Prim, Krustal, ...)</a>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,108 @@
|
||||
<!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>Greedy-Algorithmen</title>
|
||||
</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>Greedy-Algortihmen</h1>
|
||||
|
||||
Das Prinzip eines <b>Greedy-Algorithmus (gieriger Algorithmus)</b> ist es, in jedem Teilschritt so viel wie möglich zu erreichen.<br><br>
|
||||
Eine Anwendung des Greedy-Algorithmus im täglichen Leben ist die z.B. die <b>Herausgabe von Wechselgeld</b>. <br>
|
||||
<b>Greedy:</b> Nimm jeweils immer die größte Münze unter dem Zielwert und ziehe sie von diesem ab. Verfahre derart bis Zielwert gleich null.<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>Beispiel:</td>
|
||||
<td>Rückgabe von 79 Cent</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>79 = 50 + 20 + 5 + 2 + 2</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
Bei diesem Beispiel berechnet der Greedy-Algorithmus immer die optimale Geldrückgabe. Die muss allerdings nicht immer gelten. Greedy-Algorithmen berechnen jeweils ein <b>lokales Optimum</b> in jedem Schritt und können daher eventuell ein <b>globales Optimum</b> verpassen.<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>Beispiel:</td>
|
||||
<td>Zielwert ist 15. Es stehen Münzen mit den Werten 1, 5 und 11 zu Verfügung.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>15 = 5 + 5 + 5 ist globales Optimum</td>
|
||||
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>15 = 11 + 1 + 1 + 1 + 1 mit Greedy kein globales Optimum</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
|
||||
<h3>Dijkstras Algorithmus - Zum Finden kürzester Wege</h3>
|
||||
Der Dijkstra-Algorithmus kann als eine auf dem Greedy-Prinzip basierende Weiterentwicklung der Breitensuchen für gewichtete Kanten aufgefasst werden. Allerdings funktioniert diese Weiterentwicklung nur für nichtnegative Gewichte.<br><br>
|
||||
<b>Verfahren</b><br>
|
||||
Pro Knoten wird der Distanzwert D zum Startknoten in einer Prioritätswarteschlange Q gespeichert. Zu Beginn ist für den Startknoten 0 und für alle anderen Knoten unendlich ∞ eingetragen.<br><br>
|
||||
<b>Schleifendurchlauf</b><br>
|
||||
Der erste Knoten k<sub>1</sub> wird aus Q genommen. Der entgültige Distanzwert von k<sub>1</sub> ist das aktuelle D. <br>
|
||||
Nun wird Q verändert. Bei allen Knoten k<sub>i</sub>, die direkte Nachbarn von k<sub>1</sub> sind, wird nun überprüft, ob das aktuelle D größer ist als D(k<sub>1</sub>) + das Gewicht der Kante k<sub>1</sub>k<sub>i</sub>. Also wenn D(k<sub>i</sub>) > (D(k<sub>1</sub>) + k<sub>1</sub>k<sub>i</sub>), dann D(k<sub>i</sub>) = D(k<sub>1</sub>) + k<sub>1</sub>k<sub>i</sub>.<br><br>
|
||||
|
||||
<b>Beispiel</b><br>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="dijkstra.gif"></td>
|
||||
<td>
|
||||
<ol>
|
||||
<li>Q = 〈(s:0), (u:∞), (v:∞), (x:∞), (y:∞)〉</li>
|
||||
<li>Q = 〈(x:5), (u:10), (v:∞), (y:∞)〉</li>
|
||||
<li>Q = 〈(y:7), (u:8), (v:∞)〉</li>
|
||||
<li>Q = 〈(u:8), (v:13)〉</li>
|
||||
<li>Q = 〈(v:9)〉</li>
|
||||
<li>Q = 〈〉</li>
|
||||
</ol>
|
||||
</td>
|
||||
<td>
|
||||
<br>
|
||||
D(s) = 0<br>
|
||||
D(x) = 5<br>
|
||||
D(y) = 7<br>
|
||||
D(u) = 8<br>
|
||||
D(v) = 9<br>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<div class="quelle">Beispiel entnommen aus Saake, Sattler: "Algorithmen & Datenstrukturen"</div>
|
||||
<br>
|
||||
|
||||
|
||||
<h3>Algorithmus von Prim - Zum Finden des kleinsten aufspannenden Baums</h3>
|
||||
<b>Verfahren</b><br>
|
||||
Wähle einen beliebigen Knoten als Startgraph T.<br>
|
||||
Solange T noch nicht alle Knoten enthält, suche eine Kante minimalen Gewichts, die einen Knoten, der nicht in T ist, mit T verbindet und füge diese Kante und den damit verbundenen Knoten zu T hinzu.<br><br>
|
||||
<a href="http://www.fmi.uni-passau.de/~blochg/mst/prim.html">Animation für Prim</a>
|
||||
|
||||
|
||||
<h3>Algorithmus von Kruskal - Zum Finden des kleinsten aufspannenden Baums</h3>
|
||||
Die Grundidee ist, die Kanten in der Reihenfolge aufsteigender Kantengewichte zu durchlaufen und jede Kante zu wählen, die mit allen zuvor gewählten Kanten keinen Kreis schließt.<br><br>
|
||||
<b>Verfahren</b><br>
|
||||
Die Menge der Kanten werden sortiert in einer Liste L gespeichert.<br>
|
||||
Wähle die erste Kante in L als Startgraph T und lösche sie aus der Liste.<br>
|
||||
Solange T noch nicht alle Knoten enthält, gehe L der Reihe nach durch. Füge die erste Kante in T ein, die keinen Kreis mit den den Kanten, die bereits in T liegen, bilden. Die gewählte Kante und die Kanten, die einen Kreis bilden, können aus L gelöscht werden.<br><br>
|
||||
<a href="http://www.fmi.uni-passau.de/~blochg/mst/kruskal.html">Animation für Kruskal</a>
|
||||
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 3.7 KiB |
@@ -0,0 +1,30 @@
|
||||
<!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>Hashing</title>
|
||||
</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>Hashing</h1>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.vameo.de/uni/tutorium/hash.pdf">Merkblatt zu Hash-Verfahren von Augustin</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,32 @@
|
||||
<!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>Haskell - Syntax</title>
|
||||
</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>Haskell Syntax</h1>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.cs.uu.nl/~afie/haskell/tourofsyntax.html">Tour of the Haskell Syntax</a>
|
||||
<br>
|
||||
<a href="http://www.zvon.org/other/haskell/Outputglobal/index.html">Haskell Funktions Referenz (eine Art API)</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
@@ -0,0 +1,30 @@
|
||||
<!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>Heaps</title>
|
||||
</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>Heaps</h1>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.vameo.de/uni/tutorium/heaps.pdf">Merkblatt zu Heaps von Augustin</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 5.0 KiB |
@@ -0,0 +1,62 @@
|
||||
<!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>Imperative und deklarative Programmiersprachen</title>
|
||||
</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>Imperative und deklarative Programmiersprachen</h1>
|
||||
|
||||
<h2>Imperative Programmiersprachen</h2>
|
||||
In imperativen (befehlsorientierten) Programmiersprachen wie Java, C, Pascal, etc. wird der Zustand des Systems explizit verändert. Es gibt Variablen, die zur Laufzeit verändert werden können. Imperative Sprachen sind Hochsprachen, was fortgeschrittene Methoden und Konstrukte wie Objektorientierung oder Schleifen erlaubt, was den Code leichter verständlich macht. Allerdings wird der Code oft wesentlich länger im Vergleich zu funktionalen Programmiersprachen.
|
||||
|
||||
<h2>Deklarative Programmiersprachen</h2>
|
||||
<!-- Untergruppen: relationale/logische & funktionale<br> -->
|
||||
In deklarativen Programmiersprachen ist eine Änderung von Werten per Zuweisung nicht möglich, was auch bedeutet, dass z.B. Rückgabewerte von Funktionen im Normalfall nirgendwo gespeichert sondern nur ausgegeben werden. Der Code wird durch die Deklaration über Funktionen kurz gehalten, was ihn aber oft auch schwer verständlich macht. Funktionale Sprachen eignen sich gut zur Spezifikation, da mit ihnen Fehler leicht entdeckt werden können.
|
||||
|
||||
<h2>Klassifizierungen</h2>
|
||||
<table border="0">
|
||||
<tr>
|
||||
<td>Java</td><td>imperativ & objektorientiert</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Pascal</td><td>imperativ, prozedural</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>DML</td><td>imperativ, nicht-prozedural</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Haskell</td><td>deklarativ, funktional</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Prolog</td><td>deklarativ, relational/logisch</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>C++</td><td>hybrid aus imperativem C und objektorientierten Erweiterungen</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
Imperative Sprachen werden oft mit <i>prozeduralen Sprachen</i> gleichgesetzt, was jedoch nicht richtig ist. Während in imperativen Sprachen geschriebene Programme durch die Variablenmanipulation einen internen Zustand haben (wie ein Automat), ist prozedurales Programmieren auch ohne dies möglich. Ein Beispiel für eine prozedurale, nicht imperative Sprache ist die Lehrsprache LOGO. (In LOGO werden oft sog. Turtle-Grafiken erstellt: Es wird eine "Schildkröte" programmiert, die über eine Fläche läuft und dabei eine Linie zieht. Die "Schildkröte" selbst akzeptiert nur relative Befehle wie LINKS, RECHTS oder STOPP, hat aber keine Information über ihre Position o.ä. Die Programme haben keinen aktuellen Zustand sondern werden nur sequenziell abgearbeitet.)
|
||||
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.wikiservice.at/dse/wiki.cgi?DeklarativeProgrammierung">DSE: Deklarative Programmierung</a><br>
|
||||
<a href="http://foldoc.doc.ic.ac.uk/foldoc/foldoc.cgi?imperative+languages">FOLDOC: imperative languages</a><br>
|
||||
<a href="http://foldoc.doc.ic.ac.uk/foldoc/foldoc.cgi?declarative+languages">FOLDOC: declarative languages</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,221 @@
|
||||
<!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" media="print, embossed" href="druck.css">
|
||||
<title>Wiki: Algorithmen und Programmierung</title>
|
||||
<style type="text/css">
|
||||
@media screen
|
||||
{
|
||||
body { font-size: 10pt; font-family: "Trebuchet MS", Georgia, serif; background-color: #FFFFFF }
|
||||
td { font-size: 10pt; }
|
||||
h1 { font-size: large; text-align: center; color: #004080; }
|
||||
h2 { font-size: medium; text-align: left; color: #004080; }
|
||||
ol { font-size: small; font-weight: bold; color: #000000; }
|
||||
ul { font-size: x-small; color: #000000; }
|
||||
a { color: #FF8000; text-decoration:none; }
|
||||
a:hover { color: #C04040; text-decoration:none; font-weight: bold; }
|
||||
#updates { font-size: 80%; font-family: "Courier New", monospace; color: #C0C0C0; }
|
||||
#menu { font-size: 70%; }
|
||||
#buttons { position: absolute; right: 20px; top: 20px; text-align: right; }
|
||||
}
|
||||
@media print
|
||||
{
|
||||
body { font-size: 10pt; font-family: "Trebuchet MS", Georgia, serif; background-color: #FFFFFF }
|
||||
td { font-size: 10pt; }
|
||||
h1 { font-size: large; text-align: center; color: #000000; }
|
||||
h2 { font-size: medium; text-align: left; color: #000000; }
|
||||
ol { font-size: small; font-weight: bold; color: #000000; }
|
||||
ul { font-size: x-small; color: #000000; }
|
||||
a { color: #000000; text-decoration:none; }
|
||||
#updates { display: none; }
|
||||
#menu { display: none; }
|
||||
#buttons { display: none; }
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<div style="border: 1px dashed #FF8000; background-color:#FFFFFF; color:#000000; margin: 1ex; padding: 2ex; padding-left: 5ex; font-family: Arial, sans-serif; text-align: left;">
|
||||
Diese Seiten entstanden im März 2004 während unserer Vorbereitung auf die Vordiplomprüfung in Algorithmen & Programmierung.<br />
|
||||
Autoren: Bettina Selig, Vera Kern und Tilman Walther
|
||||
</div>
|
||||
|
||||
|
||||
<p>
|
||||
Bei Bedarf zu den einzelnen Punkten eine Unterseite anlegen und von dieser Seite verlinken.
|
||||
</p>
|
||||
|
||||
<div id="buttons">
|
||||
<p>
|
||||
|
||||
<br />
|
||||
|
||||
<br />
|
||||
|
||||
</p>
|
||||
<form action="newpage.php">
|
||||
<p>
|
||||
<input type="button" value="Neue Seite anlegen" onClick="self.location.href='newpage.php'">
|
||||
</p>
|
||||
</form>
|
||||
<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>
|
||||
|
||||
<div id="updates">
|
||||
Änderungen:<br>
|
||||
01.03.2004 17:30 - Erste Bestandsaufnahme<br>
|
||||
05.03.2004 15:40 - Zeitplan hinzugefügt<br>
|
||||
08.03.2004 22:34 - Aufgaben mit Lösungen online gestellt<br>
|
||||
23.03.2004 20:05 - Zeitplan überarbeitet<br>
|
||||
23.03.2004 20:33 - Stylesheets für Druckfunktion angepasst
|
||||
</div>
|
||||
|
||||
<p>
|
||||
<a href="allg.php">Allgemeines - Links zu allgemeinen Seiten</a><br>
|
||||
<a href="aufgaben.php"><b>Allgemeine Aufgaben</b></a><br>
|
||||
<a href="schweppesMostWanted.php">Schweppe's most wanted</a><br>
|
||||
</p>
|
||||
|
||||
<p>
|
||||
<a href="schweppeProtokollFragen.php"><b>Fragen aus Schweppe-Protokollen und die Antworten darauf</b></a><br>
|
||||
</p>
|
||||
|
||||
<p>
|
||||
<a href="themenBearbeitung.php">Themenaufteilung</a><br>
|
||||
<a href="kleinigkeiten.php">Kleinigkeiten</a><br>
|
||||
<a href="deprecated.php">Doch nicht so wichtig</a>
|
||||
</p>
|
||||
|
||||
<ol>
|
||||
<li>
|
||||
Haskell
|
||||
<ul>
|
||||
<li>
|
||||
<a href="haskellSyntax.php">Syntax</a>
|
||||
</li>
|
||||
<li>
|
||||
Stack, Heap, Bäume, Rekursionen
|
||||
</li>
|
||||
<li>
|
||||
<a href="begriffeInHaskell.php">Lazy Evaluation, Matching, Currying, Call-by-Name vs. Call-by-Value, transformieren von Higher-Order-Functions in Lower-Order-Functions</a>
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
<a href="lambda-kalkuel.php">Lamda-Kalkül</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="induktion.php">Beweise: Induktion</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="prf.php">Primitiv-Rekursive Funktionen</a>
|
||||
<ul>
|
||||
<li>
|
||||
µ-rekursive Funktionen
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
<a href="java.php">Java</a>
|
||||
<ul>
|
||||
<li>
|
||||
<a href="java.php#objektorientierung">Objektorientierung</a>: <a href="java.php#datenstrukturen">Datenstrukturen</a>, <a href="java.php#attribute">Sichtbarkeit</a>, <a href="java.php#geheimnisprinzip">Geheimnisprinzip</a>, <a href="java.php#polymorphie">Polymorphie</a>, <a href="java.php#call-by">Call-by-Value vs. Call-by-Reference</a>, <a href="java.php#assertions">Assertions</a>, Exceptions...
|
||||
</li>
|
||||
<li>
|
||||
<a href="java.php#entwurfsmuster">Entwursmuster / Patterns</a>
|
||||
</li>
|
||||
<li>
|
||||
Bäume, Heaps, Hashes, Prioritätsschlange
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
<a href="imperativVsDeklarativ.php">Imperatives Programmieren vs. deklaratives Programmieren</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="verifikation.php">Verifikation und Validation</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="Spezifikationen.php">Spezifikation</a>
|
||||
<ul>
|
||||
<li>
|
||||
Invarianten (Spezifikationsinvariante, konkrete Invariante)
|
||||
</li>
|
||||
<li>
|
||||
<a href="abstraktionsprinzip.php">Abstraktionsprinzip</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="uml.php">UML</a>
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
<a href="o-notation.php">Laufzeitbestimmung, O-Notation</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="rekursion.php">Rekursionen und Entrekursivierung</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="abstraktdata.php">Abstrakte Datentypen</a>
|
||||
<ul>
|
||||
<li>
|
||||
Verkettete Listen, <a href="heaps.php">Heaps</a>, <a href="hashing.php">Hashes</a>, (Prioritäts-)Schlange
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
Algorithmen:
|
||||
<ul>
|
||||
<li>
|
||||
<a href="sortieralgorithmen.php">Sortieralgorithmen: Quicksort, Mergesort, Bubblesort, Insertionsort, topologisches Sortieren</a>, Radixsort, Selectionsort
|
||||
</li>
|
||||
<li>
|
||||
Mischalgorithmen: Perfect Shuffle → Randomisierung z.B. für Quicksort
|
||||
</li>
|
||||
<li>
|
||||
Suchalgorithmen
|
||||
</li>
|
||||
<li>
|
||||
<a href="greedy.php">Greedy-Algorithmen: Dijkstra, Prim, Kruskal</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="weitereAlgorithmen.php">Huffman, RSA, Verschiebefunktion, Ackermannfunktion</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="eigenschaftenVonAlgorithmen.php">Eigenschaften von Algorithmen: Abstraktion, Diskretheit, Endlichkeit vs. Terminierung, Determinismus vs. Determiniertheit</a>
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
Relationen, Ordnungsrelationen
|
||||
</li>
|
||||
<li>
|
||||
<a href="graphenUndBaeume.php">Graphen und Bäume</a>
|
||||
<ul>
|
||||
<li>
|
||||
<a href="baeume.php">AVL-Bäume, B-Bäume, Rot-Schwarz-Bäume, Digitalbäume, Patricia-Bäume, Suffixbäume</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="tiefen-breitensuche.php">Breiten- und Tiefensuche</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="adjazenz.php">Adjazenzlisten, Adjazenzmatrix</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="wichtigeBegriffeDerGraphentheorie.php">Aufspannende Bäume, kürzeste Wege, Wälder, Mehrwegbäume, konvexe Hülle</a>
|
||||
</li>
|
||||
<li>
|
||||
<a href="infixpostfix.php">Infix, Prefix und Postfix, Inorder, Preorder, Postorder</a>
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,64 @@
|
||||
<!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>Vollständige Induktion</title>
|
||||
</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>Vollständige Induktion</h1>
|
||||
|
||||
Das Beweisen der Aussage A(n) durch vollständige Induktion wird in folgende Schritte eingeteilt:<br><br>
|
||||
<b>Induktionsanfang</b> A(0)<br>
|
||||
Wenn der Induktionsanfang abgesichert ist, dann weiß man, daß die Aussage für ein bestimmtes n (meistens nimmt man 0 oder 1) stimmt.
|
||||
<br><br>
|
||||
<b>Induktionsvoraussetzung</b> A(n)<br>
|
||||
ist die eigentliche Aussage, bei der wir für die folgenden Schritte annehmen, dass sie stimmt.
|
||||
<br><br>
|
||||
<b>Induktionsbehauptung</b> A(n+1)<br>
|
||||
müssen wir im nächsten Schritt beweisen, damit wir wissen, dass die Aussage wahr ist.
|
||||
<br><br>
|
||||
<b>Induktionsschritt</b> Beweis von A(n+1) durch A(n)<br>
|
||||
Hier formen wir die Formel A(n+1) so um, dass wir A(n) einsetzen können und eine wahre Aussage entsteht.
|
||||
<br><br><br>
|
||||
<b>Verdeutlichung an einem simplen Beispiel:</b><br>
|
||||
Eine natürliche Zahl n heißt geraden wenn n = 2x und ungerade, wenn n = 2x + 1, wobei x ∈ N. Wir beweisen, dass eine natürliche Zahl n entweder gerade oder ungerade sein muss.<br><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Induktionsanfang</b></td>
|
||||
<td>A(0): 0 ist gerade ∨ 0 ist ungerade, da 2⋅0 = 2 → 0 ist gerade</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>Induktionsvoraussetzung</b></td>
|
||||
<td>A(n): n ist gerade ∨ n ist ungerade</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>Induktionsbehauptung</b></td>
|
||||
<td>A(n+1): n+1 ist gerade ∨ n+1 ist ungerade</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>Induktionsschritt</b>
|
||||
<td>1. Fall: n ist gerade<br>
|
||||
Es gibt ein x ∈ N, so dass n = 2x. Dann ist n+1 = 2x + 1 → n+1 ist ungerade.<br>
|
||||
2. Fall: n ist ungerade<br>
|
||||
Es gibt ein x ∈ N, so dass n = 2x + 1. Dann ist n+1 = (2x + 1) + 1 = 2x + 2 = 2⋅(x+1) → n+1 ist gerade.<br>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.fh-wedel.de/~si/seminare/ws03/Ausarbeitung/4.listen/listen3.html">Beweis von <b>rev (rev xs) = xs</b></a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,65 @@
|
||||
<!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>Infix-, Postfix- und Präfix-Darstellung</title>
|
||||
</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>Infix, Postfix und Präfix</h1>
|
||||
|
||||
<b>Infix</b> ist die Darstellung wie wir sie normalerweise benutzen. Die Operatoren stehen zwischen den Operanden.<br>
|
||||
Bei <b>Postfix</b> werden die Operatoren hinter die Operanden geschrieben. Die Operanden werden von vorne nach hinten und die Operatoren von hinten nach vorne durchgearbeitet.<br>
|
||||
Bei <b>Postfix</b> ist es genau andersherum als bei Postfix. Die Operatoren stehen vor den Operanden. <br><br>
|
||||
|
||||
<table border="1">
|
||||
<tr>
|
||||
<td><b>Infix</b></td>
|
||||
<td><b>Postfix</b></td>
|
||||
<td><b>Präfix</b></td>
|
||||
<td><b>Ergebnis</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>5 + 3 * 5 / 10</td>
|
||||
<td>5 3 5 10 / * +</td>
|
||||
<td>+ 5 * 3 / 5 10</td>
|
||||
<td>6,5</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>((2 + 3) * 5 + 1) / 2</td>
|
||||
<td>2 3 + 5 * 1 + 2 /</td>
|
||||
<td>/ + * + 2 3 5 1 2</td>
|
||||
<td>13</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br><br>
|
||||
|
||||
|
||||
<h2>Termbäume</h2>
|
||||
Terme kann man auch als Bäume darstellen. <br>
|
||||
Die Termbäume für die obigen Beispiele sind folgende:<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src="termbaum1.gif"></td>
|
||||
<td><img src="termbaum2.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
Durchläuft man einen solchen Termbaum in <b>Preorder</b> (mitte - links - rechts), erhält man einen <b>Präfix-Term</b>. Wenn man ihn in <b>Postorder</b> (links - rechts - mitte) durchlauft, bekommt man einen <b>Postfix-Term</b> und bei <b>Inorder</b> (links - mitte - rechts) einen <b>Infix-Term</b>.<br><br>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="mdl_Abitur-1.pdf">Mündliche Abiprüfung zu Prä- und Postfix</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,235 @@
|
||||
<!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>Java</title>
|
||||
</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>Java - Programmierparadigmen, Architekturprinzipien, Datenstrukturen & Algorithmen</h1>
|
||||
<small>Anm.:
|
||||
<ol>
|
||||
<li>Dass der geneigte Leser die Sprache Java auf ALP2-Niveau beherrscht, wird vorausgesetzt. Insofern lag die Schwierigkeit beim Schreiben haupsächlich in der Reduktion auf das Wesentliche, da man die Balance zwischen Verständlichkeit und Wiederholung von bekanntem finden musste. Also im Zweifel noch mal nachrecherchieren (s.a. <a href="#links">Links</a>) bzw. überspringen.
|
||||
</li>
|
||||
<li>
|
||||
Da es in Java keine Funktionen, sondern nur Methoden (die auf Objekten arbeiten) gibt, werden die beiden Begriffe hier synonym verwendet.
|
||||
</li>
|
||||
</ol>
|
||||
</small>
|
||||
|
||||
<h2><a name="objektorientierung"></a>Objektorientierung</h2>
|
||||
|
||||
<h3><a name="attribute"></a>Attribute & Sichtbarkeit</h3>
|
||||
<p>
|
||||
<p>
|
||||
Ein Bezeichner (eine Variable) <i>x</i> heißt <i>sichtbar</i> an einer Programmstelle, wenn er in einem der die Programmstelle umgebenden Blöcke vereinbart wurde. Man unterscheidet innerhalb von Klassen zwischen <i>globalen</i> und <i>lokalen</i> Variablen. Während globale Variablen innerhalb der ganzen Klasse gültig sind, haben lokale Variablen nur einen begrenzten Geltungsbereich (innerhalb ein Methode, Schleife oder eines Blocks).
|
||||
</p>
|
||||
<p>
|
||||
Lokale Variablen verdecken globale, wenn sie denselben Bezeichner haben. D.h.: Existiert eine globale Variable <i>a</i> und definiert eine Methode erneut eine Variable <i>a</i>, so wird innerhalb der Methode durch den Bezeichner 'a' immer die lokale Variable angesprochen. Auf die globale Variable kann mithilfe des Schlüsselworts <span id="syntax">this</span> explizit zugegriffen werden.
|
||||
</p>
|
||||
<p>
|
||||
Die Sichtbarkeit von Variablen kann durch die Attribute <span id="syntax">public</span>, <span id="syntax">private</span> und <span id="syntax">protected</span> beeinflusst werden:
|
||||
<p>
|
||||
<table border="1" style="empty-cells:hide; border-collapse:collapse;">
|
||||
<tr>
|
||||
<td><b>Sichtbarkeit</b></td><td>Innerhalb der Package</td><td>Abgeleitete Klassen</td><td>Außerhalb der Package</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>private</td><td>unsichtbar</td><td>unsichtbar</td><td>unsichtbar</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><i>default</i></td><td>sichtbar</td><td>unsichtbar</td><td>unsichtbar</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>protected</td><td>sichtbar</td><td>sichtbar</td><td>unsichtbar</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>public</td><td>sichtbar</td><td>sichtbar</td><td>sichtbar</td>
|
||||
</tr>
|
||||
</table>
|
||||
</p>
|
||||
Java-Klassen können entweder mit dem Attribut <span id="syntax">public</span> versehen werden (dann sind sie von überall erreichbar) oder Attributfrei sein. In diesem Fall haben sie <i>default</i>-Sichtbarkeit und können nur von Klassen aus derselben Package erreicht werden.
|
||||
</p>
|
||||
</p>
|
||||
<p>
|
||||
Beispiel:<br>
|
||||
<pre>
|
||||
package fahrzeuge;
|
||||
|
||||
public class Auto {
|
||||
|
||||
private int a = 1; /* a ist globale Variable in <i>Auto</i> und durch das Attribut
|
||||
* <i>private</i> außerhalb der Klasse unsichtbar. Zuweisungen
|
||||
* der Art myAuto.a = 5; sind nicht möglich. Die Variable
|
||||
* wird nicht mitvererbt.
|
||||
*/
|
||||
|
||||
public int b = 2; /* b ist globale Variable in <i>Auto</i> und durch das Attribut
|
||||
* <i>public</i> von überall zu erreichen. Instanzen der Klasse
|
||||
* akzeptieren Zuweisungen der Art myAuto.b = 8;
|
||||
*/
|
||||
|
||||
protected int c = 3; /* c ist globale Variable in <i>Auto</i>. Durch das Attribut
|
||||
* <i>protected</i> wird die Sichtbarkeit auf derselben package
|
||||
* beschränkt. Die Variable wird an Ableitungen von Auto
|
||||
* vererbt.
|
||||
*/
|
||||
|
||||
|
||||
public int getNumber(int x) {
|
||||
|
||||
int a = 4; /* a ist lokale Variable in getNumber() und verdeckt
|
||||
* innerhalb von getNumber() die globale Variable a
|
||||
*/
|
||||
|
||||
if (x < 10) return a; // Gibt 4 zurück
|
||||
|
||||
if (x > 20) return b; // Gibt 2 zurück. (Die globale Variable ist
|
||||
// überall in Auto gültig
|
||||
|
||||
return this.a; // Gibt 1 aus. (durch das Schlüsselwort
|
||||
// this wird die globale Variable a
|
||||
// angesprochen
|
||||
}
|
||||
|
||||
private String getPolicy() {
|
||||
return ("Diese Methode kann nur innerhalb von Auto verwendet werden. " +
|
||||
"Sie wird nicht mitvererbt.");
|
||||
}
|
||||
|
||||
protected String getLiberalPolicy() {
|
||||
return ("Diese Methode kann innerhalb von Auto und von allen Klassen aus " +
|
||||
"der Package <i>fahrzeuge</i> verwendet werden. " +
|
||||
"Sie wird an abgeleitete Klassen vererbt.");
|
||||
}
|
||||
|
||||
}
|
||||
</pre>
|
||||
</p>
|
||||
<p>
|
||||
Weitere Atribute in Java sind <span id="syntax">static</span>, <span id="syntax">final</span> und die (eher speziellen und daher hier nicht näher beschriebenen) Attribute <span id="syntax">transient</span> und <span id="syntax">volatile</span>.<br>
|
||||
<p>
|
||||
<span id="syntax"><b>static</b></span><br>
|
||||
Das Schlüsselwort <span id="syntax">static</span> ist auf Variablen und Methoden anwendbar. Ist eine Variable oder Methode mit dem Attribut <span id="syntax">static</span> belegt, so existiert sie für sämtliche Instanzen der Klasse zuammen nur einmal. Statische Variablen sind sogenannte Klassenvariablen. Ändert eine Klasse eine statische Variable, so ist sie auch für alle anderen Instanzen geändert.<br>
|
||||
Da statische Variablen und Methoden keiner bestimmten Instanz angehören, können sie auch direkt über den Klassennamen erreicht werden, ohne dass erst eine Instanz der Klasse erstellt werden müsste.<br>
|
||||
</p>
|
||||
<p>
|
||||
<span id="syntax"><b>final</b></span><br>
|
||||
Das Schlüsselwort <span id="syntax">final</span> ist auf Variablen, Methoden und Klassen anwendbar.
|
||||
<ul>
|
||||
<li>
|
||||
Finale Variablen müssen initialisiert werden und können zur Laufzeit nicht mehr verändert werden. (Sie ersetzen damit die in anderen Sprachen üblichen Konstanten.)
|
||||
</li>
|
||||
<li>
|
||||
Finale Methoden können von abgeleiteten Klassen nicht überschrieben werden.
|
||||
</li>
|
||||
<li>
|
||||
Finale Klassen können nicht abgeleitet werden, sie beenden die Vererbungskette und können nicht mehr erweitert werden.
|
||||
</li>
|
||||
</ul>
|
||||
Da Elemente, die mit dem Attribut <span id="syntax">final</span> nicht änderbar sind, kann die Virtual Machine zur Laufzeit auf erneutes Laden von Variablen bzw. auf dynamische Methodensuche verzichten, weshalb finale Elemente oft deutlich performanter bearbeitet werden können.
|
||||
</p>
|
||||
</p>
|
||||
|
||||
<h3><a name="geheimnisprinzip"></a>Geheimnisprinzip</h3>
|
||||
<p>
|
||||
([<i>principle of</i>] <i>information hiding</i>) bezeichnet nach [Parnas '72] ein Entwurfsprinzip für Module. Module sollen ihre konkrete Implementierung verbergen. ("Jedes Modul hat ein Geheimnis!")<br>Komponenten eines Softwaresystems werden als Black Boxes betrachtet, die nur relevante Informationen nach außen zeigen. In Java wird das Geheimnisprinzip insbesondere über Interfaces sowie die Attribute <span id="syntax">private</span> und <span id="syntax">protected</span> realisiert.<br>
|
||||
Vorteile liegen in der konsequenten Modularisierung: Austauschbarkeit der Implementierung einer Klasse (bei Beibehaltung des Interfaces).<br>
|
||||
Das Geheimnisprinzip ist auch für → Abstrakte Datentypen von Bedeutung.
|
||||
</p>
|
||||
|
||||
<h3><a name="polymorphie"></a>Polymorphie</h3>
|
||||
<p>
|
||||
Polymorphie (lat. für Vielgestaltigkeit) bezeichnet Eigenschaft einer Variablen, für Objekte verschiedener Klassen stehen zu können. Es gibt verschiedene Arten von Polymorphie:<br>
|
||||
<ul>
|
||||
<li>
|
||||
<b>Universelle Polymorphie</b><br>
|
||||
Universell polymorphe Funktionen bearbeiten Objekte mit ähnlichen Eigenschaften auf dieselbe Weise. Man unterschiedet zwischen Inklusionspolymorphie und parametrischer Polymorphie:
|
||||
<ul>
|
||||
<li>
|
||||
<b>Inklusionspolymorphie (Vererbung)</b> - eine Instanzvariable kann auch Objekte von Unterklassen aufnehmen. So kann eine Variable vom Typ <i>Motorrad</i> außer Motorrad-Objekten, auch solche vom Typ <i>Suzuki</i> oder <i>HarleyDavidson</i> aufnehmen.
|
||||
</li>
|
||||
<li>
|
||||
<b>Parametrische Polymorphie (Typvariablen)</b> - eine Methode akzeptiert Parameter allgemeinen Typs (<i>Generizität</i>). In Java wird dies durch Methoden, die als Parameter den Typ <i>Object</i> akzeptieren realisiert. (Was ja eigentlich Inklusionspolymorphie ist - mal sehen was mit Java 1.5 kommt...) In Haskell gibt es den allgemeinen Parameter <i>a</i>.
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
<b>Ad hoc Polymorphie (Überladen)</b><br>
|
||||
Bei der Ad-hoc-Polymorphie, liegt den verschiedenen Parametern keine gemeinsame Struktur zugrunde. Die verschiedenen Typen werden unterschiedlich behandelt. Man erreicht dies durch <i>Überladen</i> von Methoden: Eine Methode kann mehrfach für verschiedene Parameter existieren.
|
||||
</li>
|
||||
</ul>
|
||||
</p>
|
||||
|
||||
<h3><a name="assertions"></a>Assertions</h3>
|
||||
<p>
|
||||
Assertions (Zusicherungen) dienen zur Überprüfung von Invarianten, um Programme robuster zu machen. Dazu wird das Programm mit dem Schlüsslwort <span id="syntax">assert</span> (ab Java 1.4) angewiesen, eine Bedingung auf Wahrheit zu überprüfen. Trifft diese (i.d.R. wider Erwarten) nicht zu, wird eine Exception ausgelöst. Der Compiler kann über Parameter angewiesen werden, die Zusicherungen an- oder abzustellen, so dass diese z.B. nur während der Entwicklung genutzt werden und für die endgültige Fassung eines Programms zur Laufzeitoptimierung wegfallen.
|
||||
</p>
|
||||
|
||||
<h3><a name="call-by"></a>Parameterübergabe: Call by value vs. Call by reference</h3>
|
||||
<h4>Call by value</h4>
|
||||
<p>
|
||||
Der Parameter einer Methode entspricht eriner lokalen Variable, die bei Aufruf mit dem übergebenen Wert initialisiert wird (Parameter-Kopie). Ändert eine Methode den Parameter, so betrifft dies nur ihre lokale Kopie, nicht die übergebene Variable. In Java werden alle primitiven Datentypen per Call by value übergeben.
|
||||
</p>
|
||||
<h4>Call by reference</h4>
|
||||
<p>
|
||||
Paramter werden als Verweis auf eine Variable übergeben. Ändert eine Methode den Parameter, so ist auch die übergebene Variable geändert. In Java werden Objekte als Zeiger übergeben, so dass Änderungen immer global gelten.
|
||||
</p>
|
||||
<h4>Call by result</h4>
|
||||
<p>
|
||||
(Teilw. auch <i>call-by-value-return</i>, u.a. auch bei Schweppe.) Hier wird zunächst das Ergebnis berechnet, und dann in Parameter-Variablen zurückgegeben.
|
||||
</p>
|
||||
<p>
|
||||
Beispiel (<b>kein Java!</b>):
|
||||
<pre>
|
||||
void solve(in float p, in float q, out float x1, out float x2)
|
||||
{
|
||||
float root = sqrt(p*p/4 - q);
|
||||
x1 = -p/2 + root;
|
||||
x2 = -p/2 - root;
|
||||
}
|
||||
</pre>
|
||||
</p>
|
||||
|
||||
<h4>Call by name</h4>
|
||||
<p>
|
||||
Entspricht <i>lazy evaluation</i> wie z.B. in Haskell. Vom Ergebnis so wie <i>Call by reference</i>, allerdings mit anderer Semantik: Der übergebene <i>Bezeichner</i> ersetzt beim Aufruf den Parameter der Methodendeklaration, also so ähnlich wie Makros in C. So eine Art automatisches Copy'n'Paste. Die Sprache ALGOL verwendet dieses System, das bei modernen Sprachen kaum noch Anwendung findet. (s.a. <a href="http://foldoc.doc.ic.ac.uk/foldoc/foldoc.cgi?call-by-name">FOLDOC: call-by-name</a>)
|
||||
</p>
|
||||
|
||||
<h2><a name="entwurfsmuster"></a>Entwurfsmuster</h2>
|
||||
<p>
|
||||
Entwurfsmuster (engl. <i>Design Patterns</i>) sind - in der Softwaretechnik - Lösungen für häufig auftretende Problemtypen im Programmdesign. Durch die Verwendung von Entwurfsmustern soll der Code robuster, eleganter und schneller werden, da man das Rad nicht immer neu erfindet, sondern stattdessen erprobte Lösungen verwendet. (Das Problem liegt also eher darin, die passende Lösung aus den bekannten herauszusuchen.)<br>
|
||||
</p>
|
||||
<h3>Häufig verwendete Entwurfsmuster</h3>
|
||||
<ul>
|
||||
<li>Singleton - Eine Klasse, von der nur eine Instanz erzeugt werden kann</li>
|
||||
<li>Immutable - Eine Klasse, die nach der Initialisierung nicht mehr veränderbar ist</li>
|
||||
<li>Interface - Trennt Eigenschaften von der Implementierung</li>
|
||||
<li>Iterator - Durchläuft alle Elemente eine Collection</li>
|
||||
<li>Factory - Übernimmt die Initialisierung und Instanziierung von verschiedenen Klassen mit gemeinsamen Eigenschaften</li>
|
||||
</ul>
|
||||
|
||||
|
||||
<h2><a name="datenstrukturen"></a>Datenstrukturen & Implementierungen</h2>
|
||||
<p>
|
||||
</p>
|
||||
|
||||
|
||||
<h2><a name="links"></a>Links</h2>
|
||||
<p>
|
||||
<a href="http://www.galileocomputing.de/openbook/javainsel2/">Java ist auch eine Insel</a><br>
|
||||
<a href="http://www.dockter-its.de/jthemen/">Bemerkungen zu den (derzeitigen) Defiziten, z.B. Generics</a>
|
||||
</p>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,33 @@
|
||||
<!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>Kleinigkeiten</title>
|
||||
</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>Kleinigkeiten / Anderes</h1>
|
||||
<center>Hier ist Platz für Dinge, die kein eigenes Alp-Thema darstellen, die man aber vielleicht trotzdem wissen sollte/möchte<br>Also immer schön ergänzen und Fragen stellen</center>
|
||||
|
||||
<h2>Compiler vs. Interpreter</h2>
|
||||
<b>[<i>kommt bald</i>]</b>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 4.7 KiB |
@@ -0,0 +1,65 @@
|
||||
<!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>Das Lambda-Kalkül</title>
|
||||
</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>Das λ-Kalkül - die kleinste Programmiersprache</h1>
|
||||
<p>
|
||||
Idee: 1900 stellt Hilbert die Frage nach der Existenz einem automatischen Verfahren, mit dem man alle Sätze der Mathematik beweisen kann.<br>
|
||||
Turing und Church beweisen 1930, dass es ein solches Verfahren nicht gibt.<br>
|
||||
Das λ-Kalkül bildet die mathematische Grundlage für funktionale Programmiersprachen.
|
||||
</p>
|
||||
<p style="font-family: monospace">
|
||||
<name> := a | b | c | a1 | b2...<br>
|
||||
<expression> := <name> | <function> | <application><br><br>
|
||||
<function> := λ<name>.<expression><br>
|
||||
<application> := <expression><expression>
|
||||
</p>
|
||||
<h2>Reduzieren von Ausdrücken:</h2>
|
||||
<p style="font-family: monospace">
|
||||
λx.x y → y<br>
|
||||
(λx.xy)z → zy<br>
|
||||
(λx.(λy.xy))ab → (λy.ay)b → ab
|
||||
</p>
|
||||
<h2>Zahlen</h2>
|
||||
<p style="font-family: monospace">
|
||||
0 ≡ λs(λz.z)<br>
|
||||
1 ≡ λs(λz.s(z))<br>
|
||||
2 ≡ λs(λz.s(s(z)))<br>
|
||||
usw.
|
||||
</p>
|
||||
<h2>Funktionen</h2>
|
||||
<p style="font-family: monospace">
|
||||
Nachfolgefunktion:<br>
|
||||
S ≡ λwyz.y(wyz)<br>
|
||||
5S4 ≡ S(S(S(S(S(4))))) ≡ 9
|
||||
<br><br>
|
||||
True: T ≡ λxy.x<br>
|
||||
False: F ≡ λxy.y<br>
|
||||
<br>
|
||||
And: ∧ ≡ λxy.xyF<br>
|
||||
Or: &or ≡ λxy.xTy<br>
|
||||
Not: ¬ ≡ λx.xFT
|
||||
</p>
|
||||
<h2>Links</h2>
|
||||
<p>
|
||||
<a href="http://www.betoerend.de/dasLandHinterDemEndeDesSinns/lambda/welcome.html">Das gefürchtete Lambda-Kalkül</a> - <b>Ist leider nicht mehr online! </b> Wer eine Kopie findet, bitte eintragen.<br>
|
||||
<a href="http://de.wikipedia.org/wiki/Lambda-Notation">Kurze Wikipedia-Erläuterung zur Lambda-Notation</a>
|
||||
</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,258 @@
|
||||
-- Aufgabe 1: Quicksort
|
||||
|
||||
qsort :: Ord (a) => [a] -> [a]
|
||||
qsort [] = []
|
||||
qsort (x:xs) = qsort[y | y <- xs, y < x] ++ [x] ++ qsort[y | y <- xs, y >= x]
|
||||
|
||||
|
||||
-- Aufgabe 2: Mergesort
|
||||
msort :: Ord (a) => [a] -> [a]
|
||||
msort [] = []
|
||||
msort [x] = [x]
|
||||
msort xs = merge (msort (take half xs)) (msort (drop half xs))
|
||||
where half = (length xs) `div` 2
|
||||
merge [] ys = ys
|
||||
merge xs [] = xs
|
||||
merge (x:xs) (y:ys)
|
||||
| (x < y) = x:(merge xs (y:ys))
|
||||
| otherwise = y:(merge (x:xs) ys)
|
||||
|
||||
-- Aufgabe 3: Insertionsort
|
||||
|
||||
insertionsort :: Ord (a) => [a] -> [a]
|
||||
insertionsort [] = []
|
||||
insertionsort (x:xs) = insert x (insertionsort xs)
|
||||
|
||||
insert :: Ord (a) => a -> [a] -> [a]
|
||||
insert a [] = [a]
|
||||
insert a (x:xs)
|
||||
|a <= x = (a:x:xs)
|
||||
|otherwise = x : (insert a xs)
|
||||
|
||||
-- Aufgabe 4: Selectionsort
|
||||
|
||||
selectionSort :: Ord (a) => [a] -> [a]
|
||||
selectionSort xs
|
||||
| xs == [] = []
|
||||
| otherwise = minimum xs : selectionSort (delete (minimum xs) xs)
|
||||
|
||||
-- die Funktion delete ist im module "List" vorhanden, habe aber keine Ahnung, wie man die importiert
|
||||
delete :: Eq (a) => a -> [a] -> [a]
|
||||
delete x [] = []
|
||||
delete x (y:ys)
|
||||
|x == y = ys
|
||||
|otherwise = y : (delete x ys)
|
||||
|
||||
-- Aufgabe 5: lineare Suche
|
||||
|
||||
linSearch :: Eq(a) => a -> [a] -> Bool
|
||||
linSearch x [] = False
|
||||
linSearch x (y:ys)
|
||||
|x == y = True
|
||||
|otherwise = linSearch x ys
|
||||
|
||||
-- Aufgabe 6: Binäre Suche
|
||||
-- hat Fehler, Hilfe!!!
|
||||
|
||||
binSearch :: Ord a => a -> [a] -> Bool
|
||||
binSearch x [] = False
|
||||
binSearch x xs
|
||||
| (mid == x) = True
|
||||
| (mid > x) = binSearch x (take half xs)
|
||||
| (mid < x) = binSearch x (drop half xs)
|
||||
where mid = head (drop half xs)
|
||||
half = (length xs) `div` 2
|
||||
|
||||
|
||||
-- Aufgabe 7: reverse
|
||||
|
||||
-- naive Implementierung (ja, es gibt eine bessere ; ))
|
||||
|
||||
rev :: [a] -> [a]
|
||||
rev [] = []
|
||||
rev (x:xs) = rev xs ++ [x]
|
||||
|
||||
-- hier die bessere Variante
|
||||
|
||||
rev2 :: [a] -> [a]
|
||||
rev2 xs = rev' [] xs
|
||||
where rev' acc [] = acc
|
||||
rev' acc (x:xs) = rev' (x:acc) xs
|
||||
|
||||
-- Aufgabe 8: Fibonacci
|
||||
|
||||
fibo :: Int -> Int
|
||||
fibo 0 = 0
|
||||
fibo 1 = 1
|
||||
fibo n = fibo (n-1) + fibo(n-2)
|
||||
|
||||
-- mit Akkumulator
|
||||
|
||||
fibo2 :: Int -> Int
|
||||
fibo2 n = fibo' 0 1 n
|
||||
where fibo' a1 a2 0 = a1
|
||||
fibo' a1 a2 n = fibo' (a1+a2) a1 (n-1)
|
||||
|
||||
-- Aufgabe 9: Fakultät
|
||||
|
||||
fak :: Int -> Int
|
||||
fak 1 = 1
|
||||
fak n = n * fak(n-1)
|
||||
|
||||
-- mit Akkumulator
|
||||
|
||||
fak2 :: Int -> Int
|
||||
fak2 n = fak' 1 n
|
||||
where fak' acc 1 = acc
|
||||
fak' acc n = fak' (n*acc) (n-1)
|
||||
|
||||
-- Aufgabe 10: Summer einer Liste
|
||||
|
||||
sumList :: [Int] -> Int
|
||||
sumList [] = 0
|
||||
sumList (x:xs) = x + sumList xs
|
||||
|
||||
-- mit Akkumulator
|
||||
|
||||
sumList2 xs = sumList' 0 xs
|
||||
where sumList' acc [] = acc
|
||||
sumList' acc (x:xs) = sumList'(x+acc) xs
|
||||
|
||||
-- Aufgabe 11: map Funktion
|
||||
|
||||
map' :: (a -> b) -> [a] -> [b]
|
||||
map' f [] = []
|
||||
map' f (x:xs) = (f x) : map' f xs
|
||||
|
||||
-- Aufgabe 12: Binärer Suchbaum
|
||||
|
||||
data BinSTree = E | N BinSTree Int BinSTree
|
||||
|
||||
sumTree :: BinSTree -> Int
|
||||
sumTree E = 0
|
||||
sumTree (N l v r) = v + sumTree l + sumTree r
|
||||
|
||||
contains :: Int -> BinSTree -> Bool
|
||||
contains a E = False
|
||||
contains a (N l v r)
|
||||
|a == v = True
|
||||
|a < v = contains a l
|
||||
|otherwise = contains a r
|
||||
|
||||
insertToTree :: Int -> BinSTree -> BinSTree
|
||||
insertToTree a E = N E a E
|
||||
insertToTree a (N l v r)
|
||||
|a == v = (N l v r)
|
||||
|a < v = N (insertToTree a l) v r
|
||||
|otherwise = N l v (insertToTree a r)
|
||||
|
||||
deleteFromTree :: Int -> BinSTree -> BinSTree
|
||||
deleteFromTree a E = E
|
||||
deleteFromTree a (N l v r)
|
||||
|a == v = insertLeftTree r l
|
||||
|a < v = N l (deleteFromTree a r)
|
||||
|otherwise = N (deleteFromTree a l) v r
|
||||
|
||||
insertLeftTree E t = t
|
||||
insertLeftTree (N l v r) t = N (insertLeftTree l t) v r
|
||||
|
||||
treeToList :: BinSTree -> [Int]
|
||||
treeToList E = []
|
||||
treeToList (N l v r) = treeToList l ++ [v] ++ treeToList r
|
||||
|
||||
-- Aufgabe 13: Ein Stack
|
||||
|
||||
data Stack t = E | NES t (Stack t)
|
||||
deriving(Show)
|
||||
|
||||
createStack :: Stack t
|
||||
createStack = E
|
||||
|
||||
push :: t -> Stack t -> Stack t
|
||||
push x s = NES x s
|
||||
|
||||
pop :: Stack t -> Stack t
|
||||
pop E = error "Stack ist leer"
|
||||
pop (NES x s) = s
|
||||
|
||||
top :: Stack t -> t
|
||||
top E = error "Stack ist leer, kein top"
|
||||
top (NES x s) = x
|
||||
|
||||
size :: Stack t -> Int
|
||||
size E = 0
|
||||
size (NES x s) = 1 + size s
|
||||
|
||||
isEmpty :: Stack t -> Bool
|
||||
isEmpty E = True
|
||||
isEmpty (NES x s) = False
|
||||
|
||||
-- showStack :: Stack t -> String
|
||||
showStack E = "*"
|
||||
showStack (NES x s) = [x] ++ showStack s
|
||||
|
||||
-- Aufgabe 14: Eine Queue
|
||||
|
||||
data Queue t = E | NEQ t (Queue t)
|
||||
|
||||
createQueue :: Queue t
|
||||
createQueue = E
|
||||
|
||||
enqueue :: t -> Queue t -> Queue t
|
||||
enqueue x E = NEQ x E
|
||||
enqueue x (NEQ y q) = NEQ y (enqueue x q)
|
||||
|
||||
dequeue :: Queue t -> Queue t
|
||||
dequeue E = error "Queue leer"
|
||||
dequeue (NEQ x q) = q
|
||||
|
||||
first :: Queue t -> t
|
||||
first E = error "Queue leer"
|
||||
first (NEQ x q) = x
|
||||
|
||||
size :: Queue t -> Int
|
||||
size E = 0
|
||||
size (NEQ x q) = 1 + size q
|
||||
|
||||
isEmpty :: Queue t -> Bool
|
||||
isEmtpy E = True
|
||||
isEmpty (NEQ x q) = False
|
||||
|
||||
-- Aufgabe 15: Eine Menge
|
||||
|
||||
data Set t = E | NES t (Set t)
|
||||
|
||||
createSet :: Eq t => Set t
|
||||
createSet = E
|
||||
|
||||
isIn :: Eq t => t -> Set t -> Bool
|
||||
isIn x E = False
|
||||
isIn x (NES y s)
|
||||
|y == x = True
|
||||
|otherwise = isIn x s
|
||||
|
||||
insert :: Eq t => t -> Set t -> Set t
|
||||
insert x E = NES x E
|
||||
insert x s
|
||||
|isIn x s = s
|
||||
|otherwise = NES x s
|
||||
|
||||
delete :: Eq t => t -> Set t -> Set t
|
||||
delete x E = E
|
||||
delete x (NES y s)
|
||||
|x == y = s
|
||||
|otherwise = insert y (delete x s)
|
||||
|
||||
size :: Eq t => Set t -> Int
|
||||
size E = 0
|
||||
size (NES x s) = 1 + size s
|
||||
|
||||
isEmpty :: Eq t => Set t -> Bool
|
||||
isEmpty s = (size s == 0)
|
||||
|
||||
isSubSet :: Eq t => Set t -> Set t -> Bool
|
||||
isSubSet E s2 = True
|
||||
isSubSet (NES x s1) s2 = (isIn x s2) && isSubSet s1 s2
|
||||
|
||||
isEqualSet :: Eq t => Set t -> Set t -> Bool
|
||||
isEqualSet s1 s2 = (isSubSet s1 s2) && (isSubSet s2 s1)
|
||||
@@ -0,0 +1,517 @@
|
||||
<!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>Lösungen</title>
|
||||
</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>Lösungen</h1>
|
||||
|
||||
<h2>Vollständige Induktion</h2>
|
||||
<table>
|
||||
<tr>
|
||||
<td>1. </td>
|
||||
<td><b>Induktionsanfang</b></td>
|
||||
<td>A(1): 1 = 1<sup>2</sup></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsvoraussetzung</b></td>
|
||||
<td>A(n): 1 + 3 + 5 + ... + (2n - 1) = n<sup>2</sup></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsbehauptung</b></td>
|
||||
<td>A(n+1): 1 + 3 + 5 + ... + (2n - 1) + (2(n+1) - 1) = (n+1)<sup>2</sup></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsschritt</b></td>
|
||||
<td>n → n+1<br>
|
||||
1 + 3 + 5 + ... + (2n - 1) + (2(n+1) - 1) = (n+1)<sup>2</sup><br>
|
||||
n<sup>2</sup> + (2n + 1) = n<sup>2</sup> + 2n + 1 mit IV
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td>2. </td>
|
||||
<td><b>Induktionsanfang</b></td>
|
||||
<td>[] ++ [] = []</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsvoraussetzung</b></td>
|
||||
<td>x ++ [] = x</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsbehauptung</b></td>
|
||||
<td>a:x ++ [] = a:x</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsschritt</b></td>
|
||||
<td>l → l+1, also x → a:x<br>
|
||||
a:x ++ [] = a:x<br>
|
||||
a:(x ++ []) = a:x mit (a)<br>
|
||||
a:x = a:x mit IV<br>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td>3. </td>
|
||||
<td><b>Induktionsanfang</b></td>
|
||||
<td>rev ([] ++ b) = (rev b) ++ (rev [])<br>
|
||||
rev b = (rev b) ++ [] mit (2a), (2)<br>
|
||||
rev b = rev b mit (2a)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsvoraussetzung</b></td>
|
||||
<td>rev (a ++ b) = (rev b) ++ (rev a)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsbehauptung</b></td>
|
||||
<td>rev ((x:a) ++ b) = (rev b) ++ (rev x:a)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsschritt</b></td>
|
||||
<td>l → l+1, also a → x:a<br>
|
||||
rev ((x:a) ++ b) = (rev b) ++ (rev x:a)<br>
|
||||
rev (x:(a ++ b)) = (rev b) ++ (rev a) ++ [x] mit (2b), (b)<br>
|
||||
rev (a ++ b) ++ [x] = (rev b) ++ (rev a) ++ [x] mit (b)<br>
|
||||
rev (a ++ b) ++ [x] = rev (a ++ b) ++ [x] mit IV<br>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td>4. </td>
|
||||
<td><b>Induktionsanfang</b></td>
|
||||
<td>rev (rev []) = []<br>
|
||||
rev [] = [] mit (a)<br>
|
||||
[] = [] mit (a)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsvoraussetzung</b></td>
|
||||
<td>rev (rev xs) = xs</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsbehauptung</b></td>
|
||||
<td>rev (rev x:xs) = x:xs</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>Induktionsschritt</b></td>
|
||||
<td>l → l+1, also xs → x:xs<br>
|
||||
rev (rev x:xs) = x:xs<br>
|
||||
rev ((rev xs) ++ [x]) = x:xs mit (b)<br>
|
||||
(rev [x]) ++ (rev (rev xs)) = x:xs mit (3)<br>
|
||||
(rev [x]) ++ xs = x:xs mit IV<br>
|
||||
[x] ++ xs = x:xs mit (c)<br>
|
||||
x:[] ++ xs = x:xs mit (d)<br>
|
||||
x:([] ++ xs) = x:xs mit (2b)<br>
|
||||
x:xs = x:xs mit (2a)
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2>Primitiv rekursive Funktionen</h2>
|
||||
<table>
|
||||
<tr>
|
||||
<td>
|
||||
Aufstellen der Gleichungen →
|
||||
</td>
|
||||
<td>
|
||||
Einfache Lösungen →
|
||||
</td>
|
||||
<td>
|
||||
Gleichungen mit <b>ψ</b> und <b>χ</b>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>pred</b> (0)<br>
|
||||
<b>pred</b> (n+1)
|
||||
</td>
|
||||
<td>
|
||||
= 0<br>
|
||||
= n
|
||||
</td>
|
||||
<td>
|
||||
= <b>clr</b> ()<br>
|
||||
= <b>p2</b> (pred (n), n)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>eq0</b> (0)<br>
|
||||
<b>eq0</b> (n+1)
|
||||
</td>
|
||||
<td>
|
||||
= 1<br>
|
||||
= 0
|
||||
</td>
|
||||
<td>
|
||||
= <b>suc clr</b> ()<br>
|
||||
= <b>clr</b> (eq0 (n), n)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>sub</b> (0, m)<br>
|
||||
<b>sub</b> (n+1, m)
|
||||
</td>
|
||||
<td>
|
||||
= m<br>
|
||||
= pred (n, m)
|
||||
</td>
|
||||
<td>
|
||||
= <b>p1</b> (m)<br>
|
||||
= <b>pred p1</b> (sub (n, m), n, m)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>and</b> (0, m)<br>
|
||||
<b>and</b> (n+1, m)
|
||||
</td>
|
||||
<td>
|
||||
= 0<br>
|
||||
= m
|
||||
</td>
|
||||
<td>
|
||||
= <b>clr</b> (m)<br>
|
||||
= <b>p3</b> (and (n, m), n, m)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>not</b> (0)<br>
|
||||
<b>not</b> (n+1)
|
||||
</td>
|
||||
<td>
|
||||
= 1<br>
|
||||
= 0
|
||||
</td>
|
||||
<td>
|
||||
= <b>suc clr</b> ()<br>
|
||||
= <b>clr</b> (not (n), n)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>ge</b> (0, m)<br>
|
||||
<b>ge</b> (n+1, m)
|
||||
</td>
|
||||
<td>
|
||||
= eq0 (m)<br>
|
||||
= eq0 (sub (n+1, m))
|
||||
</td>
|
||||
<td>
|
||||
= <b>eq0</b> (m)<br>
|
||||
= <b>eq0 (sub (suc p2, p3))</b> (ge (n, m), n, m)
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>if</b> (0, m<sub>1</sub>, m<sub>2</sub>)<br>
|
||||
<b>if</b> (n+1, m<sub>1</sub>, m<sub>2</sub>)
|
||||
</td>
|
||||
<td>
|
||||
= m<sub>2</sub><br>
|
||||
= m<sub>1</sub>
|
||||
</td>
|
||||
<td>
|
||||
= <b>p2</b> (m<sub>1</sub>, m<sub>2</sub>)<br>
|
||||
= <b>p3</b> (pred (n, m<sub>1</sub>, m<sub>2</sub>), n, m<sub>1</sub>, m<sub>2</sub>)
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2>O-Notation</h2>
|
||||
<ol>
|
||||
<li>log<sub>2</sub> n < √n < n < n(log<sub>2</sub> n)<sup>2</sup> < n<sup>2</sup> < n<sup>3</sup> < 1,8<sup>n</sup> < 3<sup>n</sup></li>
|
||||
<li>(a) Θ(n<sup>2</sup>)<br>
|
||||
(b) Θ(n log<sub>2</sub> n)<br>
|
||||
(c) Θ(n · 4<sup>n</sup>)</li>
|
||||
</ol>
|
||||
|
||||
<h2>Algorithmen</h2>
|
||||
<ol>
|
||||
<li><b>Dijkstra:</b> D(a)=0, D(b)=2, D(c)=6, D(d)=8, D(e)=9, D(f)=9, D(g)=8, D(h)=12, D(i)=9</li>
|
||||
<li>Folgende Kanten sind im <b>kleinsten aufspannenden Baum</b> enthalten: (a,b), (b,c), (c,d), (d,e), (d,i), (e,f), (e,h), (i,g) </li>
|
||||
<li><b>Ein Huffman-Code:</b> A = 00, B = 110, C = 0100, D = 0101, I = 101, L = 0110, M = 0111, R = 111, S = 100</li>
|
||||
<li><b>Verschiebefunktion:</b></li>
|
||||
</ol>
|
||||
<table>
|
||||
<tr>
|
||||
<td>
|
||||
Wort <br>
|
||||
Stelle <br>
|
||||
Verschiebefunktion f
|
||||
</td>
|
||||
<td>
|
||||
abacabb <br>
|
||||
1234567 <br>
|
||||
0112112
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>a</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>a</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>a</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>c</b></td>
|
||||
<td><b>a</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>a</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>c</b></td>
|
||||
<td><b>a</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>b</b></td>
|
||||
<td><b>c</b></td>
|
||||
<td><b>a</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>b<br>X</td>
|
||||
<td>a<br></td>
|
||||
<td>b<br></td>
|
||||
<td>c<br></td>
|
||||
<td>a<br></td>
|
||||
<td>b<br></td>
|
||||
<td>b</td>
|
||||
<td></td><td></td><td></td><td></td><td></td><td></td>
|
||||
<td></td><td></td><td></td><td></td><td></td><td></td>
|
||||
<td><br>f(1) = 0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>b<br>-</td>
|
||||
<td>a<br>X</td>
|
||||
<td>b<br></td>
|
||||
<td>c<br></td>
|
||||
<td>a<br></td>
|
||||
<td>b<br></td>
|
||||
<td>b</td>
|
||||
<td></td><td></td><td></td><td></td><td></td><td></td>
|
||||
<td></td><td></td><td></td><td></td><td></td>
|
||||
<td><br>f(2) = 1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td></td>
|
||||
<td>b<br>-</td>
|
||||
<td>a<br>-</td>
|
||||
<td>b<br>-</td>
|
||||
<td>c<br>X</td>
|
||||
<td>a<br></td>
|
||||
<td>b<br></td>
|
||||
<td>b</td>
|
||||
<td></td><td></td><td></td><td></td><td></td>
|
||||
<td></td><td></td><td></td><td></td><td></td>
|
||||
<td><br>f(4) = 2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td><td></td>
|
||||
<td></td><td></td>
|
||||
<td><i>b</i></td>
|
||||
<td>a<br>-</td>
|
||||
<td>b<br>-</td>
|
||||
<td>c<br>-</td>
|
||||
<td>a<br>-</td>
|
||||
<td>b<br>-</td>
|
||||
<td>b<br>X</td>
|
||||
<td></td><td></td><td></td><td></td>
|
||||
<td></td><td></td><td></td><td></td>
|
||||
<td><br>f(7) = 2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td><td></td><td></td><td></td><td></td>
|
||||
<td></td><td></td><td></td><td></td>
|
||||
<td><i>b</i></td>
|
||||
<td>a<br>-</td>
|
||||
<td>b<br>-</td>
|
||||
<td>c<br>-</td>
|
||||
<td>a<br>-</td>
|
||||
<td>b<br>-</td>
|
||||
<td>b<br>-</td>
|
||||
<td></td><td></td><td></td>
|
||||
<td><br>Wort gefunden</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2>Graphen und Bäume</h2>
|
||||
<ol>
|
||||
<li><b>AVL-Baum</b><br>
|
||||
<img src="avlbaumloesung.gif"><br>
|
||||
<img src="avlbaumloesung1.gif">
|
||||
<img src="avlbaumloesung2.gif">
|
||||
<img src="avlbaumloesung3.gif">
|
||||
</li>
|
||||
<li><b>B-Baum</b><br>
|
||||
<img src="bbaumloesung.gif">
|
||||
</li>
|
||||
<li><b>Rot-Schwarz-Baum</b> in eine (2,4)-Baum umgewandelt:<br>
|
||||
<img src="2-4baum.gif">
|
||||
</li>
|
||||
<li><b>Suffixbaum</b> von ananas$<br>
|
||||
<img src="ananas.gif">
|
||||
</li>
|
||||
<li><b>Adjazenzliste</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>u</b></td>
|
||||
<td>→</td>
|
||||
<td>v → x</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>v</b></td>
|
||||
<td>→</td>
|
||||
<td>y</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>w</b></td>
|
||||
<td>→</td>
|
||||
<td>y → z</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>x</b></td>
|
||||
<td>→</td>
|
||||
<td>v</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>y</b></td>
|
||||
<td>→</td>
|
||||
<td>x</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>z</b></td>
|
||||
<td>→</td>
|
||||
<td>z</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<b>Adjazenzmatrix</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>nach</td>
|
||||
<td></td>
|
||||
<td><b>u</b></td>
|
||||
<td><b>v</b></td>
|
||||
<td><b>w</b></td>
|
||||
<td><b>x</b></td>
|
||||
<td><b>y</b></td>
|
||||
<td><b>z</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>u</b></td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>v</b></td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
<td>0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>von</td>
|
||||
<td><b>w</b></td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
<td>1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>x</b></td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>y</b></td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td><b>z</b></td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
<td>1</td>
|
||||
</tr>
|
||||
</table>
|
||||
Eine Adjazenzliste ist hier sinnvoller, da bei der Adjazenzmatrix sehr viel Speicherplatz unnötig besetzt ist.
|
||||
</li>
|
||||
<li><b>Konvexe Hülle</b><br> besteht aus den Punkten A, D, G und H.</li>
|
||||
<li><b>Pre- und Postorder</b><br>
|
||||
(a)<br><img src="prepost1.gif"><br>
|
||||
Preorder : - + 2 * 3 6 / 4 1<br>
|
||||
Postorder: 2 3 6 * + 4 1 / -<br>
|
||||
(b)<br><img src="prepost2.gif"><br>
|
||||
Preorder : + - * 5 + 6 2 / 7 4 * 2 5<br>
|
||||
Postorder: 5 6 2 + * 7 4 / - 2 5 * +<br>
|
||||
(c)<br>
|
||||
Preorder : * 2 + 7 / 5 5<br>
|
||||
Inorder : 2 * (7 + 5 / 5)<br>
|
||||
Postorder: 2 7 5 5 / + *
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
Binary file not shown.
|
After Width: | Height: | Size: 4.2 KiB |
@@ -0,0 +1,197 @@
|
||||
1b. mod. Menge (Haskell Listen)
|
||||
2b. mod. Queue (Haskell Listen)
|
||||
3b. mod. Stack (Haskell Listen)
|
||||
4b. mod. Baum (Haskell Listen) // erstmal weggelassen
|
||||
|
||||
1c. mod. Menge (Folgen)
|
||||
2c. mod. Queue (Folgen)
|
||||
3c. mod. Stack (Folgen)
|
||||
4c. mod. Baum (Folgen)
|
||||
|
||||
|
||||
1b. Modellierende Spezifikation einer Menge (Model,Spezifikation,Invariante)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
Model : Haskell Listen
|
||||
|
||||
Invariante : In einer Menge dürfen keine Duplikate vorkommen
|
||||
|
||||
Spezifikation: createM :: [a]
|
||||
create = []
|
||||
|
||||
isEmpty :: [a] -> Bool
|
||||
isEmpty [] = True
|
||||
isEmpty (x:xs) = False
|
||||
|
||||
insert :: a -> [a] -> [a]
|
||||
insert x [] = [x]
|
||||
insert y (x:xs)
|
||||
| y == x = (x:xs)
|
||||
| otherwise = x:(insert y xs)
|
||||
|
||||
delete :: a -> [a] -> [a]
|
||||
delete x [] = []
|
||||
delete y (x:xs)
|
||||
| y == x = xs
|
||||
| otherwise = x:(delete y xs)
|
||||
|
||||
isIn :: a -> [a] -> Bool
|
||||
isIn x [] = False
|
||||
isIn y (x:xs)
|
||||
| y == x = True
|
||||
| otherwise = x:(isIn y xs)
|
||||
|
||||
|
||||
|
||||
2b. Modellierende Spezifikation einer Schlange (Model,Spezifikation,Invariante)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
Modell: Liste in Haskell [t]
|
||||
|
||||
Invariante : length [t] <= MAX
|
||||
|
||||
Spezifikation: createQ :: [t]
|
||||
createQ = []
|
||||
|
||||
enqueue :: t -> [t] -> [t]
|
||||
enqueue x [] = [x]
|
||||
enqueue y (x:xs) = (x:xs) ++ [y]
|
||||
|
||||
dequeue :: [t] -> [t]
|
||||
dequeue [] = error "Queue leer, Du OpfA"
|
||||
dequeue (x:xs) = xs
|
||||
|
||||
first :: [t] -> t
|
||||
first [] = error "Queue leer, Du OpfA"
|
||||
first (x:xs) = x
|
||||
|
||||
|
||||
3b. Modellierende Spezifikation eines Stacks (Model,Spezifikation,Invariante)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
Modell: Liste in Haskell [t]
|
||||
|
||||
Invariante : length [t] <= MAX
|
||||
|
||||
Spezifikation: createS :: Stack s
|
||||
createS = []
|
||||
|
||||
isEmpty :: Stack s -> Bool
|
||||
isEmpty [] = True
|
||||
isEmpty xs = False
|
||||
|
||||
push :: e -> Stack s -> Stack s
|
||||
push x [] = [x]
|
||||
push y (x:xs) = y : (x:xs)
|
||||
|
||||
pop :: Stack s -> Stack s
|
||||
pop [] = error "Stack ist leer"
|
||||
pop (x:xs) = xs
|
||||
|
||||
top :: Stack s -> e
|
||||
top [] = error "Stack ist leer"
|
||||
top (x:xs) = x
|
||||
|
||||
size :: Stack s -> int
|
||||
size [] = 0
|
||||
size (x:xs) = 1 + size (xs)
|
||||
|
||||
|
||||
|
||||
4b. Algebraische Spezifikation eines Baumes (Model,Spezifikation,Invariante)
|
||||
--------------------------------------------------------------------------------------------------
|
||||
|
||||
folgt
|
||||
|
||||
|
||||
|
||||
1c. Modellierende Spezifikation einer Menge (Model,Spezifikation,Invariante)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
Model : Menge = e | (xi)i=1..n , type xi = T , n <- N
|
||||
|
||||
Invariante : n < N && Alle (xi)i=1..n Exisitiert kein (xj)j=1..n mit xj = xi
|
||||
|
||||
Spezifikation : createM = e
|
||||
//post return e
|
||||
|
||||
isEmpty Menge
|
||||
//post if Menge == e return True else return False
|
||||
|
||||
//pre createM && isIn T Menge = False (s. Invariante) && k < N
|
||||
insert T Menge
|
||||
//post insert T (xi)i=1..k => (xi)i=1..k+1 && xk+1 = T
|
||||
|
||||
//pre createM
|
||||
delete T (xi)i=1..k
|
||||
//post (xi)i=1..k-1 && isIn T Menge = False
|
||||
|
||||
//pre createM
|
||||
isIn T Menge
|
||||
//post return ( Existiert ein (xi)i=1..k | xi == T )
|
||||
|
||||
|
||||
|
||||
|
||||
2c. Modellierende Spezifikation einer Schlange (Model,Spezifikation,Invariante)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
Model : Queue = e | (xi)i=1..n , type xi = T , n <- N
|
||||
|
||||
Invariante : n < N
|
||||
|
||||
Spezifikation : createQ = e
|
||||
//post returns e
|
||||
|
||||
isEmpty (xi)i=1..k
|
||||
//post if Queue == e return True else return False
|
||||
|
||||
//pre createQ && k < N
|
||||
enqueue T Queue
|
||||
//post enqueue T (xi)i=1..k => (xi)i=1..k+1 && xk+1 = T
|
||||
|
||||
//pre !isEmpty
|
||||
dequeue Queue
|
||||
//post dequeue (xi)i=1..k => (xi)i=2..k (size = size-1)
|
||||
|
||||
//pre !isEmpty
|
||||
first Queue
|
||||
//post first (xi)i=1..k => return x1
|
||||
|
||||
|
||||
|
||||
|
||||
3c. Modellierende Spezifikation eines Stacks (Model,Spezifikation,Invariante)
|
||||
---------------------------------------------------------------------------------------------------
|
||||
|
||||
Model : Stack = e | (xi)i=1..n , type xi = T , n <- N
|
||||
|
||||
Invariante : n < N
|
||||
|
||||
Spezifikation : createS = e
|
||||
|
||||
//pre createS
|
||||
isEmpty Stack
|
||||
//post Stack == e True else return False
|
||||
|
||||
//pre createS && k < N
|
||||
push T (xi)i=1..k-1
|
||||
//post push T (xi)i=1..k-1 =>(xi)i=1..k && xk = T
|
||||
|
||||
//pre !isEmpty
|
||||
pop (xi)i=1..n
|
||||
//pre (xi)i=1..n-1
|
||||
|
||||
//pre !isEmpty
|
||||
top (xi)i=1..n
|
||||
//post returns xn
|
||||
|
||||
//pre createS
|
||||
size (xi)i=1..n-1
|
||||
//post returns n-1
|
||||
|
||||
|
||||
4c. Algebraische Spezifikation eines Baumes (Model,Spezifikation,Invariante)
|
||||
--------------------------------------------------------------------------------------------------
|
||||
|
||||
folgt
|
||||
@@ -0,0 +1,17 @@
|
||||
<!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>Neue Seite</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<span id="menu"><a href="index.php">zurück zur Liste</a></span>
|
||||
|
||||
<p>
|
||||
Das ALP-Vordiplom-Projekt wurde erfolgreich abgeschlossen, die Seiten können nicht mehr verändert werden.
|
||||
</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.4 KiB |
@@ -0,0 +1,160 @@
|
||||
<!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>Laufzeit und O-Notation</title>
|
||||
</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>O-Notation, Laufzeiten</h1>
|
||||
|
||||
<h3>Laufzeit</h3>
|
||||
Man kann den Zeitaufwand von Algorithmen nicht eindeutig bestimmen. Viel zu viele Faktoren (Hardware, parallel laufende Programme, Eingabereihenfolge, ...) spielen eine Rolle, so dass man mit normalen Mitteln niemals eine genaue und allgemeine Aussgae über die benötigte Zeit machen kann.<br>
|
||||
Es werden nun nicht mehr die benötigten Zeiten, sondern die benötigten "greifbaren" Schritte bei einer bestimmten Eingabelänge n beschrieben.<br>
|
||||
Somit können Programme in Klassen (konstant, logarithmisch, lineas, polynomial, exponentiell, u.a.) eingeteilt werden.<br><br>
|
||||
|
||||
<h3>O-Notation</h3>
|
||||
Möchten wir nun wissen, ob eine Laufzeit in eine Klasse gehört, so müssen wir ihr asymptotisches Wachstum beobachten.<br>
|
||||
Es gibt ein n<sub>0</sub> ≠ ∞, ab dem das Wachstumsverhalten vergleichbar ist mit der repräsentierenden Funktion der Klasse.<br><br>
|
||||
Wir können nun die Laufzeit folgendermaßen einteilen:
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Worst Case</b></td>
|
||||
<td>
|
||||
<b>f(n) = Ο(g(n))</b><br>
|
||||
∃n<sub>0</sub> ∈ N ∧ c > 0, ∀n ≥ n<sub>0</sub>: |f(n)| ≤ c * g(n)
|
||||
</td>
|
||||
<td><b>lim<sub>n→∞</sub> f(n)/g(n) = 0 oder c</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>Best Case</b></td>
|
||||
<td>
|
||||
<b>f(n) = Ω(g(n))</b> <i>Omega</i><br>
|
||||
∃n<sub>0</sub> ∈ N ∧ c > 0, ∀n ≥ n<sub>0</sub>: |f(n)| ≥ c * g(n)
|
||||
</td>
|
||||
<td><b>lim<sub>n→∞</sub> f(n)/g(n) → ∞ oder c</b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>Best Case und Worst Case</b></td>
|
||||
<td>
|
||||
<b>f(n) = Θ(g(n))</b> <i>Theta</i><br>
|
||||
∃n<sub>0</sub> ∈ N ∧ c > 0, ∀n ≥ n<sub>0</sub>: f(n) = O(g(n)) ∧ f(n) = Ω(g(n))
|
||||
</td>
|
||||
<td><b>lim<sub>n→∞</sub> f(n)/g(n) = c</b></td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
|
||||
Die O-Notation ist eine Abschätzung der Laufzeit bei unendlich großen Eingaben. Da jedoch keine Eingabe unendlich ist, sollte man bei der Wahl von Algorithmen, die realistische Eingabelänge einbeziehen.<br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>Beispiel: </td>
|
||||
<td>f(n) = 10<sup>20</sup>n</td>
|
||||
<td>= O(n)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>g(n) = 10<sup>-20</sup>n<sup>2</sup></td>
|
||||
<td>= O(n<sup>2</sup>)</td>
|
||||
</tr>
|
||||
</table>
|
||||
Obwohl O(n) < O(n<sup>2</sup>), ist f(n) > g(n) bei kleinen n.<br><br>
|
||||
|
||||
<h3>Anwendung</h3>
|
||||
Es gibt folgenden Regeln zur Bestimmung der Klasse:
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Addition</b></td>
|
||||
<td>f(n) = n + 3</td>
|
||||
<td>⇒ f(n) = Θ(n)</td>
|
||||
<td>Konstante Summanden werden vernachlässigt</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>f(n) = n<sup>2</sup> + 3n</td>
|
||||
<td>⇒ f(n) = Θ(n<sup>2</sup>)</td>
|
||||
<td>Es zählt der Summand mit dem stärkeren Wachstum</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>Multipikation</b></td>
|
||||
<td>f(n) = 3n</td>
|
||||
<td>⇒ f(n) = Θ(n)</td>
|
||||
<td>Konstante Faktoren werden vernachlässigt</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td></td>
|
||||
<td>f(n) = n<sup>2</sup> * 3n</td>
|
||||
<td>⇒ f(n) = Θ(n<sup>3</sup>)</td>
|
||||
<td>Es zählt die Summe der Exponenten</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
|
||||
<b>Wachstum im Vergleich:</b> 1 < log n < √n < n < n(log n)<sup>2</sup> < n<sup>2</sup> < n<sup>a</sup> < a<sup>n</sup>
|
||||
<br><br>
|
||||
|
||||
<b>Umformen der Basen von Logerithmen:</b> log<sub>c</sub>b = log<sub>a</sub>b / log<sub>a</sub>c
|
||||
|
||||
<br><br>
|
||||
<hr>
|
||||
<i><font size="+1">O - Notation</i></font><br><br>
|
||||
|
||||
<b>Definition</b>: f(n) und g(n) seien Funktionen von den natürlichen zu den reellen Zahlen.<br>
|
||||
<font face="Times New Roman">
|
||||
f(n) = Ο(g(n)) ⇔ ∃n<sub>0</sub> ∈ N ∧ c > 0, ∀n ≥ n<sub>0</sub>: |f(n)| ≤ c * g(n)<br>
|
||||
f(n) = Ω(g(n)) ⇔ ∃n<sub>0</sub> ∈ N ∧ c > 0, ∀n ≥ n<sub>0</sub>: |f(n)| ≥ c * g(n)<br>
|
||||
f(n) = Θ(g(n)) ⇔ ∃n<sub>0</sub> ∈ N ∧ c > 0, ∀n ≥ n<sub>0</sub>: f(n) = O(g(n)) ∧ f(n) = Ω(f(n))
|
||||
</font>
|
||||
<br>
|
||||
<br>
|
||||
|
||||
<i><font size="+1">Wichtige Laufzeiten</i></font><br>
|
||||
<ul>
|
||||
<ol>Tiefensuche O(V+E)</ol>
|
||||
<ol>Breitensuche O(V+E)</ol>
|
||||
<ol>Dijktra O(V+E)</ol>
|
||||
</ul>
|
||||
|
||||
<table border=0 width="50%">
|
||||
<tr align="center">
|
||||
<td></td> <td><b>best case</b></td> <td><b>middle case</b></td> <td><b>worst case</b></td>
|
||||
</tr>
|
||||
|
||||
<tr align="center">
|
||||
<td><b>Prim</b></td> <td>O(E)</td> <td>- - -</td> <td>O(V<sup>2</sup>)</td>
|
||||
</tr>
|
||||
|
||||
<tr align="center">
|
||||
<td><b>Quicksort</b></td> <td>O(n logn)</td> <td>O(n logn)</td> <td>O(n<sup>2</sup>)</td>
|
||||
</tr>
|
||||
|
||||
<tr align="center">
|
||||
<td><b>Bubblesort, Insertsort</b></td> <td>O(n<sup>2</sup>)</td> <td>O(n<sup>2</sup>)</td> <td>O(n<sup>2</sup>)</td>
|
||||
</tr>
|
||||
|
||||
<tr align="center">
|
||||
<td><b>Mergesort</b></td> <td>O(n logn)</td> <td>O(n logn)</td> <td>O(n logn)</td>
|
||||
</tr>
|
||||
|
||||
</table>
|
||||
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.vameo.de/uni/tutorium/o-notation01.pdf">Merkblatt der O-Notation von Augustin</a><br>
|
||||
<a href="http://www.sortieralgorithmen.de/mathematics.htm">O-Notation: Definition auf der Sortieralgorithmen-Seite</a><br>
|
||||
<a href"=http://www.chemieonline.de/forum/showthread.php?p=196069#post196069">Laufzeit Fibonacci</a><br>
|
||||
<a href="http://www.fh-wedel.de/~si/seminare/ws03/Ausarbeitung/7.effizienz/effizienz03.html#u3">Laufzeit reverse</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 6.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.8 KiB |
@@ -0,0 +1,89 @@
|
||||
<!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>Primitiv-rekursive Funktionen</title>
|
||||
</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>Primitv rekursive Funktion</h1>
|
||||
|
||||
Jede berechenbare Funktion kann durch eine primitiv rekursive Funtkion mit Hilfe von einfachen Grundfunktionen dargestellt werden. <br><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td><b>Basisfunktionen</b></td>
|
||||
<td>
|
||||
clr () = 0<br>
|
||||
suc (n) = n+1<br>
|
||||
p (1, x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>) = x<sub>1</sub><br>
|
||||
p (i, x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>) = p (i-1, x<sub>2</sub>, x<sub>3</sub>, ... , x<sub>n</sub>)
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<br>
|
||||
Zu einer k-stelligen Funktion <b>ψ</b> und einer (k+2)-stelligen Funktion <b>χ</b> ist eine (k+1)-stellige Funktion <b>φ</b> definiert.<br>
|
||||
<b>φ</b> phi, <b>ψ</b> psi, <b>χ</b> chi ∈ PRF<br><br>
|
||||
|
||||
<b>φ</b> (0, x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>) = <b>ψ</b> (x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>)<br>
|
||||
<b>φ</b> (y+1, x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>) = <b>χ</b> (φ (y, x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>), y, x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>)
|
||||
|
||||
<br><br>
|
||||
|
||||
<b>Verdeutlichung am Beispiel: Addieren und multiplizieren von zwei Zahlen</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>
|
||||
Aufstellen der Gleichungen →
|
||||
</td>
|
||||
<td>
|
||||
Einfache Lösungen →
|
||||
</td>
|
||||
<td>
|
||||
Gleichungen mit <b>ψ</b> und <b>χ</b>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>add</b> (0, m)<br>
|
||||
<b>add</b> (n+1, m)
|
||||
</td>
|
||||
<td>
|
||||
= m<br>
|
||||
= suc (add (n, m))
|
||||
</td>
|
||||
<td>
|
||||
= <b>p1</b> (m)<br>
|
||||
= <b>suc (p1)</b> (add (n, m), n, m))
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
<b>mul</b> (0, m)<br>
|
||||
<b>mul</b> (n+1, m)
|
||||
</td>
|
||||
<td>
|
||||
= 0<br>
|
||||
= m + mul (n, m)
|
||||
</td>
|
||||
<td>
|
||||
= <b>clr</b> (m)<br>
|
||||
= <b>add (p1, p3)</b> (mult (n, m), n, m)
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,85 @@
|
||||
<!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>Rekursion</title>
|
||||
</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>Rekursion</h1>
|
||||
<p>
|
||||
(Unter-)Programme sind <b>rekursiv</b>, wenn sie sich selbst direkt oder indirekt aufrufen. Eine Rekursion läuft, bis sie durch einen <b>Rekursionsanker</b>, eine Abbruchbedingung für eine Rekursion endet. Man unterscheidet zwischen <b>linearen</b> und <b>nicht linearen</b> Rekursionen.
|
||||
</p>
|
||||
|
||||
<h2>Lineare Rekursion</h2>
|
||||
<p>
|
||||
Eine Funktion ist linear rekursiv, wenn nur ein rekursiver Aufruf erfolgt. Für die Fakultätsfunktion könnte das so aussehen:<br>
|
||||
<pre>
|
||||
fakul 0 = 1
|
||||
fakul n = n(fakul n-1)
|
||||
</pre>
|
||||
Der Computer würde bei Aufruf <span id="syntax">fakul 3</span> im ersten Schritt alle Aufrufe auf den Stack legen:
|
||||
<pre>
|
||||
1. fakul 3 = 3 *
|
||||
2. ( 2 *
|
||||
4. ( 1 *
|
||||
5. ( 1 ) ) )
|
||||
</pre>
|
||||
und nach erreichen des Rekursionsankers <span id="syntax">fakul 0 = 1</span> alle auf dem Stack abgelegten Zahlen aufmultiplizieren:
|
||||
<pre>
|
||||
5. ( 1 ) ) )
|
||||
6. ( 1 *
|
||||
7. ( 2 *
|
||||
8. 3 *
|
||||
9. 6 =
|
||||
</pre>
|
||||
Die Rekursion wird also einmal hin und zurück durchlaufen.<br>
|
||||
<br>
|
||||
Lineare Rekursionen, die nicht noch einmal "zurücklaufen", nennt man <b>endrekursiv</b> (tail recursion). Man unterscheidet also zwischen endrekursiven und nicht-endrekursiven linearen Rekursionen. Die Fakultätsfunktion lässt sich auch endrekursiv implementieren:
|
||||
<pre>
|
||||
fakul 0 a = a
|
||||
fakul n a = fakul (n-1) (a*n)
|
||||
</pre>
|
||||
Die Variable <span id="syntax">a</span> läuft bei der Rekursion mit und summiert das Endergebnis auf, so dass beim erreichen des Rekursionsankers das Endergebnis bereits feststeht (<b>Akkumulatortechnik</b>). Diese Variante braucht kaum Speicher, das der Stack nicht mit den rekursiven Aufrufen gefüllt wird.
|
||||
</p>
|
||||
|
||||
<h2>Nicht-lineare Rekursion</h2>
|
||||
<p>
|
||||
Eine rekursive Funktion ist nicht-linear rekursiv, wenn die Ausführung zu mehr als einem rekursiven Aufruf führt.
|
||||
|
||||
<p>
|
||||
Ein Beispiel für eine nicht-lineare Rekursion ist die Fibonaccifunktion in dieser Form:
|
||||
<pre>
|
||||
fibo 0 = 0
|
||||
fibo 1 = 1
|
||||
fibo n = fibo (n-1) + fibo (n-2)
|
||||
</pre>
|
||||
Bei der Ausführung spaltet sich die Auswertung der rekursiven Aufrufe logisch in einen Baum:
|
||||
<p>
|
||||
<img src="fibo5.gif">
|
||||
</p>
|
||||
</p>
|
||||
</p>
|
||||
|
||||
<h2>Entrekursivierung</h2>
|
||||
<p>
|
||||
Endrekursive Algorithmen können entrekursiviert werden. Dazu überführt man den Algorithmus in eine Schleife.<br>
|
||||
Lineare Algorithmen müssen erst mittels Akkumulatortechnik in eine endrekursive Form überführt werden, um sie entrekursivieren zu können. Nicht-lineare Rekursionen können nicht einfach durch Anwendung eines Schemas entrekursivieren.
|
||||
</p>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://www.vameo.de/uni/tutorium/rekursionen.pdf">Merkblatt zu Rekursion von Augustin</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.5 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 6.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.5 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.2 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.6 KiB |
@@ -0,0 +1,17 @@
|
||||
<?php
|
||||
$fp = fopen(stripslashes($_POST["filename"]),"w+"); // Datei öffnen
|
||||
fputs($fp,stripslashes($_POST["eingabe"])); # daten in datei speichern
|
||||
fclose($fp);
|
||||
echo '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">';
|
||||
echo "<html>";
|
||||
echo "<head>";
|
||||
echo '<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">';
|
||||
echo '<link rel="stylesheet" type="text/css" media="all" href="stylesheet.css">';
|
||||
echo '<title>Datei speichern</title>';
|
||||
echo "</head>";
|
||||
echo "<body>";
|
||||
echo '<span id="menu"><a href="index.php">zurück zur Liste</a></span>';
|
||||
echo "<p>Datei gespeichert.</p>";
|
||||
echo "</body>";
|
||||
echo "</html>";
|
||||
?>
|
||||
@@ -0,0 +1,438 @@
|
||||
<!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>
|
||||
| v == i = N l v r<br>
|
||||
| v < i = N l v (insertVal r i)<br>
|
||||
| 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>
|
||||
| v < i = N l v (delete r i)<br>
|
||||
| v > i = N (delete l i) v r<br>
|
||||
| l == E = r<br>
|
||||
| r == E = l<br>
|
||||
| otherwise = N (delete l (greatestElement l)) (greatestElement l) r<br>
|
||||
where greatestElement :: BinTree -> Int<br>
|
||||
greatestElement (N l v r)<br>
|
||||
| r == E = v<br>
|
||||
| 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>
|
||||
| v == i = insertLeftTree r l<br>
|
||||
| v < i = N l v (delete r i)<br>
|
||||
| otherwise = N (delete l i) v r<br>
|
||||
where insertLeftTree :: BinTree -> BinTree -> BinTree<br>
|
||||
insertLeftTree E t = t<br>
|
||||
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>
|
||||
| v == i = True<br>
|
||||
| v < i = contains r i<br>
|
||||
| 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? → 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>
|
||||
protected Comparable value;<br>
|
||||
protected Node left;<br>
|
||||
protected Node right;<br>
|
||||
<br>
|
||||
public Node(Comparable value, Node left, Node right) {<br>
|
||||
this.value = value;<br>
|
||||
this.left = left;<br>
|
||||
this.right = right;<br>
|
||||
}<br>
|
||||
}<br>
|
||||
<br>
|
||||
public class BinTree implements BinaryTree {<br>
|
||||
<br>
|
||||
private Node root;<br>
|
||||
<br>
|
||||
public BinTree(Node root) {<br>
|
||||
this.root = root;<br>
|
||||
}<br>
|
||||
<br>
|
||||
public void insert(Comparable value) {<br>
|
||||
<br>
|
||||
Node temp = root;<br>
|
||||
Node parent = null;<br>
|
||||
<br>
|
||||
while (temp != null) {<br>
|
||||
parent = temp;<br>
|
||||
if (value.compareTo(temp.value) < 0) {<br>
|
||||
temp = temp.left;<br>
|
||||
}<br>
|
||||
else {<br>
|
||||
temp = temp.right;<br>
|
||||
}<br>
|
||||
}<br>
|
||||
<br>
|
||||
if (parent != null) {<br>
|
||||
if (value.compareTo(parent.value) > 0) {<br>
|
||||
parent.right = new Node(value, null, null);<br>
|
||||
}<br>
|
||||
else {<br>
|
||||
parent.left = new Node(value, null, null);<br>
|
||||
}<br>
|
||||
}<br>
|
||||
}<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 → 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 & 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 (→ gleiche Funktionsnamen mit verschiedenen formalen Parametern).
|
||||
</p>
|
||||
</li>
|
||||
<li>
|
||||
<h3>Stellen Klassen in Java ADTs dar?</h3>
|
||||
<p>
|
||||
Können, müssen aber nicht. (→ 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">→ s. gprot40</span>
|
||||
</p>
|
||||
</li>
|
||||
<li>
|
||||
<h3>Was ist <i>late binding</i>?</h3>
|
||||
<p>
|
||||
Dynamische Typzuordnung zur Laufzeit (→ 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? (→ Endrekursion)</h3>
|
||||
<p>
|
||||
<div id="syntax">
|
||||
fak2 x = faka x 1<br>
|
||||
where faka 0 a = a<br>
|
||||
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>
|
||||
int akk = 1;<br>
|
||||
while (x > 1) {<br>
|
||||
akk = akk * x;<br>
|
||||
x--;<br>
|
||||
}<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 & 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 → Vorbedingung {P} wird in Nachbedingung {Q} überführt.<br>
|
||||
{P} S {Q} mit Zuweisungsaxiom {P}x = e{P[e/x]} → 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>
|
||||
@@ -0,0 +1,436 @@
|
||||
<!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>
|
||||
| v == i = N l v r<br>
|
||||
| v < i = N l v (insertVal r i)<br>
|
||||
| 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>
|
||||
| v < i = N l v (delete r i)<br>
|
||||
| v > i = N (delete l i) v r<br>
|
||||
| l == E = r<br>
|
||||
| r == E = l<br>
|
||||
| otherwise = N (delete l (greatestElement l)) (greatestElement l) r<br>
|
||||
where greatestElement :: BinTree -> Int<br>
|
||||
greatestElement (N l v r)<br>
|
||||
| r == E = v<br>
|
||||
| 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>
|
||||
| v == i = insertLeftTree r l<br>
|
||||
| v < i = N l v (delete r i)<br>
|
||||
| otherwise = N (delete l i) v r<br>
|
||||
where insertLeftTree :: BinTree -> BinTree -> BinTree<br>
|
||||
insertLeftTree E t = t<br>
|
||||
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>
|
||||
| v == i = True<br>
|
||||
| v < i = contains r i<br>
|
||||
| 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? → s. gprot18</span>
|
||||
</p>
|
||||
</li>
|
||||
<li>
|
||||
<h3>Implementieren Sie einen Binärbaum in Java (ADT)</h3>
|
||||
<p>
|
||||
<div id="syntax">
|
||||
class Node {<br>
|
||||
<br>
|
||||
protected Comparable value;<br>
|
||||
protected Node left;<br>
|
||||
protected Node right;<br>
|
||||
<br>
|
||||
public Node(Comparable value, Node left, Node right) {<br>
|
||||
this.value = value;<br>
|
||||
this.left = left;<br>
|
||||
this.right = right;<br>
|
||||
}<br>
|
||||
}<br>
|
||||
<br>
|
||||
public class BinTree implements BinaryTree {<br>
|
||||
<br>
|
||||
private Node root;<br>
|
||||
<br>
|
||||
public BinTree(Node root) {<br>
|
||||
this.root = root;<br>
|
||||
}<br>
|
||||
<br>
|
||||
public void insert(Comparable value) {<br>
|
||||
<br>
|
||||
Node temp = root;<br>
|
||||
Node parent = null;<br>
|
||||
<br>
|
||||
while (temp != null) {<br>
|
||||
parent = temp;<br>
|
||||
if (value.compareTo(temp.value) < 0) {<br>
|
||||
temp = temp.left;<br>
|
||||
}<br>
|
||||
else {<br>
|
||||
temp = temp.right;<br>
|
||||
}<br>
|
||||
}<br>
|
||||
<br>
|
||||
if (parent != null) {<br>
|
||||
if (value.compareTo(parent.value) > 0) {<br>
|
||||
parent.right = new Node(value, null, null);<br>
|
||||
}<br>
|
||||
else {<br>
|
||||
parent.left = new Node(value, null, null);<br>
|
||||
}<br>
|
||||
}<br>
|
||||
}<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 → 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 & 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 (→ gleiche Funktionsnamen mit verschiedenen formalen Parametern).
|
||||
</p>
|
||||
</li>
|
||||
<li>
|
||||
<h3>Stellen Klassen in Java ADTs dar?</h3>
|
||||
<p>
|
||||
Können, müssen aber nicht. (→ 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">→ s. gprot40</span>
|
||||
</p>
|
||||
</li>
|
||||
<li>
|
||||
<h3>Was ist <i>late binding</i>?</h3>
|
||||
<p>
|
||||
Dynamische Typzuordnung zur Laufzeit (→ 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? (→ Endrekursion)</h3>
|
||||
<p>
|
||||
<div id="syntax">
|
||||
fak2 x = faka x 1<br>
|
||||
where faka 0 a = a<br>
|
||||
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>
|
||||
int akk = 1;<br>
|
||||
while (x > 1) {<br>
|
||||
akk = akk * x;<br>
|
||||
x--;<br>
|
||||
}<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 & 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 → Vorbedingung {P} wird in Nachbedingung {Q} überführt.<br>
|
||||
{P} S {Q} mit Zuweisungsaxiom {P}x = e{P[e/x]} → 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>
|
||||
@@ -0,0 +1,49 @@
|
||||
<!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</title>
|
||||
</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's most wanted</h1>
|
||||
|
||||
Da wir alle beim selben Prüfer landen, ist es vielleicht nicht schlecht, wenn wir sein Prüfungsverhalten etwas profilieren.<br>Wem also was in den Prüfungsprotokollen auffällt - hier aufzeichnen!
|
||||
|
||||
<ul>
|
||||
<li>In allen (!) Protokollen die ich mir angesehen habe, hat Schweppe direkt oder indirekt nach der Definition von ADTs gefragt!</li>
|
||||
<li>O-Notation kommt auch superoft vor</li>
|
||||
<li>Rekursion</li>
|
||||
<li>Polymorphie</li>
|
||||
<li>"Warum ist Suchen (die Höhe) von Binärbäumen logarithmisch?"</li>
|
||||
<li>Binäre Suche</li>
|
||||
<li>delete für Binärbäume</li>
|
||||
</ul>
|
||||
|
||||
Anscheinend ist es in den Schweppe-Prüfungen so, dass er eine ganze Menge redet und man ihm dann ins Wort fällt, bzw. seine Sätze beendet, um sein Wissen zu zeigen.
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
<p>
|
||||
Schweppe scheint zu erwarten, dass zu einem Stichwort immer gleich ein ganzer Schwall an Information kommt. Ansonsten stellt er Massen von Zwischenfragen. (s. gprot50 - Mattias Hilliges)<br>
|
||||
Also lieber drauflosreden, aufhalten kann er einen immer noch. Schließlich soll man ja etwas "vortanzen"; außerdem kann man die Gesamtrichtung ein bißchen beeinflussen.
|
||||
</p>
|
||||
<p>
|
||||
Zitat T.: <i>Naja auf jeden Fall fand ich es hässlich, dass ich weder zu <b>SORTS</b> in Java gefragt wurde noch <b>binäre Suche</b> (macht er doch sonst so gern) oder <b>QUEUEs oder STACKS</b> implementieren durfte. Auch sein beliebtestes Thema (<b>Rekursion</b>) kam nicht dran ....</i>
|
||||
</p>
|
||||
<p>
|
||||
Zitat C.: <i>Manchmal hat er allerdings etwas unverständliche Nachfragen gestellt, bei denen als Antwort oft eine Wiederholung oder eine leichte Umformulierung ausreichend war.</i>
|
||||
</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 1.7 KiB |
@@ -0,0 +1,59 @@
|
||||
<!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>Sortieralgortihmen</title>
|
||||
</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>Sortieralgorithmen</h1>
|
||||
|
||||
<h3>Quicksort</h3>
|
||||
Der Quicksort-Algortithmus ist eines der schnellsten und zugleich einfachsten Sortierverfahren. Es arbeitet nach dem Divide-and-Conquer-Prinzip.<br>
|
||||
Es wird zunächst ein <b>Pivotelement</b> ausgewählt und die Liste in zwei geteilt. Die Elemente, die kleiner als das Pivotelement sind, kommen in die erste Liste und die anderen in die zweite. Mit den entstehenden Listen wird genauso fortgefahren, bis es nur noch Teillisten der Länge 1 gibt. Diese Listen werden nun der Reihe nach wieder zusammengefügt.<br><br>
|
||||
|
||||
<h3>Mergesort</h3>
|
||||
Ähnlich wie bei Quicksort beruht das Verfahren auf der Divide-and-Conquer-Strategie. Die zu sortierende Folge wird in zwei gleichgroße Hälften geteilt. Die entstehenden Listen werden weiter und weiter geteilt, bis es wieder nur noch Teillisten der Länge 1 gibt. Zusammengefügt wird, indem die ersten beiden Elemente zweier Teillisten verglichen werden, das kleinere gelöscht und in eine neue Liste eingetragen wird. Die neuen ersten beiden Elemente verglichen, das kleinere gelöscht und in die neue Liste eingetragen wird...<br><br>
|
||||
|
||||
<h3>Bubblesort</h3>
|
||||
Bubblesort ist einer der simpelsten Sortieralgorithmen.<br>
|
||||
Im ersten Durchlauf wird nach dem kleinsten Element gesucht, im zweiten Durchlauf nach dem zweitkleinsten usw.<br>
|
||||
Man geht den Array immer von hinten nach vorne durch. Zunächst vergleicht man das letzte mit dem vorletzten Element. Ist das hintere kleiner, werden die beiden Elemente vertauscht. Dann wird mit dem vorletzten und dem vorvorletzten weitergemacht. Dadurch bleiben die größeren liegen und die kleineren Elemente werden nach vorne durchgereicht.<br><br>
|
||||
|
||||
<h3>Insertionsort</h3>
|
||||
Man hat eine zu sortierende Folge a<sub>0</sub>, a<sub>1</sub>, ... , a<sub>n-1</sub>, wobei der erste Teil a<sub>0</sub>, a<sub>1</sub>, ... , a<sub>k-1</sub> bereits aufsteigend sortiert ist und der zweite Teil a<sub>k</sub>, a<sub>k+1</sub>, ... , a<sub>n-1</sub> noch unsortiert ist. Zu Anfang besteht der sortierte Teil nur aus a<sub>0</sub>, zum Schluss aus allen Elementen a<sub>0</sub>, a<sub>1</sub>, ... , a<sub>n-1</sub>.<br>
|
||||
Das Element a<sub>k</sub> wird als nächstes in die bereits sortierte Liste eingefügt, indem es der Reihe nach mit a<sub>k-1</sub>, a<sub>k-2</sub> usw. verglichen wird. Sobald ein Element a<sub>j</sub> mit a<sub>j</sub>≤a<sub>k</sub> gefunden wird, wird es hinter dieses eingefügt. Wird kein solches Element gefunden, wird a<sub>k</sub> an den Anfang der Folge gesetzt.<br>
|
||||
Damit ist der sortierte Teil um ein Element länger geworden. Im nächsten Schritt wird a<sub>k+1</sub> in den sortierten Teil eingefügt...
|
||||
<br><br>
|
||||
|
||||
<h2>Vergleich Mergesort und Quicksort</h2>
|
||||
von <a href="http://www.gm.fh-koeln.de/~ehses/ap/folien/folien9.pdf">http://www.gm.fh-koeln.de/~ehses/ap/folien/folien9.pdf</a>
|
||||
<ul>
|
||||
<li>Mergesort ist garantiert O(n log n), Quicksort im Mittel</li>
|
||||
<li>Die Anzahl der Vergleich und der Datenbewegungen ist bei Mergesort n log2(n)</li>
|
||||
<li>Quicksort hat im Mittel O(1.4 n log2 n) Vergleiche</li>
|
||||
<li>Quicksort hat im Mittel O(0.7 n log2 n) Datenbewegungen</li>
|
||||
<li>Quicksort ist schneller, wenn die Vergleiche schneller sind als die Datenbewegungen (einfache Datentypen)</li>
|
||||
<li>Mergesort ist schneller, wenn die Vergleiche die Zeit dominieren (Objekte)</li>
|
||||
<li>Es gibt Varianten von Mergesort für Felder und Listen (nicht rekursiv)</li>
|
||||
</ul>
|
||||
|
||||
<h2>Links</h2>
|
||||
zu Laufzeiten s.a.: <a href="o-notation.php">O-Notation</a><br>
|
||||
<a href="http://www.sortieralgorithmen.de/index.html">www.sortieralgorithmen.de - mit klasse Applet</a>
|
||||
<br>
|
||||
<a href="http://www.vameo.de/uni/tutorium/toposort.pdf">Merkblatt zu topologisches Sortieren von Augustin</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,31 @@
|
||||
@media screen
|
||||
{
|
||||
body { font-size: 10pt; font-family: "Trebuchet MS", Georgia, serif; background-color: #FFFFFF }
|
||||
h1 { font-size: 150%; text-align: center; color: #004080; }
|
||||
h2 { font-size: 125%; text-align: left; color: #004080; }
|
||||
h3 { font-size: 110%; text-align: left; color: #004080; }
|
||||
h4 { font-size: 100%; text-align: left; color: #004080; }
|
||||
td { font-size: 10pt; vertical-align: top; padding-right: 10px; }
|
||||
a { color: #FF8000; text-decoration:none; }
|
||||
a:hover { color: #C04040; text-decoration:none; font-weight: bold; }
|
||||
#updates { font-size: 80%; font-family: "Courier New", monospace; color: #C0C0C0; }
|
||||
#menu { font-size: 70%; }
|
||||
#buttons { position: absolute; right: 20px; top: 20px; text-align: right; }
|
||||
#syntax { font-family: monospace; }
|
||||
.quelle { font-size: 75%; color: #888888; font-style: italic; }
|
||||
}
|
||||
@media print
|
||||
{
|
||||
body { font-size: 10pt; font-family: "Trebuchet MS", Georgia, serif; background-color: #FFFFFF }
|
||||
h1 { font-size: 150%; text-align: center; color: #000000; }
|
||||
h2 { font-size: 125%; text-align: left; color: #000000; }
|
||||
h3 { font-size: 110%; text-align: left; color: #000000; }
|
||||
h4 { font-size: 100%; text-align: left; color: #000000; }
|
||||
td { font-size: 10pt; vertical-align: top; padding-right: 10px; }
|
||||
a { color: #000000; text-decoration: underline; }
|
||||
#menu { display: none; }
|
||||
#buttons { display: none; }
|
||||
#syntax { font-family: monospace; }
|
||||
.quelle { font-size: 75%; color: #888888; font-style: italic; }
|
||||
}
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
<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">
|
||||
</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>Titel</h1>
|
||||
|
||||
<h2>Fragen</h2>
|
||||
|
||||
<h2>Anmerkungen</h2>
|
||||
|
||||
<h2>Links</h2>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.8 KiB |
@@ -0,0 +1,35 @@
|
||||
<!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>Aufteilung der Themen</title>
|
||||
</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>Bearbeitung der Themen</h1>
|
||||
|
||||
<h2>Vera</h2>
|
||||
Haskell, Spezifikation, Abstrakte Datentypen
|
||||
|
||||
<h2>Bettina</h2>
|
||||
Primitiv-rekursive Funktionen, Algorithmen, Graphen & Bäume, Induktion, Laufzeitbestimmung, O-Notation
|
||||
|
||||
<h2>Tilman</h2>
|
||||
Java, UML, λ-Kalkül, Vergleich Programmiersprachen, Rekursion und Endrekursivierung, Perfect Shuffle
|
||||
|
||||
<h2>Es fehlen noch...</h2>
|
||||
Verifikation und Validation, Relationen
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,48 @@
|
||||
<!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>Tiefensuche und Breitensuche</title>
|
||||
</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>Tiefen- und Breitensuche</h1>
|
||||
|
||||
Tiefen- und Breitensuche sind Verfahren zum Traversieren von Graphen. Als Ergebnis eines zusammenhängenden Graphen erhält man einen aufspannenden Baum.<br><br>
|
||||
|
||||
<h3>Breitensuche</h3>
|
||||
Die <b>Breitensuche (BFS - breadth-first-search)</b> ist ein Algorithmenmuster, das die Knoten eines Graphen nach der Entfernung von einem Startknoten geordnet durchläuft.<br>
|
||||
Zuerst werden alle von diesem Startknoten direkt durch eine Kante erreichbaren Knoten bearbeitet, danach die mit zwei Kanten Entfernung, dann die mit drei usw.<br><br>
|
||||
|
||||
<h3>Tiefensuche</h3>
|
||||
Mit der <b>Tiefensuche (DFS - depth-first-search)</b> geht man so weit wie möglich einen gewählten Pfad entlang. Wenn man am Ende eines Zweiges angekommen ist, geht man schrittweise zurück, bis man in einen bislang unbesuchten Teilbaum absteigen kann. Ist man wieder am Startknoten angelangt und es gibt keine unbesuchten Knoten, die mit dem Startknoten durch eine Kante verbunden sind, dann ist man fertig.<br>
|
||||
Dieseas Verfahren nennt man <b>Backtracking</b>: Man geht solange man kann, wenn man nicht mehr weiter kommt, geht man zurück bis man einen anderen Weg findet.<br><br><br>
|
||||
|
||||
|
||||
<b>Beispiel:</b><br>
|
||||
<table>
|
||||
<tr>
|
||||
<td>Beispielgraph</td>
|
||||
<td>Breitensuche</td>
|
||||
<td>Tiefensuche</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><img src="tubsuche.gif"></td>
|
||||
<td><img src="breitensuche.gif"></td>
|
||||
<td><img src="tiefensuche.gif"></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.5 KiB |
@@ -0,0 +1,40 @@
|
||||
<!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>UML</title>
|
||||
</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>UML - Klassendiagramme</h1>
|
||||
|
||||
<!--
|
||||
<p style="text-align:center">
|
||||
<small>
|
||||
Anm.: Es sollte klar sein, dass diese Zusammenfassung weit davon entfernt ist, einen vollständigen Überblick über UML zu geben.<br>
|
||||
Es erklärt nur die wichtigsten Elemente, um ein Klassendiagramm in UML-Notation zu lesen oder zu erstellen.
|
||||
</small>
|
||||
</p>
|
||||
-->
|
||||
|
||||
<p style="text-align:center">
|
||||
<img src="umlBeispiel.gif">
|
||||
<div class="quelle">Grafik entnommen aus <a href="http://www.jeckle.de/files/UUlmUML.pdf">http://www.jeckle.de/files/UUlmUML.pdf</a></div>
|
||||
</p>
|
||||
|
||||
<h2>Links</h2>
|
||||
<a href="http://ivs.cs.uni-magdeburg.de/~dumke/UML/inhalt.htm">UML Tutorial</a>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 19 KiB |
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user