Estructuras de Datos. Dr. Pablo E. Fidel Martínez López Lic. en Ciencias de la Computación UNR

Transcripción

1 Estructuras de Datos Dr. Pablo E. Fidel Martínez López Lic. en Ciencias de la Computación UNR

2 ...but note that an implementation need not be actualized as code a concrete design is sufficient. Chris Okasaki Purely Functional Data Structures

3 Abstracción de datos Abstracción de datos Metodología que separa cómo se usa un dato compuesto de cómo se implementa. El programa se estructura para usar los datos no haciendo más suposiciones de las necesarias. La barrera de abstracción separa el nivel de uso, el nivel de implementación, y provee una interfase entre ambos niveles.

4 Abstracción de datos Las barreras de abstracción inducen tres vistas de las estructuras de datos La visión del diseñador La visión del usuario/programador La visión del implementador Es imprescindible saber seperarlas para comprender y manejar correctamente la abstracción de datos

5 Abstracción de datos Para especificar un tipo de datos debemos Especificar los constructores y selectores. Establecer las condiciones que deben cumplir. A veces se agregan restricciones de eficiencia. Existen dos maneras de hacer esto modelos abstractos (Hoare, 1972) Métodos y condiciones basados en otros modelos previos especificaciones algebraicas (Goguen,Tatcher,Wagner,Wright, 1978) Sistemas algebraicos abstractos con axiomas

6 Abstracción de datos Ejemplo: números racionales Rational makerat :: Integer -> Integer -> Rational numer :: Rational -> Integer denom :: Rational -> Integer si x es (makerat n d), entonces (numer x)/(denom x) = n/d

7 Implementando tipos abstractos Números racionales: implementación 1 Usando pares, sin preprocesamiento makerat n d = (n, d) numer r = fst r denom r = snd r No representa a un racional de manera única

8 Implementando tipos abstractos Números racionales: implementación 2 Usando pares, con preprocesamiento al construir makerat n d = let g = gcd n d in (n/g, d/g) numer r = fst r denom r = snd r Cada racional está representado de manera única

9 Implementando tipos abstractos Números racionales: implementación 3 Usando pares, con preprocesamiento al acceder makerat n d = (n, d) numer r = let g = gcd (fst r) (snd r) in fst r / g denom r = let g = gcd (fst r) (snd r) in snd r / g

10 Implementando tipos abstractos Números racionales: implementación 4 Usando pares, con preprocesamiento mixto makerat n d = let g = gcd n d in ((n, d), g)) numer r = fst (fst r) / snd r denom r = snd (fst r) / snd r

11 Implementando tipos abstractos Números racionales: implementación 5 Sin usar pares makerat n d = 2^n + 3^d numer r = factor 2 r denom r = factor 3 r factor k m = if m >= k && divide k m then 1 + factor k (m `div` k) else 0 divide k m = m `mod` k == 0 No funciona para números negativos...

12 Implementando tipos abstractos Propiedades Toda implementación satisface la especificación Una implementación específica satisface otras propiedades adicionales Obligaciones NO SE DEBEN usar estas propiedades adicionales SÓLO DEBEN usarse las propiedades especificadas Ejemplo: Cuál es el valor de (fst (makerat n d))? Tiene sentido esta expresión?

13 Implementando tipos abstractos NO SE DEBEN usar propiedades adicionales Pueden ser difíciles de identificar! Ejemplo: if numer r1 == numer r2 then 0 else 1 Da lo mismo en toda implementación? La propiedad de igualdad de numeradores NO ES consecuencia de la especificación. Entonces, NO DEBE usarse. Esta propiedad NO SE PUEDE ocultar. Hay formas de violar un TAD hasta en el mejor lenguaje!

14 Implementando tipos abstractos Qué propiedades se usan es cuestión de disciplina por parte del programador Sin embargo, un buen lenguaje provee mecanismos para garantizar la disciplina Ocultamiento de información Módulos, procedimientos locales, objetos con métodos privados, compilación separada, packages, etc. NO DEBE CONFUNDIRSE ocultar información con abstraer datos!

