Ejemplos de TAD (tipos simples)

Transcripción

1 ESPECIFICACIÓN BOOLEANOS TAD booleano Ejemplos de TAD (tipos simples) T : booleano { valor cierto } F : booleano { valor falso } : booleano booleano : booleano, booleano booleano : booleano, booleano booleano x, y : booleano T == F F == T x y == y x { conmutatividad } x y == y x F x == F ; T T == T { tablas de verdad } T x == T ; F F == F ESPECIFICACIÓN NATURALES1 (BOOLEANOS) TAD natural 0 : natural suc : natural natural { siguiente número natural } +, * : natural, natural natural = : natural, natural booleano x, y : natural x + 0 == x { axiomas de Peano } x * 0 == 0 x + suc(y) == suc(x + y) x * suc(y) == (x * y) + x 0 = 0 == T 0 = suc(x) == F ; suc(x) = 0 == F suc(x) = suc(y) == x = y UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 1

2 ESPECIFICACIÓN NATURALES2 (NATURALES1) : natural, natural booleano >,, < : natural, natural booleano x, y : natural 0 x == T suc(x) 0 == F suc(x) suc(y) == x y x > y == (x y) x y == (x > y) (x = y) x < y == (x y) ESPECIFICACIÓN NATURALES3 (NATURALES2) - : natural, natural natural div : natural, natural natural { Cociente } mod : natural, natural natural { Resto } mcd : natural, natural natural { Máximo común divisor } x, y : natural x - y x y x div y y 0 x mod y y 0 x - 0 == x suc(x) - suc(y) == x - y (x < y) x div y == 0 (x y) x div y == (x-y) div y (x < y) x mod y == x (x y) x mod y == (x-y) mod y mcd(x, 0) == x mcd(x, x) == x mcd(x, y) == mcd(y, x) mcd(x, y) == mcd(y, x mod y) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 2

3 TADs de Parámetros ESPECIFICACIÓN EQUIVALENCIA (BOOLEANOS) TAD equivalente = : equivalente, equivalente booleano : equivalente, equivalente booleano x, y, z : equivalente x = x == T { Reflexividad } x = y == y = x { Simetría } (x = y) (y = z) == x = z { Transitividad } x y == (x = y) ESPECIFICACIÓN COMPARABLE (EQUIVALENCIA) TAD comparable equivalente : comparable, comparable booleano, <, > : comparable, comparable booleano x, y, z : comparable x x == T { Reflexividad } (x y) (y x) == x = y { Antisimetría } (x y) (y z) == x z { Transitividad } x > y == (x y) x y == (x > y) (x = y) x < y == (x y) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 3

4 TAD Vector ESPECIFICACIÓN VECTOR (NATURALES1, COMPARABLE) TAD vector [indice comparable, elemento] crear : natural vector { Crea un vector no asignado tamaño : vector natural con índices 1..n } asignado : vector, indice booleano asignar : vector, indice, elemento vector valor : vector, indice elemento v : vector ; n : natural ; i, j : indice ; x, y : elemento [P1] asignar( v, i, x ) 1 i tamaño(v) [P2] valor( v, i ) (1 i tamaño(v)) asignado( v, i ) [E1] asignar( asignar(v, i, x), i, y ) == asignar(v, i, y) [E2] ( i j ) asignar( asignar(v, i, x), j, y ) == asignar( asignar(v, j, y), i, x ) [E3] valor( asignar(v, i, x), i ) == x [E4] ( i j ) valor( asignar(v, i, x), j ) == valor(v, j) [E5] asignado( asignar(v, i, x), i ) == T [E6] ( i j ) asignado( asignar(v, i, x), j ) == asignado(v, j) [E7] asignado( crear(n), i ) == F [E8] tamaño( crear(n) ) == n [E9] tamaño( asignar(v,i,x) ) == tamaño(v) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 4

