abstraktn í datové typy

AbstraktnAbstraktní datové typyí datové typy

doc. Dr. Ing. doc. Dr. Ing. Miroslav BenešMiroslav Beneš

katedra informatiky, A-1007katedra informatiky, A-1007

59 732 59 732 42134213

22ÚDPJ - Abstraktní datové typyÚDPJ - Abstraktní datové typy

Obsah pObsah přednáškyřednášky

Motivace, vlastnosti ADTMotivace, vlastnosti ADTModuly v HaskelluModuly v HaskelluObecné principy návrhu ADTObecné principy návrhu ADTADT FrontaADT FrontaADT Vyhledávací stromADT Vyhledávací stromADT MnožinaADT MnožinaADT RelaceADT RelacePříklady na procvičeníPříklady na procvičení


MotivaceMotivace

Cíl: Vytvoření kalkulátoru pro číselné výrazyCíl: Vytvoření kalkulátoru pro číselné výrazy čtení a zápis hodnot proměnnýchčtení a zápis hodnot proměnných

Modely zapisovatelné paměti Modely zapisovatelné paměti seznam dvojicseznam dvojic:: [(String, Int)][(String, Int)] funkce:funkce: (String -> Int)(String -> Int)

OperaceOperace initial :: Storeinitial :: Store value :: Store -> String -> Intvalue :: Store -> String -> Int update :: Store -> String -> Int -> Storeupdate :: Store -> String -> Int -> Store


AbstraktnAbstraktníí datov datovýý typ typ

Omezené rozhraníOmezené rozhraní type Store type Store = [(Int, Var)]= [(Int, Var)]ss1, s2:: Store1, s2:: Store -> Co je to -> Co je to s1++s2s1++s2 ??

Nezávislost rozhraní na implementaciNezávislost rozhraní na implementaci type Store type Store = Var -> Int= Var -> Ints1, s2:: Stores1, s2:: Store -> -> s1++s2s1++s2 nefunguje nefunguje

PodmPodmínky pro ADTínky pro ADT definice veřejného rozhranídefinice veřejného rozhraní implementace typu není dostupnáimplementace typu není dostupná


ModulyModuly

Definice moduluDefinice modulu module A where -- A.hs, A.lhsmodule A where -- A.hs, A.lhs......

všechny definice jsou viditelnévšechny definice jsou viditelné

Import moduluImport modulu module A wheremodule A whereimport Bimport B......

dovezou se všechny viditelné definicedovezou se všechny viditelné definice


ModulyModuly

Omezení exportuOmezení exportu module module ExprExpr ( printExpr, Expr(..) ) where( printExpr, Expr(..) ) where Expr(..)Expr(..) – exportuje i konstruktory– exportuje i konstruktoryExprExpr – pouze export jm– pouze export jména typuéna typu

Omezení dovozuOmezení dovozu import Expr hidingimport Expr hiding( printExpr )( printExpr ) import qualified Expr -- Expr.printExprimport qualified Expr -- Expr.printExpr import Expr as Vyrazimport Expr as Vyraz -- Vyraz.printExpr -- Vyraz.printExpr


ADT a HaskellADT a Haskell

ADT je definovADT je definován v samostatném moduluán v samostatném modulu

Explicitní export operacíExplicitní export operací

Export pouze jména typu bez konstruktorůExport pouze jména typu bez konstruktorů

module Store module Store

(Store, (Store,

initial, initial, -- Store-- Store

value, value, -- Store -> String -> Int-- Store -> String -> Int

update update -- Store -> String -> Int -> Store-- Store -> String -> Int -> Store

) where) where


Implementace - seznamImplementace - seznam

Definice typuDefinice typudata Store = Sto [(String, Int)]data Store = Sto [(String, Int)]newtype Store = Sto [(String,newtype Store = Sto [(String, Int)]Int)]

Definice operacDefinice operacííinitial initial :: Store:: Storeinitial = Sto []initial = Sto []

value :: Store -> String -> Intvalue :: Store -> String -> Intvalue (Sto []) _ = 0value (Sto []) _ = 0value (Sto ((w,n):sto)) v value (Sto ((w,n):sto)) v | v == w = n| v == w = n | otherwise = value (Sto sto) v| otherwise = value (Sto sto) v

update :: Store -> String -> Int -> Storeupdate :: Store -> String -> Int -> Storeupdate (Sto sto) v n = Sto ((v,n):sto)update (Sto sto) v n = Sto ((v,n):sto)


Implementace - funkceImplementace - funkce

Definice typuDefinice typunewtype Store = Sto (String -> Int)newtype Store = Sto (String -> Int)