15 Implementando tipos abstractos Pilas Misma signatura que las listas! Stack a empty :: Stack a push :: a -> Stack a -> Stack a top :: Stack a -> a pop :: Stack a -> Stack a isempty :: Stack a -> Bool top (push x p) = x pop (push x p) = p isempty empty = True isempty (push x p) = False (top empty) y (pop empty) no están definidos

16 Implementando tipos abstractos Pilas Implementación con listas empty = [] push = (:) top = head pop = tail isempty = isnil Equivalentemente... empty = [ ] push a s = a : s top s = head s pop s = tail s isempty s = isnil s

17 Implementando tipos abstractos Deben probarse las propiedades especificadas (top empty) no está definido top empty = head [], por lo que no está definido top (push x p) = x top (push x p) = head (x : p) = x (pop empty) no está definido pop empty = tail [ ], por lo que no está definido pop (push x p) = p pop (push x p) = tail (x : p) = p isempty empty = True isempty empty = isnil [] = True isempty (push x p) = False isempty (push x p) = isnil (x : p) = False

18 Implementando tipos abstractos Calcular el costo de las operaciones Definición muy simple El costo de cada operación es 1 más el costo de la operación correspondiente de listas Cada operación de listas tiene costo constante Por lo tanto CADA OPERACIÓN tiene costo de peor caso O(1)

19 Implementando tipos abstractos Colas Otra estructura con acceso restringido Queue a emptyq :: Queue a queue :: Queue a -> a -> Queue a firstq :: Queue a -> a dequeue :: Queue a -> Queue a isemptyq :: Queue a -> Bool isemptyq emptyq = True Y condiciones sobre isemptyq (queue q x) = False operaciones no definidas firstq (queue emptyq x) = x firstq (queue (queue q y) x) = firstq (queue q y) dequeue (queue emptyq x) = emptyq dequeue (queue (queue q y) x) = queue x (dequeue (queue q y))

20 Implementando tipos abstractos Colas Implementación con listas emptyq = [ ] queue = snoc firstq = head dequeue = tail isemptyq = isnil snoc xs x = xs ++ [ x ]

21 Implementando tipos abstractos Propiedades de las colas isemptyq emptyq = True isemptyq emptyq = isnil [] = True isemptyq (queue q x) = False isemptyq (queue q x) = isnil (snoc q x) = isnil (q ++ [ x ]) Probamos que isnil (q ++ (x : xs)) = False para cualquier xs por recursión sobre la forma de la lista q Si q = [] isnil ([ ] ++ (x : xs)) = isnil (x : xs) = False Si q = snoc q' x' isnil ((q' ++ [ x' ]) ++ (x : xs)) = isnil (q' ++ (x' : (x : xs))) (por HI) = False

22 Implementando tipos abstractos Propiedades de las colas (cont. 2) (firstq emptyq) no está definido firstq emptyq = head nil, por lo que no está definido firstq (queue emptyq x) = x firstq (queue emptyq x) = head (snoc [] x) = head ([] ++ [ x ]) = head [ x ] = x firstq (queue (queue q y) x) = firstq (queue q y) firstq (queue (queue q y) x) = head (snoc (snoc q y) x) = head (snoc q y) = firstq (queue q y) Probar que head (snoc (snoc q y) x) = head (snoc q y) por inducción en la estructura de la lista q Observar que se demuestra usando propiedades de la representación!

