Gliederung Einführung Binary Tree Binary Search Tree Binary Heap

Präsentation zum Thema: "Gliederung Einführung Binary Tree Binary Search Tree Binary Heap"—  Präsentation transkript:

1

2 Gliederung Einführung Binary Tree Binary Search Tree Binary Heap
Rose Tree Anwendungsbeispiel: Huffman Tree

3 Einführung Was sind Bäume? Bäume sind spezielle Graphen
Diese Graphen sind zusammenhängend Besitzen einen Wurzelknoten Jeder nicht Wurzelknoten, besitzt genau einen Elternknoten Knoten können beliebig viele Nachkommen haben Knoten ohne Nachkommen werden als Blätter bezeichnet

4 Einführung Wozu werden Bäume benötigt? Generalisierung von Listen
Hierarchische Strukturen aufbauen Effiziente Verarbeitung von Daten

5 Binary Tree Knoten haben genau zwei Kinder oder sind Blätter
Definition in Haskell data Btree a = Leaf a | Fork (Btree a) (Btree a) Eigenschaften Größe ist die Anzahl der Blätter Tiefe ist die Distanz von der Wurzel zum weitesten entfernten Blatt Anzahl innerer Knoten entspricht der Größe vermindert um eins

6 Binary Tree Berechnung der Eigenschaften size :: Btree a -> Int
size (Leaf x) = 1 size (Fork xt yt) = size xt + size yt height :: Btree a -> Int height (Leaf x) = 0 height (Fork xt yt) = 1 + max (height xt) (height yt) nodes :: Btree a -> Int nodes (Leaf x) = 0 nodes (Fork xt yt) = 1 + nodes xt + nodes yt

7 Binary Tree Baum -> Liste Liste -> Baum
flatten :: Btree a -> [a] flatten (Leaf x) = [x] flatten (Fork xt yt) = flatten xt ++ flatten yt Liste -> Baum mkBtree :: [a] -> Btree a mkBtree xs | (m == 0) = Leaf (unwrap xs) | otherwise = Fork (mkBtree ys) (mkBtree zs) where m = (length xs) ‘div‘ 2 (ys, zs) = splitAt m xs

8 Binary Tree map auf Bäumen fold auf Bäumen
mapBtree :: (a -> b) -> Btree a -> Btree b mapBtree f (Leaf x) = Leaf (f x) mapBtree f (Fork xt yt) = Fork (mapBtree f xt) (mapBtree f yt) fold auf Bäumen foldBtree :: (a -> b) -> (b -> b -> b) -> Btree a -> b foldBtree f g (Leaf x) = f x foldBtree f g (Fork xt yt) = g (foldBtree f g xt) (foldBtree f g yt)

9 Binary Tree Definitionen mit Fold size = foldBtree (const 1) (+)
height = foldBtree (const 0) (\ a b -> 1 + max a b) flatten = foldBtree wrap (++) mapBtree f = foldBtree (Leaf . f) Fork

10 Binary Search Tree Daten sind in den inneren Knoten enthalten
Die Daten müssen ordinalen Typs sein Es gibt keine Blätter Definition in Haskell data (Ord a) => Stree a = Null | Fork (Stree a) a (Stree a) Für alle Elemente im linken Teilbaum gilt <a Für alle Elemente im rechten Teilbaum gilt >a

11 Binary Search Tree Baum -> Liste Liste -> Baum
flatten :: (Ord a) =>Stree a -> [a] flatten Null = [] flatten (Fork xt x yt) = flatten xt ++ [x] ++ flatten yt Liste -> Baum mkStree :: (Ord a) => [a] -> Stree a mkStree [] = Null mkStree (x:xs) = Fork (mkStree smaller) x (mkStree larger) where (smaller,larger) = partition (<x) xs partition :: (a->Bool) -> [a] -> ([a],[a]) partition p xs = ([ x | x <- xs, p x], [ y | y <- xs, (not . p) y])