Definice operacDefinice operacííinitial initial :: Store:: Storeinitial = Sto (\v -> 0)initial = Sto (\v -> 0)

value :: Store -> String -> Intvalue :: Store -> String -> Intvalue (Sto sto) v = sto vvalue (Sto sto) v = sto v

update :: Store -> String -> Int -> Storeupdate :: Store -> String -> Int -> Storeupdate (Sto sto) v n update (Sto sto) v n = Sto (\w -> if v==w then n else sto w)= Sto (\w -> if v==w then n else sto w)


ObecnObecné principy návrhu ADTé principy návrhu ADT

Identifikace a pojmenování typůIdentifikace a pojmenování typůNeformální popis typůNeformální popis typůSignatury typůSignatury typů Jak vytvořit objekt daného typu?Jak vytvořit objekt daného typu? Jak zjistit, o jaký druh objektu jde?Jak zjistit, o jaký druh objektu jde? Jak se dostaneme ke složkám typu?Jak se dostaneme ke složkám typu? Můžeme provádět transformace objektů?Můžeme provádět transformace objektů? Jak můžeme objekty kombinovat?Jak můžeme objekty kombinovat? Můžeme objekty agregovat?Můžeme objekty agregovat?


ADT ADT FrontaFronta

inicializace: emptyQinicializace: emptyQtest prtest prázdné fronty: isEmptyQázdné fronty: isEmptyQvložení na konec fronty: addQvložení na konec fronty: addQvýběr prvku ze začátku fronty: remQvýběr prvku ze začátku fronty: remQ

module Queuemodule Queue( Queue,( Queue, emptyQ, emptyQ, -- Queue a-- Queue a isEmptyQ, isEmptyQ, -- Queue a -> Bool-- Queue a -> Bool addQ, addQ, -- a -> Queue a -> Queue a-- a -> Queue a -> Queue a remQ remQ -- Queue q -> (a, Queue a)-- Queue q -> (a, Queue a)) where) where


Implementace fronty 1Implementace fronty 1

-- -- vklvkládáme na konec, vybíráme ze začátku seznamuádáme na konec, vybíráme ze začátku seznamu

newtype Queue a newtype Queue a = Qu [a]= Qu [a]

emptyQ = Qu []emptyQ = Qu []

isEmptyQ (Qu q) = empty qisEmptyQ (Qu q) = empty q

addQ x (Qu xs) = Qu (xs++[x])addQ x (Qu xs) = Qu (xs++[x])

remQ q@(Qu xs)remQ q@(Qu xs)| not (isEmptyQ q) = (head xs, Qu (tail | not (isEmptyQ q) = (head xs, Qu (tail xs))xs))| otherwise = error “remQ”| otherwise = error “remQ”


Implementace fronty Implementace fronty 22

-- -- vklvkládáme na začátek, vybíráme z konce seznamuádáme na začátek, vybíráme z konce seznamu

addQ x (Qu xs) = Qu (addQ x (Qu xs) = Qu (x:xsx:xs))

remQ q@(Qu xs)remQ q@(Qu xs)| not (isEmptyQ q) = (last xs, Qu (init | not (isEmptyQ q) = (last xs, Qu (init xs))xs))| otherwise = error “remQ”| otherwise = error “remQ”

slosložžitostitost addQ/remQ addQ/remQ konstantní – konstantní – na začátku seznamuna začátku seznamu lineární – na konci seznamulineární – na konci seznamu


Implementace fronty 3Implementace fronty 3

newtype Queue a newtype Queue a = Qu [a]= Qu [a] [a][a]

emptyQ = Qu [] []emptyQ = Qu [] []

isEmptyQ (Qu [] []) = TrueisEmptyQ (Qu [] []) = True

isEmptyQ _ = FalseisEmptyQ _ = False

addQ x (Qu xs ys) = Qu xs (x:ys)addQ x (Qu xs ys) = Qu xs (x:ys)

remQ (Qu (x:xs) ys) = (x, Qu xs ys)remQ (Qu (x:xs) ys) = (x, Qu xs ys)

remQ (Qu [] ys) = remQ (Qu (reverse ys) [])remQ (Qu [] ys) = remQ (Qu (reverse ys) [])

remQ (Qu [] []) = error “remQ”remQ (Qu [] []) = error “remQ”


ADT Vyhledávací stromADT Vyhledávací strom