23 Implementando tipos abstractos Propiedades de las colas (cont. 3) (dequeue emptyq) no está definido dequeue emptyq = tail [], por lo que no está definido dequeue (queue emptyq x) = emptyq dequeue (queue emptyq x) = tail (snoc [] x) = tail ([] ++ [ x ]) = tail [ x ] = [] = emptyq dequeue (queue (queue q y) x) = queue x (dequeue (queue q y)) dequeue (queue (queue q y) x) = tail (snoc (snoc q y) x) = snoc (tail (snoc q y)) x = queue (dequeue (queue q y)) x Probar que tail (snoc (snoc q y) x) = snoc (tail (snoc q y) por inducción en la estructura de la lista q En algunas presentaciones se usan funciones de abstracción y representación explícitas

24 Implementando tipos abstractos Colas: costo de las operaciones Salvo queue, las demás son O(1) El costo de queue es el costo de snoc que depende del costo de append En una implementación algebraica de listas, el costo de append es O(n), siendo n la longitud de xs En una implementación imperativa, tanto snoc como append se pueden implementar en O(1) Hay otras implementaciones funcionales... snoc xs x = xs ++ [ x ]

25 Implementando tipos abstractos Colas Implementación con dos listas Invariante de representación: (fst q) es [] sólo cuando (snd q) es [] emptyq = ([], []) queue q x = check (fst q) (x : snd q) firstq q = head (fst q) dequeue q = check (tail (fst q)) (snd q) isemptyq q = isnil (fst q) check [] r = (reverse r, []) check f r = (f, r)

26 Implementando tipos abstractos Propiedades de las colas isemptyq emptyq = True isemptyq emptyq = isnil (fst ([ ], [ ]))) = (isnil [ ]) = True isemptyq (queue q x) = False isemptyq (queue q x) = isnil (fst (check (fst q) (x : snd q))) Análisis por casos: fst q = [ ] (y entonces, (snd q) = [ ], por el invariante) = isnil (fst (reverse (x : snd q), [ ])) = isnil (reverse [ x ]) = isnil [ x ] = False fst q <> nil = isnil (fst (fst q, x : snd q)) = isnil (fst q) = False

27 Implementando tipos abstractos Propiedades de las colas (cont. 2) (firstq emptyq) no está definido firstq emptyq = head (fst ([ ], [ ])) = head [ ], no está definido firstq (queue emptyq x) = x firstq (queue emptyq x) = head (fst (check [ ] [ x ])) = head (fst (check [ ] [ x ])) = head [ x ] = x El resto, de ejercicio

28 Implementando tipos abstractos Colas: costo de las operaciones emptyq, firstq, isemptyq y queue son O(1) dequeue depende de check check es peor caso O(n) Sin embargo, se puede hacer otro análisis COSTO AMORTIZADO Se mide el costo de una sequencia de operaciones en lugar de medir el costo de cada una Así, todas las operaciones de esta implementación tienen costo amortizado O(1)

29 TADs en Haskell Cómo expresamos TADs en Haskell? Mediante MÓDULOS Un módulo Permite agrupar definiciones relacionadas Modularidad Es la unidad de compilación ( no en Hugs!) Compilación separada Limita el scope (alcance) de las variables Reuso de nombres Permite exportación e importación explícita Ocultación de información

30 TADs en Haskell Ejemplo: de agrupación de funciones Así todo el tipo es visible! module Complejos (Complex(..), realpart, imagpart, mkpolar) where data Complex = C Float Float realpart, imagpart :: Complex -> Float realpart (C r i) = r imagpart (C r i) = i...

31 TADs en Haskell Ejemplo: de ocultación de información Así la implementación está oculta! module Racionales (Rational, makerat, numer, denom) where data Rational = R Float Float makerat n r = reduce (n * signo d) (abs d) reduce x 0 = error Racional con denom. 0 reduce x y = R (x `quot` d) (y `quot` d) where d = gcd x y... Esta función no es visible para los usuarios

32 TADs en Haskell Cómo se utiliza un módulo? Mediante la cláusula import module Main where import Complejos import Racionales (Rational, makerat) mipar :: (Complex, Rational) mipar = (C 1 0, makerat 4 2) -- (numerador (snd mipar)) está permitido? -- Y (reduce (R 4 2))? Por qué?

33 TADs en otros lenguajes En general los lenguajes no proveen TADs, sino ocultación de información Como vimos, la idea de TAD es transversal a esta noción En lenguajes imperativos Módulos, APIs, etc. En lenguajes orientados a objetos Clases, interfases Lo importante es distinguir entre la especificación del TAD, y su implementación

34 Tipos algebraicos como TADs Recordemos que para un tipo algebraico (TAlg) Se determina la forma de sus elementos Se provee un mecanismo único de acceso a ellos Los TAlgs son más sencillos para razonar e implementar que los TADs Todo TAlg puede definirse como TAD Operaciones constructoras Operaciones de acceso o inspección