12 Binary Search Tree Suchen Einfügen
member :: (Ord a) => a -> Stree a -> Bool member x Null = False member x (Fork xt y yt) | (x < y) = member x xt | (x == y) = True | (x > y) = member x yt Einfügen insert :: (Ord a) => a -> Stree a -> Stree a insert x Null = Fork Null x Null insert x (Fork xt y yt) | (x < y) = Fork (insert x xt) y yt | (x == y) = Fork xt y yt | (x > y) = Fork xt y (insert x yt)

13 Binary Search Tree Entfernen
delete :: (Ord a) => a -> Stree a -> Stree a delete x Null = Null delete x (Fork xt y yt) | (x < y) = Fork (delete x xt) y yt | (x == y) = join xt yt | (x > y) = Fork xt y (delete x yt) join :: (Ord a) => Stree a -> Stree a -> Stree a join xt yt = if empty yt then xt else Fork xt h t where (h,t) = splitTree yt splitTree :: (Ord a) => Stree a -> (a,Stree a) splitTree (Fork xt y yt) = if empty xt then (y,yt) else (x, Fork wt y yt) where (x,wt) = splitTree xt

14 Binary Heap Aufbau entspricht Binary Search Tree Definition in Haskell
data (Ord a) => Htree a = Null | Fork a (Htree a) (Htree a) Für alle Kindelemente eines Knotens gilt >a

15 Binary Heap Baum -> Liste Liste -> Baum
flatten :: (Ord a) =>Htree a -> [a] flatten Null = [] flatten (Fork x xt yt) = x:merge (flatten xt) (flatten yt) merge:: (Ord a) =>[a] -> [a] -> [a] merge [] ys = ys merge xs [] = xs merge (x:xs) (y:ys) = if x<=y then x:merge xs (y:ys) else y:merge (x:xs) ys Liste -> Baum mkHeap :: (Ord a) => [a] -> Htree a mkHeap = heapify . mkHTree

16 Binary Heap Liste -> Baum
heapify :: (Ord a) => Htree a -> Htree a heapify Null = Null heapify (Fork x xt yt) = sift x (heapify xt) (heapify yt) sift :: (Ord a) => a -> Htree a -> Htree a -> Htree a sift x Null Null = Fork x Null Null sift x (Fork y a b) Null = if x <= y then Fork x (Fork y a b) Null else Fork y (sift x a b) Null sift x Null (Fork z c d) = if x <= z then Fork x Null (Fork z c d) else Fork z Null (sift x c d) sift x (Fork y a b) (Fork z c d) | x<=(y 'min' z) = Fork x (Fork y a b) (Fork z c d) | y<=(x 'min' z) = Fork y (sift x a b) (Fork z c d) | z<=(x 'min' y) = Fork z (Fork y a b) (sift x c d) insert :: (Ord a) => a -> Htree a -> Htree a insert x t = sift x Null t

17 Rose Tree Knoten können beliebig viele Kinder haben
Definition in Haskell data Rose a = Node a [Rose a] Blätter haben leere Listen von Kindern Binary Tree entspricht einem Rose Tree 2. Ordnung

18 Rose Tree Berechnung der Eigenschaften size :: Rose a -> Int
size (Node x xts) = 1 + sum (map size xts) height :: Rose a -> Int height (Node x xts) = 1 + maxlist (map height xts) where maxlist = foldl (max) 0 nodes :: Rose a -> Int nodes (Node x []) = 0 nodes (Node x xts) = 1 + sum(map nodes xts)

19 Rose Tree fold-Funktion map-Funktion
foldRose :: (a -> [b] -> b) -> Rose a -> b foldRose f (Node x xts) = f x (map (foldRose f) xts) map-Funktion mapRose :: (a -> b) -> Rose a -> Rose b mapRose f = foldRose (Node . f)

20 Rose Tree Baum -> Liste Breadth-First Depth-First

