Grundlagen der Programmierung 2. Bäume

Transkript

1 Grundlagen der Programmierung 2 Bäume Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 24. Mai 2006

2 Graphen Graph: Menge von Knoten undzugehörige (gerichtete oder ungerichtete) Kanten zwischen den Knoten Einige Begriffe für ungerichtete Graphen Schlingen Kanten mit gleichem Anfangs- und Endknoten Wege Kantenfolgen (A, B), (B, C),... Kreise Kantenfolgen (A, B), (B, C),..., (Z, A) Erreichbarkeit A ist von B aus erreichbar, wenn es einen Weg von A nach B gibt zusammenhängend: alle Knoten sind von jedem Knoten aus erreichbar markierter Graph Knoten bzw. Kanten haben Markierungen Grundlagen der Programmierung 2-1 -

3 Bäume Baum: ein (gerichteter oder ungerichteter) Graph, zusammenhängend, ohne Kreise, mit Wurzel-Knoten Annahme: die Wurzel ist oben, Wurzel Vorgänger Blatt Tochter Nachfolger Grundlagen der Programmierung 2-2 -

4 Bäume: Einige Begriffe: geordneter Baum Links-Rechts-Ordnung auf den Töchtern (Kinder,Söhne) markierter Baum Die Knoten haben Markierung (bzw. Kanten) Rand des Baumes Liste der Blattmarkierungen eines geordneten Baumes binärer Baum Jeder Knoten ist Blatt oder hat genau zwei Töchter Höhe (Tiefe) maximale Länge eines Weges von der Wurzel zu einem Blatt balanciert bei gleichem Rand kleinste Tiefe (eines binären Baumes) Grad eines Knoten Anzahl der Töchter Grad eines Baumes maximaler Grad eines Knoten Grundlagen der Programmierung 2-3 -

5 Datenstruktur Baum Binäre, geordnete Bäume in Haskell: data Binbaum a = Bblatt a Bknoten (Binbaum a) (Binbaum a) Daten (Markierungen) sind an den Blättern des Baumes Die Daten sind von gleichem Typ Jeder (innere) Knoten hat genau zwei Tochterknoten es gibt linken und rechten Tochterknoten (geordnet) Grundlagen der Programmierung 2-4 -

6 Datenstruktur Baum; Beispiel Der folgende binäre Baum hat eine Darstellung als Bknoten (Bknoten (Bblatt 1) (Bknoten (Bblatt 3) (Bblatt 4))) (Bknoten (Bblatt 7) (Bblatt 8)) Grundlagen der Programmierung 2-5 -

7 Einige Verarbeitungsfunktionen Rand: Liste der Markierungen der Blätter: b_rand (Bblatt x) = [x] b_rand (Bknoten bl br) = (b_rand bl) ++ (b_rand br) testet, ob Element im Baum ist: b_in x (Bblatt y) = (x == y) b_in x (Bknoten bl br) = b_in x bl b_in x br wendet eine Funktion auf alle Elemente des Baumes an, Resultat: Baum der Resultate b_map f (Bblatt x) = Bblatt (f x) b_map f (Bknoten bl br) = Bknoten (b_map f bl) (b_map f br) Grundlagen der Programmierung 2-6 -

8 Einige Verarbeitungsfunktionen (2) Größe des Baumes: b_size (Bblatt x) = 1 b_size (Bknoten bl br) = 1+ (b_size bl) + (b_size br) Summe aller Blätter, falls Zahlen: b_sum (Bblatt x) = x b_sum (Bknoten bl br) = (b_sum bl) + (b_sum br) Tiefe des Baumes: b_depth (Bblatt x) = 0 b_depth (Bknoten bl br) = 1 + (max (b_depth bl) (b_depth br)) Grundlagen der Programmierung 2-7 -

9 Einige Verarbeitungsfunktionen (3) schnelles fold über binäre Bäume: foldbt :: (a -> b -> b) -> b -> Binbaum a -> b foldbt op a (Bblatt x) = op x a foldbt op a (Bknoten x y) = (foldbt op (foldbt op a y) x) foldbt mit optimiertem Stackverbrauch: foldbt :: (a -> b -> b) -> b -> Binbaum a -> b foldbt op a (Bblatt x) = op x a foldbt op a (Bknoten x y) = (((foldbt op) $! (foldbt op a y)) x) effizientere Version von b rand und b sum b_rand_eff = foldbt (:) [] b_baum_sum = foldbt (+) 0 Grundlagen der Programmierung 2-8 -

