Haskell Seminar Abstrakte Datentypen. Nils Bardenhagen ms2725

Transkript

1 Haskell Seminar Abstrakte Datentypen Nils Bardenhagen ms2725

2 Gliederung Konzept Queue Module Sets Bags Flexible Arrays Fazit

3 Abstrakte Datentypen (ADT) Definition: Eine Zusammenfassung von Operationen, die auf einer Menge von Objekten durchgeführt werden, wird als abstrakter Datentyp bezeichnet. Alternative Bezeichnung: Klasse, Modul

4 ADT: Eigenschaften Universalität: Verwendung in verschiedenen Programmen Präzise Beschreibung: Interface muss eindeutig und vollständig sein Kapselung: Der Anwender soll wissen was der ADT tut, aber nicht wie Schutz: Der Anwender kann nicht in die interne Datenstruktur eingreifen. Modularität: Einfacher Austausch, Fehlersuche, Verbesserung => Objektorientierung

5 ADT: Beispiele Float Tree List Queue Stack

6 Queue Operationen: empty :: Queue a join :: aöqueue aöqueue a front :: Queue aöa back :: Queue aöqueue a isempty :: Queue aöbool

7 Queue: Axiome isempty empty isempty (join x xq) front (join x empty) front (join x (join y xq)) back (join x empty) back (join x (join y xq)) = True = False = x = front (join y xq) = empty = join x (back (join y xq)) isempty (join x bottom) = isempty =

8 Queue: Implementierung 1 joinc joinc x xs :: aö[a] ö [a] = xs ++ [x] emptyc :: [a] emptyc = [] isemptyc isemptyc xs frontc frontc (x:xs) backc backc (x:xs) :: [a] ö Bool = null xs :: [a] öa = x :: [a] ö [a] = xs abstr :: [a] ö Queue a abstr = foldr join empty. Reverse reprn :: Queue aö[a] reprn empty = [] reprn (join x xq) = reprn xq ++ [x]

9 Queue: Implementierung 2 valid valid (xs,ys) :: ([a],[a]) ö Bool = not (null xs) v null ys abstr abstr :: ([a],[a]) ö Queue a (xs,ys) = (foldr join empty. reverse) (xs ++ reverse ys)

10 Queue: Implementierung 2 emptyc = ([],[]) isemptyc (xs,ys) = null xs joinc x (xs,ys) frontc (x:xs, ys) backc (x:xs,ys) = mkvalid (ys, x:zs) = x = mkvalid (xs,ys) mkvalid :: ([a],[a]) ö ([a],[a]) mkvalid (xs, ys) = if null xs then (reverse ys,[]) else (xs,ys)

11 Module module Queue (Queue, empty, isempty, join, front, back) where newtype Queue a = MkQ ([a],[a]) isempty isempty (MkQ (xs:ys)) empty empty join join x (MkQ (ys,xs)) front front (MkQ (x:xs, ys)) back back (MkQ(x:xs, ys)) mkvalid mkvalid (xs, ys) :: Queue aöbool = null xs :: Queue a = MkQ([],[]) :: aöqueue aöqueue a = mkvalid(ys,x:xs) :: Queue aöa = x :: [a] ö [a] = mkvalid(xs,ys) :: ([a],[a]) ö Queue a = if null xs then MkQ (reverse ys, []) else mkq (xs, ys)

12 Module (2) import Queue toq toq :: [a] ö Queue a = foldr join empty. Reverse fromq :: Queue a ö [a] fromq q = if isempty q then [] front q:fromq (back q)? join 1 (join 2 empty) ([2],[1])? join 1 (join 2 empty) == join 2 (join 1 empty) False

13 Sets Ausgewählte Operationen: empty isempty member insert delete union meet minus :: Set a :: Set aöbool :: Set aöaöbool :: aöset aöset a :: aöset aöset a :: Set aöset aöset a :: Set aöset aöset a :: Set aöset aöset a

14 Sets: Axiome insert x (insert x xs) insert x (insert y xs) isempty empty isempty (insert x xs) = insert x xs = insert y (insert x xs) = True = False member empty y = False member (insert x xs) y = (x=y) v member xs y delete x empty delete x (insert y xs) union xs empty union xs (insert y ys) meet xs empty meet xs (insert y ys) minus xs empty minus xs (insert y ys) = empty = if x = y then delete x xs else insert y (delete x xs) = xs = insert y (union xs ys) = empty = if member xs y then insert y (meet xs ys) else meet xs ys = xs = minus (delete y xs) ys

15 Sets: Implementierung als Liste abstr abstr valid xs valid xs member xs x insert x xs delete x xs union xs ys minus xs ys some some p :: [a] ö Set a = foldr insert empty = True = nonduplicated xs = some (==x) = x:xs = filter ( x) xs = xs ++ ys = filter (not. member ys) xs :: (a öbool) ö [a] ö Bool = or. map p