module Treemodule Tree( Tree,( Tree, nil, nil, -- Tree a-- Tree a isNil, isNil, -- Tree a -> Bool-- Tree a -> Bool isNode, isNode, -- Tree a -> Bool-- Tree a -> Bool leftSub, leftSub,-- Tree a -> Tree a-- Tree a -> Tree a rightSub, rightSub, -- Tree a -> Tree a-- Tree a -> Tree a treeVal, treeVal,-- Tree a -> a-- Tree a -> a insTree, insTree,-- Ord a => a -> Tree a -> Tree a-- Ord a => a -> Tree a -> Tree a delete, delete, -- Ord a => a -> Tree a -> Tree a-- Ord a => a -> Tree a -> Tree a minTree minTree -- Ord a => Tree a -> Maybe a-- Ord a => Tree a -> Maybe a) where) where


ADT ADT VyhledVyhledávací stromávací strom-- definice typu-- definice typudata Tree a data Tree a = Nil | Node a (Tree a) (Tree a)= Nil | Node a (Tree a) (Tree a)-- konstrukce hodnoty-- konstrukce hodnotynil :: Tree anil :: Tree anil = nilnil = nil-- dotaz na druh objektu-- dotaz na druh objektuisNil :: Tree a -> BoolisNil :: Tree a -> BoolisNil Nil = TrueisNil Nil = TrueisNil _ = FalseisNil _ = False-- -- vvýběr složky objektuýběr složky objektuleftSub :: Tree a -> Tree aleftSub :: Tree a -> Tree aleftSub Nil leftSub Nil = error “leftSub”= error “leftSub”leftSub (Node _ t1 _) = t1leftSub (Node _ t1 _) = t1


ADT Vyhledávací stromADT Vyhledávací strom

-- -- vložení prvku do stromuvložení prvku do stromuinsTree :: Ord a insTree :: Ord a => a -> => a -> Tree a Tree a -> Tree a-> Tree a

insTree val Nil = (Node val Nil Nil)insTree val Nil = (Node val Nil Nil)insTree val (Node v t1 t2)insTree val (Node v t1 t2) | v == val = Node v t1 t2 | v == val = Node v t1 t2 | val > v = Node v t1 (insTree val t2) | val > v = Node v t1 (insTree val t2) | val < v = Node v (insTree val t1) t2 | val < v = Node v (insTree val t1) t2


ADT ADT VVyhledyhledávací stromávací strom

-- -- vyhledání nejmenšího prvku ve stromuvyhledání nejmenšího prvku ve stromuminTree :: Ord a minTree :: Ord a => => Tree a Tree a -> -> MaybeMaybe a a

minTree tminTree t || isNil isNil t = Nothing t = Nothing | isNil t1 = Just v | isNil t1 = Just v | otherwise = minTree t1 | otherwise = minTree t1 where t1 = leftSub t where t1 = leftSub t v = treeVal t v = treeVal t

data Maybe a = Nothing | Just adata Maybe a = Nothing | Just a


ADT Vyhledávací stromADT Vyhledávací strom-- odstran-- odstranění prvku ze stromuění prvku ze stromudelete :: Ord a delete :: Ord a => a -> => a -> Tree a Tree a -> Tree a-> Tree a

delete val delete val (Node v t1 t2)(Node v t1 t2) | val < v = Node v (delete val t1) t2 | val < v = Node v (delete val t1) t2 | val > v = Node v t1 (delete val t2) | val > v = Node v t1 (delete val t2) | isNil t2 = t1 | isNil t2 = t1 | isNil t1 = t2 | isNil t1 = t2 | otherwise = join t1 t2 | otherwise = join t1 t2

join :: Ord a => Tree a -> Tree a -> Tree ajoin :: Ord a => Tree a -> Tree a -> Tree ajoin t1 t2 = Node mini t1 newtjoin t1 t2 = Node mini t1 newt where (Just mini) = minTree t2 where (Just mini) = minTree t2 newt = delete mini t2 newt = delete mini t2


ADT MnožinaADT Množina

Seznam – uspořádaná posloupnostSeznam – uspořádaná posloupnost

Množina – bez uspořádání, bez opakováníMnožina – bez uspořádání, bez opakovánímodule Setmodule Set

( Set,( Set, empty, empty, -- Set a-- Set a inclincl,, -- -- Eq a => Eq a => a -a -> Set a -> Set a> Set a -> Set a makeSet, makeSet, -- Eq a => [a] -> Set a-- Eq a => [a] -> Set a isEmpty, -- Set a -> Bool isEmpty, -- Set a -> Bool inSet, inSet, -- Eq a => Set a -> a -> Bool-- Eq a => Set a -> a -> Bool union, inter, diff, union, inter, diff, -- Eq a => Set a -> Set a -> Set a -- Eq a => Set a -> Set a -> Set a eqSet, subSet,-- Eq a => Set a -> Set a -> Bool eqSet, subSet,-- Eq a => Set a -> Set a -> Bool card card -- Set a -> Int-- Set a -> Int) where) where