35 Tipos algebraicos como TADs Ejemplo: listas (versión 1) Lista a Nil :: Lista a Cons :: a -> Lista a -> Lista a isnil :: Lista a -> Bool hd :: Lista a -> a tl :: Lista a -> Lista a hd (Cons x xs) = x tl (Cons x xs) = xs isnil Nil = True isnil (Cons x xs) = False (hd Nil) y (tl Nil) no están definidos } Constructores } Funciones de acceso

36 Tipos Algebraicos como TADs Observaciones los constructores, con mayúsculas (convención) las funciones de acceso deben contemplar TODAS las partes a acceder Para especificar el comportamiento, basta dar una ecuación por cada combinación función de acceso/constructor Si hay casos no definidos, se agregan funciones que determinen el dominio de tales operaciones

37 Tipos Algebraicos como TADs Pattern matching Acceso genérico a un tipo algebraico Notación alternativa a las funciones de acceso Dependiendo del lenguaje se escribe diferente En Haskell, se usa la expresión case Pero el pattern matching es primitivo En lenguajes imperativos se puede usar otra versión de las funciones de acceso, más parecida al pattern matching

38 Tipos Algebraicos como TADs Pattern matching, ejemplo 1 Equivalencia entre la notación Haskell y el uso de funciones de acceso tradicionales y lenght xs = case xs of Nil -> 0 Cons y ys -> 1 + length ys lenght xs = if (isnil xs) then 0 else let y = hd xs; ys = tl xs in 1 + length ys son equivalentes (salvo detalles en el orden de reducción)

39 Tipos algebraicos como TADs Ejemplo: listas (versión 2; matching en imperativo) Lista a Nil :: Lista a Cons :: a -> Lista a -> Lista a matchnil :: Lista a -> Bool matchcons :: Lista a -> (Bool, (a, Lista a)) matchnil Nil = True matchnil (Cons x xs) = False fst (matchcons Nil) = False snd (matchcons Nil) no está definido cuando el fst da False matchcons (Cons x xs) = (True, (x, xs))

40 Tipos Algebraicos como TADs Posible implementación imperativa en C struct LIBase; typedef LIBase* ListInt; typedef struct LIBase { int head; ListInt tail; } LIBase; ListInt nil() { return NULL; } ListInt cons (int x, ListInt xs) { ListInt ys = (ListInt)malloc(sizeof(LIBase)); ys->head = x; ys->tail = xs; return ys; } bool matchnil (ListInt xs) { return (xs == NULL); } bool matchcons (ListInt ys, int x, ListInt xs) { bool retval = (ys == NULL); // o: bool retval = matchnil(ys); if (retval) { x = ys->head; xs = ys->tail; } return retval; } NO HACE ADMINISTRACIÓN DE MEMORIA!

41 Tipos Algebraicos como TADs Pattern matching, ejemplo 2 Equivalencia entre la notación Haskell y el uso de funciones de matching imperativas lenght xs = case xs of Nil -> 0 Cons y ys -> 1 + length ys y int lenght(listint xs) { int y; ListInt ys; if (matchcons(xs, y, ys)) { return 0; } else { return (1 + length(ys)); } } son equivalentes (salvo detalles en el orden de reducción)

42 Tipos Algebraicos como TADs Valores que pueden no estar... Maybe a Nothing :: Maybe a Just :: a -> Maybe a isnothing :: Maybe a -> Bool fromjust :: Maybe a -> a isnothing Nothing = True isnothing (Just x) = False fromjust (Just x) = x (fromjust Nothing) no está definido

43 Tipos Algebraicos como TADs Se puede hacer lo mismo con cualquier TAlg Ej: árboles de todo tipo binarios, tip, generales, etc. Hay que tener cuidado con la elección de las funciones de acceso el uso de las mismas pues puede violarse la abstracción, o la naturaleza algebraica

44 Ejercicio Implementar el tipo de datos abstracto IntSet single :: Integer -> IntSet insert :: IntSet -> Integer -> IntSet min :: IntSet -> Integer min (single x) = x min (insert s x) = if (min s) > y then y else (min s) TODAS LAS OPERACIONES O(1) en peor caso