16 Sets: Implementierung als Liste insert x xs union xs ys = x:filter ( x) xs = xs ++ filter (not. Member xs) ys member xs x = if null ys then False else (x == head ys) where ys = dropwhile (<x) xs union [] ys = ys union (x:xs) [] = x:xs union (x:xs)(y:ys) (x < y) = x:union xs (y:ys) (x==y) = x:union xs ys (x > y) = y:union (x:xs) ys

17 Sets: Implementierung als Baum Data Stree a = Null Fork (Stree a) a (Stree a) empty empty isempty isempty Null isempty (Fork xt y yt) :: Set a = Null :: Set aöbool = True = False member :: (Ord a) => Stree aöaöbool member Null x = False member (Fork xt y yt) x (x < y) = member xt x (x == y) = True (x > y) = member zt x insert :: (Ord a) => aöstree aöstree a insert x Null = Fork Null x Null insert x (Fork xt y zt) (x < y) = Fork (insert x xt) y zt (x == y) = Fork xt y zt (x > y) = Fork xt y (insert x zt)

18 Sets: Implementierung als Baum delete ::(Ord a) => aöstree aöstree a delete x Null = Null delete x (Fork xt y zt) (x < y) = Fork (delete x xt) y zt (x == y) = join xt zt (x > y) = Fork xt y (delete x zt) join join xt yt :: Stree aöstree aöstree a = if isempty yt then xt else Fork xt y zt where (y,zt) = splittree xt splittree :: Stree aö(a, Stree a) splittree (Fork xt y zt) = if isempty xt then (y,zt) else (u, Fork vt y zt) where (u,vt) = splittree xt

19 Bags / Multisets {[1,2,2,3]} ={[3,2,1,2]} aber {[1,2,2]}!= {[1,2]} Operationen mkbag :: [a] ö Bag a isempty :: Bag aöbool union :: Bag aöbag aöbag a minbag :: Bag aöa delmin :: Bag aöbag a

20 Bags: Axiome isempty (mkbag xs) union(mkbagxs) (mkbagys) minbag (mkbag xs) delmin (mkbag xs) = null xs = mkbag(xs++ys) = minlist xs = mkbag (deletemin xs)

21 Bags: Implementierung (Heap) data Htree a = Null Fork Int a (Htree a) (Htree a) fork fork x yt zt :: aöhtree aöhtree a = if m < n then Fork p x zt yt else Fork p x yt zt where m = size yt n = size zt p = m + n + 1 size :: Htree aöint size Null = 0 size (Fork n x yt zt) = n isempty :: Htree aöbool isempty Null = True isempty (Fork n x yt zt) = False minbag :: Htree aöa minbag (Fork n x yt zt) = x delmin :: Htree aöhtree a delmin (Fork n x yt zt) = union yt zt

22 Bags: Implementierung (Heap) union union Null yt union (Fork m u vt wt) Null :: Htree aöhtree aöhtree a = yt = Fork m u vt wt union (Fork m u vt wt) (Fork n x yt zt) (u x) = fork u vt (union wt (Fork n x yt zt)) (x < u) = fork x yt (union (Fork m u vt wt) zt) mkbag mkbag xs :: [a] ö Htree a = fst (mktwo (length xs) xs) mktwo :: Int ö [a] ö (Htree a, [a]) mktwo n xs (n == 0) = (Null, xs) (n == 1) = (fork (head xs) Null Null, tail xs) otherwise = (union xt yt, zs) where (xt, ys) = mktwo m xs (yt,zs) = mktwo (n-m) ys m = n div 2

23 Flexible Arrays Operationen empty isempty access update hiext hirem loext lorem :: Flex a :: Flex aöbool :: Flex aöint öa :: Flex aöint öaöflex a :: aöflex aöflex a :: Flex aöflex a :: aöflex aöflex a :: Flex aöflex a

24 Flexible arrays: Axiome hiext x. loext y hirem empty hirem (hiext x xf) hirem (loext x empty) hirem (loext x (hiext y xf)) hirem (loext x (loext y xf)) access ampty k access (loext x xf) 0 access (hiext x xf) (k + 1) = loext y hiext x = error = xf = empty = loext x xf = loext x (hirem(loext y xf)) = error out of range = x = access xf k access (hiext x xf) k (k < n) = access xf k (k == n) = x (k > n) = error where n = length xf

25 Flexible Arrays: Implementierung data Flex a = Null Leaf a Fork Int (Flex a) (Flex a) access access (Leaf x) 0 access (Fork n xt yt) k :: Flex aöint a = x = if k < m then access xt k else access yt (k m) where m = size xt size :: Flex aöint size Null = 0 size (Leaf x) = 1 size (Fork n xt yt) = n

26 Fazit