5 TAD Colección y Conjunto ESPECIFICACION COLECCION (NATURALES1, EQUIVALENCIA) TAD coleccion[elemento equivalente] crear_coleccion : coleccion { colección vacía } añadir : coleccion, elemento coleccion { añadir elemento } quitar : coleccion, elemento coleccion { quitar todos los elementos iguales } cuantos_hay : coleccion, elemento natural { contar elementos iguales } c : colección x, y : elemento quitar( crear_coleccion, x ) == crear_coleccion quitar( añadir(c, x), x ) == quitar(c, x) (x y) quitar( añadir(c, x), y ) == añadir( quitar(c, y), x ) cuantos_hay( crear_coleccion, x ) == 0 cuantos_hay( añadir(c, x), x ) == 1 + cuantos_hay(c, x) (x y) cuantos_hay( añadir(c, x), y ) == cuantos_hay(c, x) ESPECIFICACIÓN CONJUNTO (EQUIVALENCIA) TAD conjunto[elemento equivalente] crear_conjunto : conjunto { conjunto vacío } añadir : conjunto, elemento conjunto { incluir elemento } quitar : conjunto, elemento conjunto { excluir elemento } pertenece : conjunto, elemento booleano { pertenencia de elemento } c : conjunto x, y : elemento quitar( crear_conjunto, x ) == crear_conjunto quitar( añadir(c, x), x ) == quitar(c, x) (x y) quitar( añadir(c, x), y ) == añadir( quitar(c, y), x ) pertenece( crear_conjunto, x ) == F pertenece( añadir(c, x), x ) == T (x y) pertenece( añadir(c, x), y ) == pertenece(c, x) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 5

6 TAD Lista (Especificación básica Bicola) ESPECIFICACIÓN LISTA_BASICA (NATURALES1) TAD lista[elemento] [ ] : lista { lista vacía } [ ] : elemento lista { lista unitaria } ++ : lista, lista lista { concatenar listas } >> : elemento, lista lista { insertar al principio } << : lista, elemento lista { insertar al final } tamaño : lista natural { número de elementos } esta_vacía : lista booleano primero, ultimo : lista elemento { acceso } quita_primero, quita_ultimo : lista lista { borrado } l, l1, l2 : lista; x : elemento primero( l ) esta_vacía( l ) ultimo( l ) esta_vacía( l ) quita_primero( l ) esta_vacía( l ) quita_ultimo( l ) esta_vacía( l ) [ ] ++ l == l ( x >> l1 ) ++ l2 == x >> ( l1 ++ l2 ) l << x == l ++ [ x ] [ x ] == x >> [ ] tamaño( [ ] ) == 0 tamaño( x >> l ) == 1 + tamaño( l ) primero( x >> l ) == x quita_primero( x >> l ) == l ultimo( x >> [ ] ) == x ultimo( x >> (y >> l) ) == ultimo( y >> l ) quita_ultimo( x >> [ ] ) == [ ] quita_ultimo( x >> (y >> l) ) == x >> quita_ultimo( y >> l ) esta_vacía( [ ] ) == T esta_vacía( x >> l ) == F UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 6