21 Rose Tree Baum -> Liste (breadth-first) level :: Rose a -> [a]
level = concat . levels levels :: Rose a -> [[a]] levels (Node x xts) = [x]:combine (map levels xts) combine :: [[[a]]] -> [[a]] combine = foldr (zipWith2) [] zipWith2 :: [[a]] -> [[a]] -> [[a]] zipWith2 [] yss = yss zipWith2 xss [] = xss zipWith2 (xs:xss) (ys:yss) = (xs++ys):(zipWith2 xss yss)

22 Rose Tree Baum -> Liste (depth-first) Eigenschaften der Funktionen
flatten :: Rose a -> [a] flatten (Node x xts) = x:concat (map flatten xts) Eigenschaften der Funktionen breadth-first: Kann auf unendliche Bäume angewendet werden werden depth-first: Braucht deutlich weniger Speicherplatz

23 Anwendungsbeispiel: Huffman Tree
Dient der Datenkomprimierung Erzeugt aus einer Zeichenkette Bitcode variabler Länge Codierung der einzelnen Zeichen anhand ihrer Auftrittswahrscheinlichkeit Je größer die Auftrittswahrscheinlichkeit, desto kürzer die resultierende Bitfolge

24 Anwendungsbeispiel: Huffman Tree
Teilprobleme bei der Implementierung der Huffmancodierung Ermitteln der Auftrittshäufigkeiten Aufbau des Huffman Tree Kodierung Dekodierung

25 Anwendungsbeispiel: Huffman Tree
Ermitteln der Auftrittshäufigkeiten Aus einer Zeichenkette wird eine Liste aus den einzelnen Zeichen mit deren Auftrittshäufigkeiten ermittelt Alphabetisches Sortieren der gegebenen Zeichenkette Ermittlung der Auftrittshäufigkeiten Sortierung entsprechend der Auftrittshäufigkeiten sample :: [Char] -> [(Char,Int)] sample = sortby snd . collate . sortby id collate :: [Char] -> [(Char,Int)] collate [] = [] collate (x:xs) = (x,1+(length ys)):collate zs where (ys,zs) = span (==x) xs

26 Anwendungsbeispiel: Huffman Tree
Aufbau des Huffman Tree mkHuff :: [(Char,Int)] -> BTree Char mkHuff = unlabel . unwrap . until singleton combine . map mktip Die Tupel der Liste werden in Blätter umgewandelt Aus den jeweils ersten beiden Bäumen der List wird ein neuer Baum generiert Sein Gewicht entspricht der Summe der Gewichte der Teilbäume Der Erzeugte Baum wird entsprechend seines Gewichts in die Liste einsortiert Es werden solange Bäume zusammengefügt, bis nur noch einer Übrig ist Abschließend werden die Gewichte aus dem Baum entfernt

27 Anwendungsbeispiel: Huffman Tree
Kodierung Einfacher Ansatz: Ermitteln der Bitfolge direkt am Baum Für jedes Zeichen erneute Traversierung notwendig => Ineffizient Effizientere Lösung: Umwandlung des Baumes in einen CodeTable

28 Anwendungsbeispiel: Huffman Tree
Kodierung type CodeTable = [(Char,[Bit])] transform :: Btree Char -> CodeTable Baum wird einmal traversiert Zeichen in den Blättern und zugehörige Bitfolge werden in Tupeln gespeichert Resultierende Liste aus Tupeln ist entsprechend der Länge der Bitfolge sortiert

29 Anwendungsbeispiel: Huffman Tree
Kodierung encode :: Btree Char -> [Char] -> [Bit] encode t = concat . map (codelookup codetable) where codetable = transform t codelookup :: CodeTable -> Char -> [Bit] codelookup ((x,bs) : xbs) y = if x == y then bs else codelookup xbs y

30 Anwendungsbeispiel: Huffman Tree
Dekodierung decode :: BTree Char -> [Bit] -> [Char] decode t cs = if null cs then [] else decode1 t cs where decode1 (Leaf x) cs = x : decode t cs decode1 (Fork xt yt) (0:cs) = decode1 xt cs decode1 (Fork xt yt) (1:cs) = decode1 yt cs

31