Algorithmen und Datenstrukturen 1 SS 2002

Präsentation zum Thema: "Algorithmen und Datenstrukturen 1 SS 2002"—  Präsentation transkript:

1 Algorithmen und Datenstrukturen 1 SS 2002
Mag.Thomas Hilpold Institut für Wirtschaftsinformatik Software Engineering JKU Linz Termin 8 – Bäume

2 Übersicht Lösung Übung 6 Themenbereiche heute Bäume Binärbaume
einfache Algorithmen auf Bäume rekursiv und iterativ Übungsbesprechung Übung 8

3 Lösung Ü6 User: integer erwartet, String eingegeben
Device: Hardware Fehler: Printer ausgeschaltet, Festplatte defekt, Web-page kurzfristig nicht erreichbar Physical: Disk full, Mem full Code errors: Eine Methode wird inkorrekt ausgeführt, ungültiger Array index

4 Rückblick letztes Mal rekursive Algorithmen ruft sich selbst auf
enthalt rek. und nicht-rek. Zweige rekursive Algorithmen auf Listen Liste -> einfache rek. Datenstruktur Dies paßt auch zur Objektorientierung; Diskussion des Beispiels, Zeit lassen Welcher Code wird ausgeführt, Abarbeitung bis i =

5 Bäume Allgemeines rekursive Datenstruktur
Definition (vereinfacht): Eine Baumstruktur T ist entweder die leere Struktur ein Knoten mit einer endlichen Zahl verknüpfter Baumstrukturen T (Teilbäume) Level (Stufe) 0 1 Wurzel Stufe 1 2 3 innerer Knoten Stufe 2 4 5 6 Grad d Baumes = 3 (max Nachfolger eines inneren Knotens) 7 8 Stufe 3 = max 9 Blatt (ohne Nachfolger) oder Endelement Höhe = max Stufe + 1 = 4

6 x ist Vorgänger von y (ascendent) y ist Nachfolger von x (descentant)
Bäume Allgemeines (2) allgemeiner Baum Bäume vom Grad 2 heißen binär; Binärbaum (binary tree) Ternärbaum (Grad = 3) Grad = max Anzahl der Nachfolger eines Knotens im Baum Level (Stufe) 0 1 Wurzel Stufe 1 2 3 x ist Vorgänger von y (ascendent) Stufe 2 4 5 6 y ist Nachfolger von x (descentant) 7 8 Stufe 3 9