7 TAD Lista (acceso por índice) ESPECIFICACIÓN LISTA_INDEXADA (LISTA_BASICA) TAD lista_ind[elemento] : lista_ind, natural elemento { acceso a elemento } insertar : lista_ind, natural, elemento lista_ind { insertar( l, i, x i == x } cambiar : lista_ind, natural, elemento lista_ind { cambiar( l, i, x i == x } quitar : lista_ind, natural lista_ind concatenar : lista_ind, lista_ind lista_ind l, l1, l2 : lista_ind ; x, y : elemento ; i : natural i 1 i tamaño( l ) insertar( l, x, i ) 1 i tamaño( l ) cambiar( l, x, i ) 1 i tamaño( l ) quitar( l, i ) 1 i tamaño( l ) ( x >> l 1 == x ( i > 1 ) ( x >> l i == ( i - 1 ) insertar( l, 1, x ) == x >> l ( i > 1 ) insertar( y >> l, i, x ) == y >> insertar( l, i - 1, x ) cambiar( y >> l, 1, x ) == x >> l ( i > 1 ) cambiar( y >> l, i, x ) == y >> cambiar( l, i - 1, x ) quitar( x >> l, 1 ) == l ( i > 1 ) quitar( x >> l, i ) == x >> quitar( l, i - 1 ) concatenar(l1, l2) == l1 ++ l2 UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 7

8 TAD Lista (acceso por cursor) ESPECIFICACIÓN LISTA_CURSOR (LISTA_BASICA) TAD lista_cur[elemento] crear_lc : lista_cur { lista-cursor vacía } : lista, lista lista_cur { una lista-cursor consta de dos lista basicas } fin_de_lista : lista_cur booleano { cursor fuera de la lista } actual : lista_cur elemento { acceso a elemento actual } ir_a_siguiente : lista_cur lista_cur { elemento actual pasa a ser el siguiente } ir_a_inicial : lista_cur lista_cur { elemento actual pasa a ser el primero } insertar : lista_cur, elemento lista_cur { inserta despues del actual y pasa al siguiente } cambiar : lista_cur, elemento lista_cur { cambia el elemento actual y pasa al siguiente } quitar : lista_cur lista_cur { borra el elemento actual y pasa al siguiente } concatenar : lista_cur, lista_cur lista_cur { une dos listas, una despues de la otra } l : lista_cur ; l1, l2 : lista ; x, y : elemento; actual( l ) fin_de_lista( l ) cambiar( l ) fin_de_lista( l ) quitar( l ) fin_de_lista( l ) crear_lc == [ ] [ ] fin_de_lista( l1 [ ] ) == T fin_de_lista( l1 (x >> l2) ) == F actual( l1 (x >> l2) ) == x ir_a_siguiente( l1 [ ] ) == l1 [ ] ir_a_siguiente( l1 (x >> l2) ) == (l1 << x) l2 ir_a_inicial( l1 l2 ) == [ ] (l1 ++ l2) insertar( l1 [ ], x ) == l1 [ x ] insertar( l1 (y >> l2), x ) == (l1 << y) (x >> l2) cambiar( l1 (y >> l2), x ) == (l1 << x) l2 quitar( l1 (x >> l2) ) == l1 l2 concatenar( l1 l2, l3 l4 ) == (l1 ++ l2) (l3 ++ l4) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 8

9 TAD Lista ordenada (acceso por índice) ESPECIFICACIÓN LISTA_ORDENADA (COMPARABLE) TAD lista_ord[elemcomp comparable] crear_lisord : lista_ord { crear lista vacía } tamaño : lista_ord natural { número de elementos : lista_ord, natural elemcomp { acceso a elemento } insertar : lista_ord, elemcomp lista_ord { insertar en orden } cambiar : lista_ord, natural, elemcomp lista_ord { cambiar elem. en posición } quitar : lista_ord, natural lista_ord { quitar elem. en posición } fusionar : lista_ord, lista_ord lista_ord OCULTO >> : elemcomp, lista_ord lista_ord { inserción al principio } l, l1, l2 : lista_ord ; x, y : elemcomp ; i : natural i 1 i tamaño( l ) insertar( l, x, i ) 1 i tamaño( l ) cambiar( l, x, i ) 1 i tamaño( l ) quitar( l, i ) 1 i tamaño( l ) tamaño( crear_lisord ) == 0 tamaño( x >> l ) == 1 + tamaño( l ) ( x >> l 1 == x ( i > 1 ) ( x >> l i == ( i - 1 ) quitar( x >> l, 1 ) == l ( i > 1 ) quitar( x >> l, i ) == x >> quitar( l, i - 1 ) cambiar( l, i, x ) == insertar( quitar( l, i ), x ) insertar( [ ], x ) == x >> [ ] (x < y) insertar( y >> l, x ) == x >> (y >> l) (x y) insertar( y >> l, x ) == y >> insertar(l, x) fusionar( l, [ ] ) == l fusionar( [ ], l ) == l (x y) fusionar( x >> l1, y >> l2 ) == x >> fusionar( l1, y >> l2 ) (x > y) fusionar( x >> l1, y >> l2 ) == y >> fusionar( x >> l1, l2 ) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 9

10 Operaciónes de búsqueda en listas ESPECIFICACIÓN BUSQLIS (LISTA_INDEXADA, LISTA_CURSOR, LISTA_ORDENADA) { Aunque tienen el mismo nombre son operaciones distintas porque se aplican a TADs diferentes (sus parámetros son de tipos distintos). La búsqueda en listas indexadas y ordenadas devuelven la posición del primer elemento igual o un indice fuera de rango (mayor que el tamaño de la lista) si no existe ningún elemento igual. La búsqueda en listas basadas en cursor situa el cursor sobre el primer elemento igual o sobre el final de la lista si no existe. } buscar : lista_ind, elemento natural buscar : lista_cur, elemento lista_cur buscar : lista_ord, elemcomp natural l1, l2 : lista ; li : lista_ind ; lo : lista_ord ; x, y : elemento; u,v : elemcomp { --- Lista indexada --- } buscar( [ ], x ) == 1 buscar( x >> li, x ) == 1 (x y) buscar( y >> li, x ) == 1+ buscar( li, x ) { --- Lista basada en cursor --- } buscar( l1 [ ], x ) == l1 [ ] buscar( l1 (x >> l2), x ) == l1 (x >> l2) (x y) buscar( l1 (x >> l2), y ) == buscar( (l1 << x) l2, y) { --- Lista ordenada --- } buscar( crear_lisord, u ) == 1 buscar( u >> lo, u ) == 1 (u v) buscar( v >> lo, u ) == 1+ buscar( lo, u ) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 10

11 TAD Pila y Cola ESPECIFICACIÓN PILA Y COLA (BOOLEANOS) TAD pila[elemento] TAD cola[elemento] { --- Operaciones de pila --- } crear_pila : pila vacía : pila booleano añadir : pila, elemento pila cima : pila elemento { Último elemento añadido } quitar : pila pila { Elimina elemento cima } { --- Operaciones de cola --- } crear_cola : cola vacía : cola booleano añadir : cola, elemento cola cabeza : cola elemento { Primer elemento añadido } quitar : cola cola { Elimina elemento cabeza } p : pila; c : cola ; x : elemento cima(p) vacía(p) quitar(p) vacía(p) cabeza(c) vacía(c) quitar(c) vacía(c) { --- Pila --- } vacía( crear_pila ) == T vacía( añadir(p, x) ) == F cima( añadir(p, x) ) == x quitar( añadir(p, x) ) == p { --- Cola --- } vacía( crear_cola ) == T vacía( añadir(c, x) ) == F cabeza( añadir( crear_cola, x ) ) == x vacía(c) cabeza( añadir(c, x) ) == cabeza(c) quitar( añadir( crear_cola, x ) ) == crear_cola vacía(c) quitar( añadir(c, x) ) == añadir( quitar(c), x ) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 11

12 TAD Cola de prioridad ESPECIFICACIÓN COLA PRIORIDAD (COMPARABLE) TAD colapri[elemcomp comparable] crear_cp : colapri { Crear cola vacía } vacía : colapri booleano minimo : colapri elemcomp { Elemento mínimo } añadir : colapri, elemcomp colapri { Añadir elemento } quitar : colapri colapri { Elimina el elemento mínimo } { --- Operaciones auxiliares --- } min_aux : cola_pri, elemcomp colapri { Obtención del valor mínimo } quitar_aux : cola_pri, elemcomp colapri { Quitar elemento igual } : elemcomp, cola_pri booleano { Pertenencia } c : colapri ; x, y: elemento minimo(c) vacía(c) quitar(c) vacía(c) cambiar(c, x) vacía(c) min_aux(c, x) vacía(c) quitar_aux(c, x) x c vacía( crear_cp ) == T vacía( añadir(c, x) ) == F minimo( añadir(c, x) ) == min_aux(c, x) min_aux( crear_cp, x ) == x (x < y) min_aux( añadir(c, x), y ) == min_aux(c, x) (x y) min_aux( añadir(c, x), y ) == min_aux(c, y) quitar(c) == quitar_aux( c, minimo(c) ) quitar_aux( añadir(c, x), x ) == c (x y) quitar_aux( añadir(c, y), x ) == añadir( quitar_aux(c, x), y ) x crear_cp == F x añadir(c, x) == T (x y) x añadir(c, y) == x c UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 12

13 TAD Tabla (un elemento por clave) ESPECIFICACION TABLA (EQUIVALENCIA) TAD tabla[clave equivalente, elemento] crear_tabla : tabla { creación de una tabla vacía } añadir : tabla, clave, elemento : tabla { inserción y modificación } quitar : tabla, clave tabla { borrado de clave } presente : tabla, clave booleano { existencia de par clave-elemento } valor : tabla, clave elemento { acceso a elemento } t : tabla ; k, k1, k2 : clave ; v : elemento valor(t, k) presente(t, k) quitar( crear_tabla, k ) == crear_tabla quitar( añadir(t, k, v), k ) == quitar( t, k ) ( k1 k2 ) quitar( añadir( t, k1, v ), k2 ) == añadir( quitar( t, k2 ), k1, v ) presente( crear_tabla, k ) == F presente( añadir(t, k, v), k ) == T ( k1 k2 ) presente( añadir(t, k1, v), k2 ) == presente(t, k2) { Si existen varias operaciones de añadir sobre la misma clave sólo se tiene en cuenta la más reciente } valor( añadir(t, k, v), k ) == v ( k1 k2 ) valor( añadir(t, k1, v), k2 ) == valor(t, k2) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 13

14 TAD Diccionario (varios elementos por clave) ESPECIFICACIÓN DICCIONARIO (LISTA_BASICA) TAD diccionario[clave equivalente, elemento equivalente] crear_dic : diccionario { creación de un diccionario vacío } añadir : diccionario, clave, elemento diccionario { inserción } borrar : diccionario, clave diccionario { borrado de todos los elementos asociados a la misma clave } quitar : diccionario, clave, elemento diccionario { borrado de elemento concreto } valor : diccionario, clave lista[elemento] { lista de valores asoc. a clave } d : diccionario ; k, k1, k2 : clave ; v, v1, v2 : elemento borrar( crear_dic, k ) == crear_dic borrar( añadir(d, k, v), k ) == borrar(d, k) ( k1 k2 ) borrar( añadir(d, k1, v), k2 ) == añadir( borrar(d, k2), k1, v ) quitar(crear_dic, k, v) == crear_dic ( k1 k2 ) quitar( añadir(d, k1, v1), k2, v2 ) == añadir( quitar(d, k2, v2), k1, v1 ) quitar( añadir(d, k, v), k, v ) == quitar(d, k, v) ( v1 v2 ) quitar( añadir(d, k, v1 ), k, v2 ) == añadir( quitar(d, k, v2), k, v1 ) valor( crear_dic, k ) == [ ] valor( añadir(d, k, v), k ) == v >> valor(d, k) ( k1 k2 ) valor( añadir(d, k1, v), k2 ) == valor(d, k2) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 14

15 TAD Arbol ESPECIFICACION ARBOL (LISTA_INDEXADA) TAD arbol[nodo equivalente] : nodo, lista_ind[arbol] arbol { creación de un arbol } raiz : arbol nodo { nodo raiz de un arbol } subarbol : arbol, natural arbol { subarbol n-ésimo de un arbol } padre : arbol, nodo nodo { nodo padre de un nodo del arbol } hijos : arbol, nodo lista[nodo] { nodos hijos de un nodo del arbol }, : nodo, arbol booleano { pertenencia de un nodo a un arbol } a : arbol ; x, y : nodo ; i : natural ; l, l1, l2 : lista_ind[arbol] subarbol( x l, i ) 1 i tamaño(l) padre(a, x) ( x raiz(a) ) ( x a ) hijos(a, x) x a raiz( x l ) == x subarbol( x l, i ) == i x (x l) == T ( x y ) x (y [ ]) == F ( x y ) x (y (a >> l) ) == ( x a ) ( x (y l) ) x a == (x a) padre( y ((x l1 ) >> l2), x ) == y ( x a ) padre( y (a >> l), x ) == padre( a, x ) ( x a ) padre( y (a >> l), x ) == padre( y l, x ) hijos( x [ ], x ) == [ ] hijos( x (a >> l), x ) == raiz(a) >> hijos( x l, x ) ( x y ) ( x a ) hijos( y (a >> l), x ) == hijos( a, x ) ( x y ) ( x a ) hijos( y (a >> l), x ) == hijos( y l, x ) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 15

16 Operaciones sobre árboles ESPECIFICACIÓN ARBOPER (ARBOL) altura : arbol natural altura_nodo : arbol, nodo natural profundidad : arbol, nodo natural preorden, postorden, inorden : arbol lista_ind[nodo] { --- Operaciones auxiliares para recorridos --- } lista_preorden, lista_postorden, lista_inorden : lista_ind[arbol] lista_ind[nodo] a : arbol ; x, y : nodo ; l : lista_ind[arbol] altura_nodo( a, x ) x a profundidad( a, x ) x a altura( x [ ] ) == 0 altura( x (a >> l) ) == max( 1+altura(a), altura(x l) ) altura_nodo( x l, x ) == altura( x l ) ( x y ) ( x a ) altura_nodo( y (a >> l), x ) == altura_nodo( a, x ) ( x y ) ( x a ) altura_nodo( y (a >> l), x ) == altura_nodo( y l, x ) profundidad( x l, x ) == 0 ( x y ) ( x a ) profundidad( y (a >> l), x ) == 1+profundidad( a, x ) ( x y ) ( x a ) profundidad( y (a >> l), x ) == profundidad( y l, x ) { --- Recorridos --- } preorden( x [ ] ) == [x] preorden( x l ) == x >> lista_preorden(l) lista_preorden( [ ] ) == [ ] lista_preorden( a >> l ) == preorden(a) ++ lista_preorden(l) postorden( x [ ] ) == [x] postorden( x l ) == lista_postorden(l) << x lista_postorden( [ ] ) == [ ] lista_postorden( a >> l ) == postorden(a) ++ lista_postorden(l) inorden( x [ ] ) == [x] inorden( x [a] ) == inorden(a) << x inorden( x (a >> l) ) == inorden(a) ++ [x] ++ lista_inorden(l) lista_inorden( [ ] ) == [ ] lista_inorden( a >> l ) == inorden(a) ++ lista_inorden(l) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 16

17 TAD Directorio ESPECIFICACION DIRECTORIO (EQUIVALENCIA, LISTA_BASICA) TAD directorio[nodo equivalente] { El TAD directorio es el análogo de un sistema de ficheros, y el TAD nodo representa el concepto de subdirectorio (un fichero sería un subdirectorio vacío). La operación insertar es el análogo de mkdir, quitar de rmdir, subdirs devuelve la lista de nodos hijos de otro nodo (análogo de dir ). } crear_dir : nodo directorio { crear directorio con nodo raiz } raiz : directorio nodo { nodo raiz del directorio } insertar : directorio, nodo, nodo directorio { inserta 2º nodo como hijo del 1º } quitar : directorio, nodo directorio { elimina el nodo y sus descendientes } quitar_aux : directorio, nodo directorio { elimina sólo el nodo (op. auxiliar) } quitar_lista : directorio, lista[nodo] directorio { elimina nodos de la lista (auxiliar) } subdirs : directorio, nodo lista[nodo] { lista de hijos del nodo } : directorio, nodo booleano { pertenencia de un nodo al dir. } d : directorio ; r, p, h, x : nodo insertar( d, x, y ) (x d) (y d) { No se permiten nodos duplicados } quitar( d, x ) x raiz(d) { No se puede borrar el raiz } quitar_aux( d, x ) x raiz(d) raiz( crear_dir(r) ) == r raiz( insertar(d, p, h) ) == raiz(d) r crear_dir(r) == T (h r) h crear_dir(r) == F h insertar(d, p, h) == T (x h) x insertar(d, p, h) == x d subdirs( crear_dir(r), p ) == [ ] subdirs( insertar( d, p, h ), p ) == h >> subdirs( d, p ) (x p) subdirs( insertar( d, p, h ), x ) == subdirs( d, x ) quitar(d, p) = quitar_lista( quitar_aux(d, p), subdirs(d, p) ) quitar_aux( crear_dir(r), h ) == crear_dir(r) quitar_aux( insertar( d, p, h ), h ) == d (x h) quitar_aux( insertar( d, p, h ), x ) == insertar( quitar_aux( d, x ), p, h ) quitar_lista(d, [ ]) == d quitar_lista( d, (x >> l) ) == quitar_lista( quitar(d, x), l ) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 17

18 TAD Grafo (malla, red) ESPECIFICACION GRAFO (LISTA_BASICA, CONJUNTO) TAD grafo[nodo equivalente] crear_grafo : grafo { grafo vacío } insertar : grafo, nodo, nodo grafo { inserta arco en el grafo } quitar : grafo, nodo, nodo grafo { elimina arco del grafo } hay_arco : grado, nodo, nodo booleano { existencia de arco } vecinos : grafo, nodo lista[nodo] { nodos vecinos } nodos : grafo conjunto[nodo] { nodos del grafo } g : grafo ; x, y, a, b : nodo insertar(g, x, y) hay_arco(g, x, y) { no se permiten arcos duplicados } hay_arco( crear_grafo, x, y ) == F hay_arco( insertar(g, x, y), x, y ) == T hay_arco( insertar(g, y, x), x, y ) == T (x a) (x b) hay_arco( insertar(g, a, b), x, y ) == hay_arco(g, x, y) quitar( crear_grafo, x, y ) == crear_grafo quitar( insertar(g, x, y), x, y ) == g quitar( insertar(g, y, x), x, y ) == g (x a) (x b) quitar( insertar(g, a, b), x, y ) == insertar( quitar(g, x, y), a, b ) vecinos( crear_grafo, x ) == [ ] vecinos( insertar(g, x, y), x ) == y >> vecinos(g, x) vecinos( insertar(g, y, x), x ) == y >> vecinos(g, x) (x a) (x b) vecinos( insertar(g, a, b), x ) == vecinos(g, x) nodos( crear_grafo ) == crear_conjunto nodos( insertar(g, x, y) ) == añadir( añadir( nodos(g), x ), y ) UNIVERSIDAD DE VALLADOLID - DPTO. DE INFORMÁTICA PÁG. 18