10 Auswertung mit foldbt Werte foldbt (+) 0 "(((1,2),3),(4,5))" aus: foldbt (+) 0 "(((1,2),3),(4,5))" --> foldbt (+) (foldbt (+) 0 (4,5)) ((1,2),3) --> foldbt (+) (foldbt (+) (foldbt (+) 0 (5)) (4) ((1,2),3)) --> foldbt (+) (foldbt (+) (5+0) (4) ((1,2),3)) --> foldbt (+) (4+ (5+0)) ((1,2),3) --> foldbt (+) (foldbt (+) (4+ (5+0)) (3)) (1,2) --> foldbt (+) (3+ (4+ (5+0))) (1,2) --> foldbt (+) (foldbt (+) (3+ (4+ (5+0))) (2) (1)) --> foldbt (+) (2+ (3+ (4+ (5+0)))) (1) --> 1+ (2+ (3+ (4+ (5+0)))) Grundlagen der Programmierung 2-9 -

11 Bemerkungen zu foldbt Sei tr binärer Baum mit Randliste [a 1,..., a n ] (foldbt f a tr) entspricht (f a_1 (f a_2 (... (f a_n a)...s))). D.h. foldbt entspricht foldr Grundlagen der Programmierung

12 Vergleich von b rand und b rand eff : Nur für volle binäre Bäume: testbaum m Ergebnislisten werden voll ausgewertet Zählweise der Reduktionen wie in Hugs Grundlagen der Programmierung

13 Analyse von b rand: #Reduktionen von (b_rand testbaum_n) Tiefe #Blätter #berechnet #tatsächliche m 2 m 2 m + 2 m 1 m m 2 m + 2 m 1 m m + 14 n n + n/2 log 2 (n) + 3 n n + n/2 log 2 (n) + 3 n Grundlagen der Programmierung

14 Analyse von b rand eff #Reduktion von (b_rand_eff testbaum_n) Tiefe #Blätter #berechnet #tatsächliche #Red(b rand) m 2 m 2 m m 2 m m + 15 n 3n 3n Fazit: b rand eff ist effizienter: O(n) statt O(n log(n)). Grundlagen der Programmierung

15 Suchbaum Effizienzsteigerung beim Zugriff auf Elemente: sortierte Liste als Baum Jeder Knoten enthält als Markierung den größten Schlüssel des linken Teilbaumes mit den kleineren Werten. Laufzeit des Zugriffs: logarithmisch in der Anzahl der Elemente Grundlagen der Programmierung

16 Suchbaum, Beispiel Grundlagen der Programmierung

17 Haskell-Implementierung: Suchbaum data Satz a = Satz Integer a data Suchbaum a = Sblatt Int a Sknoten (Suchbaum a) Int (Suchbaum a) Suchbaumleer Verwendung: Suchbaum (Satz a) intial = Suchbaumleer Grundlagen der Programmierung

18 Haskell-Implementierung: Suchbaum einfuegedbs (Satz x sx) Suchbaumleer = Sblatt x (Satz x sx) einfuegedbs (Satz x sx) (Sblatt k satzk) = if x < k then Sknoten (Sblatt x (Satz x sx)) x (Sblatt k satzk) else if x == k then error " schon eingetragen" else Sknoten (Sblatt k satzk) k (Sblatt x (Satz x sx)) einfuegedbs (Satz x sx) (Sknoten l k r) = if x < k then Sknoten (einfuegedbs (Satz x sx) l) k r else if x == k then error " schon eingetragen" else Sknoten l k (einfuegedbs (Satz x sx) r) Grundlagen der Programmierung

19 Haskell-Implementierung zum Suchbaum Elementweises Einfügen : Vorsicht: Abhilfe: Laufzeit des Baumaufbaus mit Balancieren: sortiert die Eingabe Der entstehende Baum kann unbalanciert sein bewirkt Verschlechterung der Laufzeit von O(log(n)) auf O(n) Balancieren des Baumes durch Rotationen O(n log(n)) Grundlagen der Programmierung

20 Haskell-Implementierung eines Suchbaumes (2) istindbs (Satz x y) Suchbaumleer = False istindbs (Satz x y) (Sblatt k _) = (x == k) istindbs (Satz x y) (Sknoten bl k br) = if x < k then istindbs (Satz x y) bl else if x == k then True else istindbs (Satz x y) br erzeugedbs [] = Suchbaumleer erzeugedbs (x:xs) = einfuegedbs (Satz x x) druckedbs sb = blaettersb (erzeugedbs xs) Grundlagen der Programmierung

21 Haskell-Implementierungen zum Suchbaum foldsb :: (a -> b -> b) -> b -> Suchbaum a -> b foldsb op a Suchbaumleer = a foldsb op a (Sblatt _ x) = op x a foldsb op a (Sknoten x _ y) = (foldsb op (foldsb op a y) x) blaettersb = foldsb (:) [] Grundlagen der Programmierung

22 Allgemeinere Bäume mit beliebiger Anzahl Töchter Die Programmierung ist analog zu einfachen Bäumen data Nbaum a = Nblatt a Nknoten [Nbaum a] nbaumrand :: Nbaum a -> [a] nbaumrand (Nblatt x) = [x] nbaumrand (Nknoten xs) = concatmap nbaumrand xs Grundlagen der Programmierung