7 Binärbaum Allgemeines
Bäume vom Grad 2 heißen binär; Binärbaum (binary tree) Beispiele: Stammbaum (Vater/Mutter), Turniere (2 Spieler, 1 Gewinner steigt auf), arithmetischer Ausdruck ((1+2)*(2+4); jeder Operator 2 Operanden) type BinaryTree = { refType Node = { int value Node left Node right } Level (Stufe) 0 1 Wurzel Stufe 1 2 3 Stufe 2 4 5 6 7 8 Stufe 3

8 Binärer Suchbaum Begriff
Ein binärer Suchbaum ist ein binärer Baum, in dem die Knoten so geordnet sind, daß wenn Value der Informationsteil eines Knotens ist, die Informationsteile aller linken Abkömmlinge “kleiner” und die aller rechten Abkömmlinge “größer” als value sind. weitere Übung Level (Stufe) 0 3 Wurzel type BinaryTree = { refType Node = { int value Node left Node right } Node root; init() {root = null}; ... //Algorithmen Stufe 1 2 7 Stufe 2 1 5 9 8 10 Stufe 3

9 Binärer Suchbaum Suchen boolean search( int v) Idee:
falls knotenwert == v -> gefunden falls v > value suche rechts, sonst links falls aktueller Knoten == null -> false 3 2 7 1 5 9 type BinaryTree = { refType Node = { int value Node left Node right } Node root; init() {root = null}; ... //Algorithmen 8 10

10 Binärer Suchbaum Suchen (rekursiv) boolean search( int v) Idee:
falls knotenwert == v -> gefunden falls v > value suche rechts, sonst links falls aktueller Knoten == null -> false type BinaryTree = { ... boolean search (int v){ return searchR(root, v) }//insert boolean searchR(Node t, int v){ if (t == null) { return false } if (t^.v == v) { return true } if (v < t^.v) return searchR(t^.left, v) else return searchR(t^.right, v) }//searchR }//Tree 3 2 7 1 5 9 8 10

11 Binärer Suchbaum Suchen iterative Lösung für Suchen
Lösung einfach, da nur ein Pfad zur Lösung beschritten werden muß! Solange cur != gesuchtes { wenn v > Cur, cur = rechter Nachfolger .... 3 2 7 1 5 9 8 10

12 Binärer Suchbaum Suchen type BinaryTree = { ...
boolean search (int v){ Node n n = root while (n != null && n^.value != v){ if (v < n^.value) n = n^.left else n = n^.right } return n != null }//BinaryTree 3 2 7 1 5 9 8 10

13 Binärbaum Baumtraversierung Inorder (links, Knoten, rechts)
Praeorder (Knoten, links, rechts) Postorder (links, rechts, Knoten) Level order (Ebenen) Inorder (a+b)*(d-(e*f)) Praeorder ? Postorder ? Level order ? * * + a b – d * e f a b + d e f * - * * + - a b d * e f + - / d * a b e f Man merkt sich bei Rekursionsschritt bisherige Knoten und wie weit diese bearbeitet wurden. -> Stack Kein Suchbaum!!

14 Binärer Suchbaum Iterative Algorithmen:
Iterative Suche im Binärbaum -> einfach Im allgemeinen sind iterative Alg. auf Bäumen rel. kompliziert Beispiel: iterative Traversierung (praeorder) Problem: Im Unterschied zur Suche (1Pfad) muß man sich Knoten merken. Knoten / links / rechts > 3 Idee: Zunächst zu merkende Knoten auf einen Stack legen 2 7 1 5

15 Binärer Suchbaum Algorithmus (iterative Traversierung praeorder):
Idee: schreibe Knoten merke rechten Nachfolger gehe zu linken Knoten falls null. hole zuletzt gemerkten Knoten und gehe zu rechtem Knoten type Tree { reftype Node {...} preorderI(Node n){ Stack s; s.init() while (n <> null) { write(n^.v) if (n^.right != null) s.push(n^.right) if (n^.left != null) n = n^.left else n = s.pop() }//while }//preorderI 3 2 7 1 5

16 Binärer Suchbaum Algorithmus (iterative Traversierung praeorder):
type Tree { reftype Node {...} preorderI(Node n){ Stack s; s.init() while (n <> null) { write(n^.v) if (n^.right != null) s.push(n^.right) if (n^.left != null) n = n^.left else n = s.pop() }//while }//preorderI 3 2 7 1 5 9 8 10

17 Binärer Suchbaum einfacher Stack (Array): 1: push (3) 2: pop (): 3 3 4
type Stack { int[1:] stack int sp // stack pointer init() { sp = 0} boolean isEmpty(){ return (sp == 0) }//isEmtpy push (Node n){ sp = sp+1 stack[sp] = n }//push Node pop(){ if (!isEmtpy){ sp = sp-1 return stack[sp+1] } else return null; }//pop }//Stack 1: push (3) 2: pop (): 3 3 4 1

18 Zusammenfassung Baum ist eine rekursive Datenstruktur
Begriffe: Grad, Höhe, Wurzel, Stufe, Blatt, Innerer Knoten Binärbaum binärer Suchbaum Search rekursiv / iterativ -> auch iterativ einfach (selten) Baumtraversierung binärer Bäume Iterative Lösung für praeorder Traversierung -> rel. kompliziert

19 Übung 8 ad 1) Binarytree rek. Algorithmen
int size() { ... } // Anzahl d. Knoten boolean contains(int value){ ... } int height(){ ... } // Anzahl der Ebenen free(){ ... } ad 2) iteratives Einfügen in Binärbaum ad 3) Stammbaum areParents(char[] father, char[] mother) Hinweise: Zunächst Algorithmus für einfach Beispiele überlegen: zb. 1 Knoten, null, 2, 3 Knoten Rekursive Definition beachten !