6.4 Traversierung von Bäumen

Transkript

1 6.4 Traversierung von Bäumen Vgl. Traversierung von Folgen: mit jedem Element wird etwas gemacht - bei Bäumen auch abstrakt: alle Elemente werden linear gesehen Tiefendurchlauf (depth-first traversal): Traversierung rekursiv durch Traversierung der Teilbäume Breitendurchlauf (breadth-first traversal): von der Wurzel aus eine Ebene nach der anderen durchlaufen alp

2 6.4.1 Tiefendurchlauf Alternativen: Durchlaufen in Vorordnung, Präordnung (preorder): erst die Wurzel, dann die Teilbäume Nachordnung, Postordnung (postorder): erst die Teilbäume, dann die Wurzel bei Binärbäumen auch Inordnung (inorder): erst der linke Teilbaum, dann die Wurzel, dann der rechte Teilbaum alp

3 data Bintree t = E N (Bintree t) t (Bintree t) preorder, inorder, postorder :: Bintree t -> [t] preorder E = [] preorder(n l v r) = [v] ++ preorder l ++ preorder r (analog für inorder, postorder) Beachte aber z.b. map für Binärbäume: map f E = E map f(n l v r) = N(map f l)(f v)(map f r) lässt im Prinzip offen, in welcher Reihenfolge die drei Bestandteile des neuen Baums ermittelt werden! alp