ADT ADT MMnonožinažina

ImplementaceImplementace seznam neopakujících se prvkůseznam neopakujících se prvků

newtype Set a newtype Set a = St [a]= St [a] seznam seznam uspouspořádaných prvkůřádaných prvků

lineární složitost vyhledávánílineární složitost vyhledávání vyhledávací stromvyhledávací strom

logaritmická složitost vyhledávánílogaritmická složitost vyhledávání ……



-- zakrytí funkce union-- zakrytí funkce union

import List hiding import List hiding ((unionunion))

-- deklarace instance t-- deklarace instance třídy Eqřídy Eq

instance Eq a instance Eq a => Eq (Set a) where=> Eq (Set a) where (==) = eqSet (==) = eqSet

-- definice typu-- definice typu

newtypenewtype SetSet a a = St [a]= St [a]



-- konstruktory-- konstruktory

empty :: Set aempty :: Set aemptyempty = St [] = St []

incl :: Eq a => incl :: Eq a => a -a -> Set a -> Set a> Set a -> Set a

incl x (St st) = St (incl1 x st)incl x (St st) = St (incl1 x st) where incl1 x [] = [x] where incl1 x [] = [x] incl1 x s@(y:ys) incl1 x s@(y:ys) | x == y = s | x == y = s | otherwise = y : (incl1 x ys) | otherwise = y : (incl1 x ys)

makeSet :: makeSet :: Eq a Eq a => [a] -> Set a=> [a] -> Set amakeSet [] = emptymakeSet [] = emptymakeSet (x:xs) = incl x (makeSet xs)makeSet (x:xs) = incl x (makeSet xs)


ADTADT Relace Relace

Binární relace na množině A:Binární relace na množině A:podmnožina kartézského součinu (A x A)podmnožina kartézského součinu (A x A)

MnoMnožina uspořádaných dvojic žina uspořádaných dvojic (x,y)(x,y)(AxA)(AxA)type Relation a type Relation a = Set (a,a)= Set (a,a)

11 22 33

11 XX XX

22 XX

33 XX

11

22

33


ADT ADT RRelaceelace

Kompozice relacKompozice relacíí (x1, x2)(x1, x2)R1, (x2, x3)R1, (x2, x3)R2 -> (x1,x3)R2 -> (x1,x3)R2R2R1R1 compose r2 r1 =compose r2 r1 = [(x1,x3) | (x1, x2) <- r1, [(x1,x3) | (x1, x2) <- r1, (x2’,x3) <- r2, (x2’,x3) <- r2, x2 == x2’] x2 == x2’]

Mocnina relaceMocnina relace rr1 1 = r, r= r, rn+1n+1 = r = r r rnn

pow 1 r = rpow 1 r = rpow (n+1) r = compose r (pow n r)pow (n+1) r = compose r (pow n r)


ADT ADT RRelaceelace

Vlastnosti relace R Vlastnosti relace R U UUU reflexivita:reflexivita:

x x U . (x,x) U . (x,x) R R symetriesymetrie

x,y . (x,y) x,y . (x,y) R R (y,x) (y,x) R R tranzitivitatranzitivita

x,y,z . (x,y)x,y,z . (x,y)R R (y,z) (y,z)R R (x,z) (x,z)RR

Pozor! Pozor! isReflexive :: Eq a => Rel a => Set a => BoolisReflexive :: Eq a => Rel a => Set a => BoolisReflexive r u = and [inSet (x,x) r | x <- u]isReflexive r u = and [inSet (x,x) r | x <- u]


Úkoly na procvičeníÚkoly na procvičení

Definujte abstraktní datový typ Stack Definujte abstraktní datový typ Stack reprezentující zásobník s operacemireprezentující zásobník s operacemi push push :: a -> Stack a -> Stack a:: a -> Stack a -> Stack a pop :: Stack a -> Stack apop :: Stack a -> Stack a top :: Stack a -> atop :: Stack a -> a isEmpty :: Stack a ->BoolisEmpty :: Stack a ->Bool

Definujte abstraktní datový typ Deque Definujte abstraktní datový typ Deque reprezentující oboustranně ukončenou frontu s reprezentující oboustranně ukončenou frontu s operacemioperacemi addFirst, addLastaddFirst, addLast removeFirst, removeLastremoveFirst, removeLast ……

abstraktn í datové typy

Documents