4 mit internem Iterator class Node<T> { // Binärbäume als Werte - wie Node(T val, Node<T> l, Node<T> r) { left = l; root = val; right = r; final Node<T> left; final T root; final Node<T> right; public void preorder(operation<t> op) { op.call(root); if(left!= null) left. preorder(op); if(right!= null) right.preorder(op); Beachte: dies ist nicht linear rekursiv! Z.B.... tree.preorder(new Operation<Float>(){ public void call(float x){ (ausdrucken) System.out.print(x);); alp

5 Beispiel Operatorbaum + * - - c d e a b a,b,c,... R interface Expression { void preorder(); // Polish notation! void postorder(); // reverse Polish! // void inorder(); // infix notation! * double eval(); // expression evaluation * ohne Klammern! alp

6 class Result { // sequence of objects... static void append(object x) {... class Simple implements Expression { final double value; Simple(double v) { value = v; public void preorder() { Result.append(new Double(value)); public void postorder() { // like preorder Result.append(new Double(value)); public double eval() { return value; alp

7 abstract class Composite implements Expression { abstract char op(); final Expression left,right; Composite(Expression l, Expression r){ left = l; right = r; // not null! public void preorder() { Result.append(new Character(op())); left.preorder(); right.preorder(); public void postorder() { left.postorder(); right.postorder(); Result.append(new Character(op())); public abstract double eval(); // depends on operator alp

8 class Plus extends Composite { Plus(Expression l, Expression r){ super(l,r); char op() { return '+'; public double eval() { return left.eval() + right.eval(); class Minus extends Composite { Minus(Expression l, Expression r){ super(l,r); char op() { return '-'; public double eval() { return left.eval() - right.eval(); class Times... class Div... alp

9 Operatorbaum von S. 5: + * - - c d e a b Expression x = new Times(new Plus(new Minus(new Simple(a), new Simple(b)), new Simple(c)), new Minus(new Simple(d), new Simple(e))); double result = x.eval(); Times Plus Minus Simple(a).... * + - a b c - d e = Ausdruck in Präfix-Notation! (Direkte Konstruktion des Baums aus Präfix-Notation: S. 14) alp

10 ? Alternative: class Composite implements Expression { final char op; final Expression left,right;... public double eval() { double l = left.eval(); double r = right.eval(); switch(op) { case '+': return l+r; break; case '-': return l-r; break; case '*': return l*r; break; case '/': return l/r; Indiz für mangelnde Objektorientierung alp

11 6.4.2 Lineare Repräsentation von Binärbäumen... ist bei vollständigen Bäumen möglich durch ebenenweises Aneinanderhängen der Elemente: * c d e a b alp

12 6.4.2 Lineare Repräsentation von Binärbäumen... ist bei vollständigen Bäumen möglich durch ebenenweises Aneinanderhängen der Elemente: * c d e a b ergibt sich für beliebige Operatorbäume in natürlicher Weise durch Traversierung in Vorordnung oder Nachordnung: * + - a b c - d e Beachte: Die Struktur geht dabei nicht verloren, und die Repräsentation als Geflecht kann aus der linearen Repräsentation wiedergewonnen werden! alp

13 ... und für beliebige Binärbäume mit Kennung leerer Unterbäume, z.b. Joseph Rahel Jakob Laban Rebekka Isaak könnte so eingegeben werden: Joseph Rahel? Laban?? Jakob Rebekka?? Isaak??... von Tastatur... oder aus Datei... oder aus interner linearer Repräsentation: alp

14 Ein Stack<String> enthalte Präfix-Darstellung - damit: class Pedigree { final String name; Pedigree mother, father; Pedigree(Stack<String> names) { // from sequence name = names.pop(); if(names.peek() == null) names.pop(); else mother = new Pedigree(names); if(names.peek() == null) names.pop(); else father = new Pedigree(names); public String tostring() // back to String // preorder traversal! return name+" "+mother+" "+father+" "; Bei Syntaxfehler: Kellerunterlauf oder Keller wird nicht aufgebraucht! alp

15 Konstruktion eines Baums aus linearer Infix-Darstellung ist schwieriger, z.b. aus (? Rahel Laban) Joseph (Rebekka Jakob Isaak) ( a - b + c ) * ( d - e ) Postfix-Notation ermitteln (5.1.3, mit explizitem Keller) rückwärts abarbeiten wie auf S. 14 ( oder Top-Down-Syntaxanalyse durch rekursiven Abstieg ) alp

16 Implementierung typischer Baumoperationen auf Vektor-Repräsentation: class LinearBintree<T> implements Bintree<T> { protected Vector<T> elem; LinearBintree(T root, LinearBintree<T> left, LinearBintree<T> right) { elem = new Vector<T>(); elem.add(root); if(left==null) elem.add(null); else elem.addall(left.elem); if(right==null)elem.add(null); else elem.addall(right.elem); public T root() { return elem.get(0); public LinearBintree<T> left() {... public LinearBintree<T> right(){... // traversals required! alp

17 public LinearBintree<T> left() { class Traversal { int i = 1; Vector<T> v = new Vector<T>(); void preorder() { T x = elem.get(i++); v.add(x); if(x!= null){preorder(); preorder(); Traversal t = new Traversal(); t.preorder(); LinearBintree<T> result = new LinearBintree<T> (null,null,null); result.elem = t.v; return result;... aufwendig! Einfacher mit Geflecht! alp

18 6.4.3 Iterativer Tiefendurchlauf... ist z.b. hilfreich für die Konstruktion externer Iteratoren. Explizite Zuhilfenahme eines Kellers (wie zu erwarten ;-) von Bäumen: class Node<T> {... // vgl public void preorder(operation<t> op) { Stack<Node<T>> s = new Stack<Node<T>>(); Node<T> x = this; while(true){ op.call(x.root); if(x.right!= null) s.push(x.right); x = x.left; if(x == null) if(s.empty()) return; else x = s.pop(); alp

19 ... oder mit aufwendigerer Repräsentation: gefädelte Darstellung (threaded representation), geeignet für Durchlauf mit Inordnung: e b g a d f h c a b c d e f g h alp

20 6.4.4 Breitendurchlauf... wird für manche Anwendungen (statt Tiefendurchlauf) benötigt, z.b. für unendliche Bäume: data Inftree t = N t (Inftree t)(inftree t) duals = from "1" where from x = N x(from(x++"0"))(from(x++"1")) alp

21 6.4.4 Breitendurchlauf... wird für manche Anwendungen (statt Tiefendurchlauf) benötigt, z.b. für unendliche Bäume: data Inftree t = N t (Inftree t)(inftree t) duals = from "1" where from x = N x(from(x++"0"))(from(x++"1")) hat den Wert 1 und Breitendurchlauf liefert die Dualzahlen in aufsteigender Folge alp

22 Breitendurchlauf rekursiv: einfacher für Verallgemeinerung Breitendurchlauf im Wald : data Tree t = N t [Tree t] root(n r s) = r subt(n r s) = s Erst alle Wurzeln des Waldes (Ebene 0), dann Breitendurchlauf auf Ebene 1: list :: [Tree t] -> [t] -- serialization only list[] = [] list forest = roots ++ list subts where roots = map root forest subts = concat(map subt forest)... list[tree]... alp

23 Breitendurchlauf iterativ - mit Verwendung einer Schlange von Bäumen, hier mit Anwendung Finde einen auf kürzestem Weg erreichbaren Unterbaum mit Wurzelmarke x : class LinkedTree<T> implements Tree<T> { // vgl protected T root; protected final Vector<LinkedTree<T>> children = new Vector<LinkedTree<T>>();... public Tree<T> breadthfirstsearch(t x) throws NotFound { Queue<LinkedTree<T>> q = new LinkedList<LinkedTree<T>>(); q.add(this); do{linkedtree<t> t = q.remove(); if(x.equals(t.root)) return t; for(linkedtree<t> ch: t.children) q.add(ch); while(!q.size()==0); throw new NotFound(); 23

24 Bäume in den Java-Bibliotheken? Nicht als Werte oder abstrakte Datenobjekte, nur als Repräsentation für andere abstrakte Datentypen! alp