3. ESTRUCTURAS DE DATOS NO LINEALES

Transcripción

1 3. ESTRUCTURAS DE DATOS NO LINEALES 3.1 Conjuntos 3.2 Árboles 3.3 Grafos Conjuntos Índice Introducción Especificación del TAD TipoConjunto Implementaciones del TAD TipoConjunto Programación usando conjuntos Bolsas (conjuntos con repetición) 2 1

2 Introducción El TAD Conjunto está formado por una colección de elementos junto con sus operaciones, tal que: Todos los elementos son del mismo tipo, No hay elementos repetidos. No existe ningún tipo de ordenación de los elementos (no hay un primer elemento, ni un segundo elemento, etc.) Universo de valores o conjunto universal: es el conjunto de todos los posibles valores que puede haber en un conjunto del TAD. Cardinal de un conjunto: número de elementos que contiene. Conjunto vacío ({}): conjunto con cardinal cero. 3 Introducción {1,2,7} = {2,1,7} El orden en que se escriben los elementos es irrelevante, estos conjuntos son indistiguibles al no haber linealidad. Operaciones típicas de conjuntos: Pertenencia ( ): x C significa que el elemento x forma parte del conjunto C. Inclusión ( ): el conjunto A B si todo elemento de A lo es también de B. Todo conjunto incluido en otro es un subconjunto de él. Intersección ( ): A B es el conjunto de elementos que 4 están en A y en B a la vez. 2

3 Introducción Operaciones típicas de conjuntos (sigue): Unión ( ): A B es el conjunto de los elementos que son miembros de A, de B o de ambos a la vez. Diferencia (-): A-B es el conjunto de elementos de A que no están en B. Otras operaciones básicas a especificar en el TAD: CrearConjuntoVacío, Poner, EsConjuntoVacío, Quitar y Elegir. NOTA: La unión y la intersección pueden aplicarse a más de dos conjuntos. 5 Introducción Ejemplos: Sean los conjuntos A = {a, b, e} y B={a, c, d, e} Se cumple: b A d A AUB = {a, b, c, d, e} A B = {a, e} A-B = {b} 6 3

4 Especificación Conjunto (I) ESPECIFICACIÓN TAD TipoConjunto PARAMETROS FORMALES: TipoElemento OPERACIONES: (*Constructoras generadoras*) CrearConjuntoVacio : -> TipoConjunto Poner : TipoElemento x TipoConjunto -> TipoConjunto (*Constructoras no generadoras*) Quitar : TipoElemento x TipoConjunto -> TipoConjunto Union : TipoConjunto x TipoConjunto -> TipoConjunto Interseccion : TipoConjunto x TipoConjunto -> TipoConjunto Diferencia : TipoConjunto x TipoConjunto -> TipoConjunto [parcial] (*Observadoras selectoras*) Elegir : TipoConjunto -> TipoElemento (*Observadoras no selectoras*) EsConjuntoVacio : TipoConjunto -> booleano Pertenece : TipoElemento x TipoConjunto -> booleano 7 Especificación Conjunto (II) VARIABLES: conjunto, conjunto2, conjunto3 : TipoConjunto; elemento: TipoElemento; ECUACIONES: CrearConjuntoVacío( ) = conjunto Efecto: Devuelve conjunto sin elementos Poner (elemento, conjunto) = conjunto Efecto: si elemento pertenece al conjunto devuelve el mismo conjunto sin modificar. Si elemento no pertenece a conjunto, devuelve conjunto con el nuevo elemento. EsConjuntoVacio (conjunto) = BOOLEANO Efecto: devuelve CIERTO si el conjunto no tiene elementos, y FALSO si los tiene. Quitar (elemento, conjunto) = conjunto Efecto: si elemento no pertenece al conjunto devuelve conjunto sin modificar. Si elemento pertenece al conjunto, devuelve conjunto si el elemento. 8 4

5 Especificación Conjunto (III) Pertenece (elemento, conjunto) = BOOLEANO Efecto: si elemento está en el conjunto devuelve CIERTO. En caso contrario devuelve FALSO. Elegir (conjunto) = elemento Requisito: El conjunto no puede ser vacío. Efecto: devuelve un elemento seleccionado aleatoriamente entre los que pertenecen al conjunto, sin modificar el conjunto. Union (conjunto, conjunto2) = conjunto3 Efecto: devuelve conjunto3, que es la unión de conjunto y conjunto2. Interseccion (conjunto, conjunto2) = conjunto3 Efecto: devuelve conjunto3 con los elementos comunes a conjunto y conjunto2. Diferencia (conjunto, conjunto2) = conjunto3 Efecto: devuelve conjunto3 sin los elementos de conjunto2 que puedan encontrarse en conjunto. FIN ESPECIFICACIÓN TAD 9 Especificación Conjunto (IV) Otras posibles operaciones: CopiarConjunto: TipoConjunto -> TipoConjunto IgualesConjuntos: TipoConjunto x TipoConjunto -> BOOLEANO Incluido: TipoConjunto x TipoConjunto -> BOOLEANO Cardinal : TipoConjunto -> INTEGER 10 5

6 Implementaciones de Conjuntos Implementaciones Mediante vectores booleanos Mediante un vector de elementos Realización dinámica Comparación de las diversas implementaciones Observaciones Generales 11 Comparación de las diversas realizaciones Vector de booleanos: Requiere que TipoElemento sea un Tipo Ordinal, de manera que pueda ser índice de un array. Un elemento pertenece al conjunto si el valor de su componente en el vector es TRUE. Sus índices son los elementos del conjunto universal. Sus valores indican cierto si el elemento (índice) pertenece al conjunto, y falso en caso contrario i NUM_MAX conjunto T F F T F True si el elemento i pertenece al conjunto. False si el elemento i no pertenece al conjunto 12 6

7 Comparación de las diversas realizaciones Vector de booleanos (sigue): Permite trabajar con conjuntos de cualquier tamaño, requiriendo un vector del tamaño del conjunto universal (número máximo posible de elementos o cardinal del conjunto universal NUM_MAX). p.e. para nºs de 1 a 1000 se requiere un vector de 1000 elementos. Algunas operaciones son muy simples y eficientes con esta implementación: Poner, Quitar y Pertenece son O(1). Si el rango del conjunto universal es muy grande y los conjuntos son de tamaño reducido en comparación con él, es más adecuado usar otras implementaciones, p.e. un vector de elementos o una lista enlazada de los elementos, para ahorrar memoria, aunque con estas implementaciones las operaciones no son tan eficientes. Comparación de las diversas realizaciones Vector de elementos : Los elementos del conjunto se guardan en un vector, uno detrás de otro en posiciones consecutivas, utilizando así sólo las primeras componentes necesarias (las que indica el cardinal actual). Es útil para hacer más eficientes algunas operaciones, además del vector, disponer también de un campo con el número de elementos ocupados actualmente en el vector: Vector de elementos + número de elementos 14 7

8 Comparación de las diversas realizaciones Realización mediante una lista enlazada simple dinámica: Los elementos del conjunto se guardan en la lista, y las operaciones se realizan sobre ella teniendo en cuenta que el orden de los elementos en la lista irrelevante. CrearConjuntoVacío y EsConjuntoVacío son más eficientes con esta implementación que con vectores de BOOLEANOS. Esta realización requiere memoria adicional para guardar los punteros. 15 Observaciones Generales NOTAS: Para simplificar, en esta asignatura hemos considerado en las operaciones de unión, intersección y diferencia que los conjuntos tienen el mismo tamaño. Hemos considerado que los conjuntos están formados por enteros y que sus valores van desde 1 hasta NUM_MAX. Cuando hemos recorrido los conjuntos hemos considerado que los elementos del conjunto universal van de 1 a NUM_MAX. Es más conveniente que TipoConjunto disponga de dos operaciones Mínimo: TipoConjunto -> TipoElemento Máximo: TipoConjunto -> TipoElemento Que calculen y devuelvan el mínimo y el máximo elemento del conjunto. De esta forma, los recorridos se harían desde Mínimo(C) hasta 16 Máximo(C). 8

9 Programación con conjuntos Escribir los elementos de un conjunto Encontrar el mayor de los factores primos comunes de tres números menores que 100 Juego del Bingo Criba de Eratóstenes para generar los primos menores que un número dado. Clasificación de caracteres 17 Programación con conjuntos Ejercicio: Desarrollar un programa que reciba una frase en un vector de letras, extraiga los caracteres que son letras y los guarde en un conjunto. A partir de dicho conjunto, calcule 3 conjuntos: a) conjunto de las letras del alfabeto que no pertenecen a la frase, b) conjunto de las letras que aparecen una vez en la frase, c) conjunto de letras que aparecen más de una vez. Ejemplo: ayer hizo buen tiempo Resultado = {c,d,f,g,j,k,l,q,s,v,w,x,z}, {a,y,r,h,z,b,u,n,t,m,p}, {e,i,o} 18 9

10 Bolsas Una bolsa es una colección formada por un número arbitrario de elementos del mismo tipo, donde no hay orden (como ocurre en los conjuntos), pero puede haber repetición de elementos. Bolsas = Conjuntos con repeticiones. Además de las operaciones de conjuntos surge la necesidad de una nueva operación: hallar la multiplicidad de un elemento en una bolsa, que es el número de veces que aparece el elemento en la bolsa. Multiplicidad: TipoElemento x TipoBolsa Entero 19 Bolsas. Implementaciones Las implementaciones son las mismas que las del TAD conjunto, pero modificando las operaciones para que se tenga en cuenta la posibilidad de repetición de elementos. B (1, 2) (7, 4) (2,1) 20 10

11 Ejercicio Dada la realización del TAD TipoConjunto, adaptarla para la representación y manipulación de bolsas (TAD TipoBolsa) Usando el TAD TipoBolsa, especificar y codificar en Pascal un algoritmo que permita calcular el mínimo común múltiplo de tres números naturales Árboles Definiciones Conceptos sobre Árboles Binarios Especificación Implementaciones Programación con Árboles Binarios Árboles Binarios de Búsqueda Introducción Especificación e Implementación Árboles equilibrados 22 11

12 Definiciones Un árbol es una estructura de datos no lineal que organiza sus elementos siguiendo una jerarquía de niveles entre sus elementos (nodos). Un elemento puede tener varios siguientes (hijos), y a su vez estos siguientes pueden tener varios siguientes, etc... Así, todo elemento puede tener uno, o varios o ningún hijo. Todo elemento excepto el raíz tendrá un único antecesor o padre (si tuviera más sería un grafo, no un árbol). Todo elemento excepto el raíz estará unido a su padre por una única arista o rama. Definición de árbol general: Un árbol general es una colección de nodos, todos del mismo tipo, que puede ser vacía o bien contener un nodo raíz con cero o más subárboles disjuntos (árboles hijos), hijos de la raíz. Es una definición recursiva. El TAD árbol general es el conjunto de posibles árboles junto con sus operaciones, t.q. su especificación es independiente de la representación Árbol ejemplo: Raíz: 8 Nº nodos: 13 Definiciones Definición recursiva: S i son subárboles (o árboles hijos) de la raíz r. r S 1 S 2 S 3 S

13 Definiciones Nivel o profundidad de un nodo: la raíz está en el nivel 1, 2 para los hijos de la raíz, 3 para sus nietos, etc Si un nodo está en el nivel N sus hijos están en el nivel N+1. En el 1º árbol ejemplo 8 está en el nivel 1 y 10 está en el nivel 3. Altura o profundidad de un árbol: número de niveles del árbol ó máximo nivel de sus nodos. El 1º árbol ejemplo tiene profundidad 5. Grado de un nodo: número de subárboles o hijos del nodo. El grado del nodo 10 es 3 en el 1º dibujo ejemplo. Los nodos 7 tienen grado 0. Grado de un árbol: máximo grado de sus nodos. En el 1º dibujo ejemplo el grado es 3. Hojas o nodos terminales: son los que tienen grado 0, no tienen hijos. En el ejemplo los nodos 7, 1 y 18 son hojas. Nodos no terminales: son los nodos que tienen algún hijo no vacío, p.e. los nodos 6, 15 y 10 del dibujo. Hijos de un nodo: subárboles del nodo. Nodos hijos de un nodo: nodos raíz de los subárboles del nodo. Los nodos 10 y 18 son nodos hijos del nodo Definiciones Nodo padre o antecesor: El nodo padre de 15 es 8. Nodos hermanos: nodos hijos del mismo padre. El nodo 2, el nodo 1 y el nodo 1 del nivel 4 son hermanos entre ellos y todos son hijos de 10. Camino: Secuencia de nodos n 1,n 2,n 3,...,n k siendo n i padre de n i+1, conectados dentro de un árbol. Longitud de un camino: número de aristas que unen los nodos del camino. Nodos antecesores o predecesores de un nodo: todos los nodos que están en el camino desde la raíz hasta ese nodo. Los antecesores de 2 son 10, 15 y 8. EJEMPLOS DE ÁRBOLES: - árboles genealógicos, - diagramas de la organización del personal en una empresa, - árbol de directorios en una unidad de disco, etc estos datos pueden guardarse en árboles, siendo estos las EDs más adecuadas por organizarlos en una jerarquía de niveles. 13

14 Conceptos de Árboles Binarios Árboles Binarios Son un tipo especial de árboles cuyos nodos pueden tener como máximo 2 hijos. Se definen como un conjunto finito de nodos que o bien es vacío o bien consta de una raíz y dos árboles binarios disjuntos llamados subárbol izquierdo y subárbol derecho (estos a su vez pueden ser vacíos o no). r S i S d 27 Conceptos de Árboles Binarios Hijos de un nodo: son hijo izquierdo e hijo derecho. Si se intercambian dos subárboles se obtienen árboles distintos. raíz Subárbol izdo Subárbol dcho Grado: el grado de un árbol binario puede ser como máximo 2, pero puede ser también 1 o 0. Ejemplo (dibujo abajo a la derecha): árbol binario de profundidad 4, linealizado, todo nodo tiene grado 0 o 1. Subárbol izdo vacío A B Subárbol dcho C D 14

15 Conceptos de Árboles Binarios Nº de nodos que caben en un nivel: en un árbol de profundidad k caben como máximo k-1 nodos = Nivel Nº nodos que caben 1 1 = = = = 2 3 i 2 i-1, i >= 1 k i= 1 2 i 1 = 2 k 1, k 1 29 Conceptos de Árboles Binarios Árbol binario lleno de profundidad k: tiene 2 k -1 nodos, es decir, el máximo número posible para su profundidad. Árbol binario completo con m nodos y profundidad k: si al numerar los m primeros nodos de un árbol lleno de la misma profundidad de izquierda a derecha y de arriba abajo, los nodos del árbol se corresponden con los nodos numerados. En un árbol completo, los nodos que faltarían para llenarlo son los del final Árbol lleno Árbol completo Árbol no completo 30 15

16 ESPECIFICACIÓN TAD TipoArbolBin Especificación PARAMETROS FORMALES: TipoElemento OPERACIONES: CONSTRUCTORAS GENERADORAS: CrearArbolBinVacio : -> TipoArbolBin ConstruirArbolBin : TipoArbolBin x TipoElemento x TipoArbolBin -> TipoArbolBin OBSERVADORAS SELECTORAS: [parcial] Raiz : TipoArbolBin -> TipoElemento [Parcial] HijoIzq : TipoArbolBin -> TipoArbolBin [parcial] HijoDer : TipoArbolBin -> TipoArbolBin NOTA: de las operaciones siguientes, las que están marcadas con un (*) no son operaciones básicas, es decir, sin ellas, la estructura se comportaría correctamente como un árbol binario. Estas podrían estar o no en la especificación. Si no estuvieran, podrían crearse en la aplicación usando el TAD. Sin embargo las demás operaciones son las básicas o 31 imprescindibles. OBSERVADORAS NO SELECTORAS: EsArbolBinVacio : TipoArbolBin -> booleano (*)NumNodos: TipoArbolBin Integer (*)NumHojas: TipoArbolBin Integer (*)Altura: TipoArbolBin Integer CONSTRUCTORAS NO GENERADORAS: (*)Espejo: TipoArbolBin TipoArbolBin Especificación VARIABLES: arbol, i, d, a: TipoArbolBin; r, e: TipoElemento; ECUACIONES: CrearArbolBinVacio() = arbol Efecto: crea un árbol sin elementos 32 16

17 Especificación ConstruirArbolBin(i, r, d) = arbol Efecto: construye un árbol binario a partir de un subárbol izdo i, una raíz r y un subárbol dcho d. EsArbolBinVacio (arbol) = BOOLEANO Efecto: si árbol no tiene elementos devuelve cierto y en caso contrario devuelve falso. Raiz (arbol) = r Pre: el árbol no puede ser vacío Efecto: devuelve el elemento r situado en la raíz del árbol. HijoIzq (arbol) = i Pre: el árbol no puede ser vacío Efecto: devuelve el subárbol izquierdo i del árbol. HijoDer (arbol) = d Pre: el árbol no puede ser vacío Efecto: devuelve el subárbol derecho d del árbol. 33 Especificación NumNodos(arbol) = Integer Efecto: si arbol es vacío entonces devuelve cero, y si no, si i es su hijo izquierdo y d es su hijo derecho devuelve 1 + NumNodos(i) + NumNodos(d) (recursivamente). NumHojas(arbol) = Integer Efecto: si arbol es vacío devuelve cero, y si no, si i es su hijo izquierdo, r es su raíz y d es su hijo derecho, entonces si i es vacío y d es vacío devuelve 1, y si no, devuelve NumHojas(i) + NumHojas(d) Altura(arbol) = Integer Efecto: si árbol es vacío devuelve cero. Si no, si árbol está formado por i, r, d entonces devuelve 1 + Maximo(Altura(i), Altura(d)) Espejo(arbol) = a (*) Si arbol es vacío devuelve un árbol vacío. Si no, devuelve un árbol a construido con el hijo izquierdo y el hijo derecho de arbol intercambiados. FIN ESPECIFICACIÓN 34 17

18 Implementaciones Mediante punteros y variables dinámicas: cada nodo tiene acceso a sus dos hijos, pero no tiene acceso al padre. TYPE TipoArbolBin = ^TipoNodo; B TipoNodo = RECORD izdo: TipoArbolBin; raiz: TipoElemento; dcho: TipoArbolBin; H A T izdo izdo A B T raíz dcho izdo raíz dcho izdo H raíz ÁrbolBin raíz dcho dcho D Y izdo D raíz dcho izdo raíz dcho Y Implementaciones Mediante un vector estático de tamaño MAX_NUM_NODOS: representación adecuada para árboles completos estáticos, de tamaño fijo. TYPE TipoArbolBin = ARRAY [1..MAX_NUM_NODOS] OF TipoElemento; Los elementos se almacenan de mayor nivel a menor nivel y de izda a dcha en este orden: nodo i 1 <=i<= MAX_NUM_NODOS se cumple: D B E A C A B C D E - El padre del nodo i-ésimo está en la posición idiv2 si i 1, es decir, si i no es la raíz. - hijo izq. Del nodo i-ésimo: está en la posición 2*i si 2*i<=N. - hijo dcho de i: está en la posición (2*i)+1 si (2*i)+1 <=N. No es útil para árboles estáticos no completos ni para árboles dinámicos (en los que hay inserciones y supresiones) 36 18

19 Uso. Recorridos Recorrido por los elementos de un árbol binario (pasando por todos y una vez por cada uno), p.e. para escribir su contenido, etc. Según el orden seguido pueden ser: Preorden (RID) Inorden (IRD) Postorden (IDR) Se recorren: 1º Raíz 2º Subárbol izdo en preorden 3º Subárbol dcho en preorden Se recorren: 1º Subárbol izdo en Inorden 2º Raíz 3º Subárbol dcho en Inorden Se recorren: 1º Subárbol izdo en postorden 2º Subárbol dcho en postorden 3º Raíz A A A B C B C B C D E D E D E Recorrido:ABDEC Recorrido: DBEAC Recorrido: DEBCA Uso. Una aplicación Utilidad: sirven para representar expresiones aritméticas con operaciones binarias. Operador: raíz Operandos: hijos + - C D * B E Recorrido Inorden: Notación infija: A - (B*C) + D Recorrido Postorden: Notación postfija: ABC*-D+ Recorrido en Preorden: Notación prefija: +-A*BCD 38 19

20 Implementación UNIT TArbolBin; INTERFACE USES TElemento; TYPE TipoArbolBin = ^TipoNodo; TipoNodo = RECORD izdo : TipoArbolBin; raiz : TipoElemento; dcho : TipoArbolBin 39 Implementación PROCEDURE CrearArbolBinVacio (VAR arbol: TipoArbolBin); (* POST: Construye un arbol binario sin elementos *) PROCEDURE ConstruirArbolBin (ai: TipoArbolBin; r: TipoElemento; ad: TipoArbolBin; VAR arbol: TipoArbolBin); (*POST: Construye arbol a partir de los arboles hijos izquierdo y derecho y de un nodo raiz *) FUNCTION EsArbolBinVacio (arbol: TipoArbolBin): BOOLEAN; (* POST: Devuelve TRUE si arbol no tiene elementos y FALSE si los tiene. *) FUNCTION Raiz (arbol: TipoArbolBin): TipoElemento; (* PRE: NOT EsArbolBinVacio (arbol) ; POST: Nodo raiz de arbol *) FUNCTION HijoIzq (arbol: TipoArbolBin): TipoArbolBin; (* PRE: NOT EsArbolBinVacio (arbol) ; POST: Subárbol hijo izquierdo de arbol *) FUNCTION HijoDer (arbol: TipoArbolBin) : TipoArbolBin; (* PRE: NOT EsArbolBinVacio (arbol) ; POST: Subárbol hijo derecho de arbol *) Etc 40 20

21 Implementación IMPLEMENTATION PROCEDURE CrearArbolBinVacio (VAR arbol: TipoArbolBin); (* COMPLEJIDAD: O(1) *) arbol := NIL PROCEDURE ConstruirArbolBin (ai: TipoArbolBin; r: TipoElemento; ad: TipoArbolBin; VAR arbol: TipoArbolBin); (* COMPLEJIDAD: O(1) *) VAR aux : TipoArbolBin; (*CrearArbolBinVacio (arbol);*) new (aux); aux^.izdo := ai; aux^.raiz := r; aux^.dcho := ad; arbol := aux 41 Implementación FUNCTION EsArbolBinVacio (arbol: TipoArbolBin): BOOLEAN; (* COMPLEJIDAD: O(1) *) EsArbolBinVacio := arbol = NIL FUNCTION Raiz (arbol: TipoArbolBin): TipoElemento; (* COMPLEJIDAD: O(1) *) IF NOT EsArbolBinVacio (arbol) THEN Raiz := arbol^.raiz FUNCTION HijoIzq (arbol: TipoArbolBin): TipoArbolBin; (* COMPLEJIDAD: O(1) *) IF NOT EsArbolBinVacio (arbol) THEN HijoIzq := arbol^.izdo END 42 21

22 Implementación FUNCTION HijoDer (arbol: TipoArbolBin): TipoArbolBin; (* COMPLEJIDAD: O(1) *) IF NOT EsArbolBinVacio (arbol) THEN HijoDer := arbol^.dcho END END. 43 Programación con Árboles Binarios Contar número de nodos Contar el número de hojas Decir si dos árboles son iguales Pertenencia de un elemento a un árbol Construir imagen especular Calcular la profundidad de un árbol Ver si un árbol está equilibrado Calcular el nivel en el que aparece un nodo en un árbol Si estas operaciones no estuvieran implementadas en el TAD TipoArbolBin podrían crearse en la aplicación usando el TAD

23 Uso del TAD Árbol Binario PROCEDURE Preorden (a: TipoArbolBin); IF NOT EsArbolBinVacio (a) THEN (* escritura correspondiente a recorrido en preorden *) write (Raiz(a), ' '); Preorden (HijoIzq (a)); Preorden (HijoDer (a)); END (* Preorden *) (* *) PROCEDURE Inorden (a: TipoArbolBin); IF NOT EsArbolBinVacio (a) THEN (* escritura correspondiente a recorrido en inorden *) Inorden (HijoIzq(a)); write (Raiz(a),' '); Inorden (HijoDer(a)) END (* Inorden *) 45 Uso del TAD Árbol Binario PROCEDURE Postorden (a: TipoArbolBin); IF NOT EsArbolBinVacio (a) THEN (* escritura correspondiente a recorrido en postorden *) Postorden (HijoIzq (a)); Postorden (HijoDer(a)); write (Raiz(a),' ') END (* Postorden *) (* *) FUNCTION NumNodos (a: TipoArbolBin): INTEGER; IF EsArbolBinVacio (a) THEN NumNodos := 0 ELSE NumNodos := 1 + NumNodos (HijoIzq (a)) + NumNodos (HijoDer (a)) (* nodos *) 46 23

24 Uso del TAD Árbol Binario FUNCTION Hojas (a: TipoArbolBin): INTEGER; IF EsArbolBinVacio (a) THEN Hojas := 0 ELSE IF EsArbolBinVacio (HijoIzq (a)) AND EsArbolBinVacio (HijoDer (a)) THEN Hojas := 1 ELSE Hojas := Hojas (HijoIzq (a)) + Hojas (HijoDer (a)) END (* hojas *) 47 Árboles Binarios de Búsqueda Introducción Especificación Implementación 48 24

25 Introducción Árbol binario cuyos nodos están ordenados en función del elemento o de una clave del mismo que contienen Para todos los nodos de un árbol binario de búsqueda se cumple que: los valores de los elementos de su subárbol izquierdo son menores que él y los del derecho son mayores que él Especificación algebraica ESPECIFICACIÓN TAD TipoABinBusq PARAMETROS FORMALES: TipoElemento OPERACIONES {si TipoElemento tuviera estas operaciones predefinidas, no harían falta incorporarlas en la unidad TipoElemento} Mayor: TipoElemento x TipoElemento -> Booleano Menor: TipoElemento x TipoElemento -> Booleano Igual: TipoElemento x TipoElemento -> Booleano Asignacion: TipoElemento -> TipoElemento FIN DE PARAMETROS FORMALES OPERACIONES: CONSTRUCTORAS GENERADORAS: CrearABinBusqVacio: -> TipoABinBusq PARCIAL ConstruirABinBusq: TipoABinBusq X TipoElemento X TipoABinBusq -> TipoABinBusq 50 25

26 Especificación algebraica CONSTRUCTORAS NO GENERADORAS: Insertar: TipoElemento X TipoABinBusq -> TipoABinBusq Eliminar: TipoElemento X TipoABinBusq -> TipoABinBusq OBSERVADORAS NO SELECTORAS: EsABinBusqVacio: TipoABinBusq -> booleano Pertenece: TipoElemento X TipoABinBusq -> booleano OBSERVADORAS SELECTORAS: PARCIAL Minimo: TipoABinBusq -> TipoElemento PARCIAL Maximo: TipoABinBusq -> TipoElemento BUSCAR: TipoElemento x TipoABinBusq -> TipoABinBusq VARIABLES: e, f: TipoElemento iz, dr, arbol: TipoABinBusq 51 Especificación algebraica ECUACIONES: ConstruirABinBusq(iz, e, dr) = arbol Requisito: (NO EsABinBusqVacio(iz) Y Maximo(iz)<e) Ó (NO EsABinBusqVacio(dr) Y Minimo(dr)>e) Ó (NO EsABinBusqVacio (iz) Y NO EsABinBusqVacio(dr) Y Maximo(iz)<e<Minimo(dr)) Efecto: devuelve arbol formado por una raíz e con un subárbol izquierdo iz y un subárbol dcho der. Insertar (e, a) = a Efecto: Devuelve el árbol a con el nuevo elemento e insertado. SI a es vacío devuelve un árbol a construido con un solo nodo raíz e y dos subárboles vacíos. SI NO, SI arbol está formado por (iz,f,dr) entonces SI e = f devuelve a sin modificar, SI NO SI e < f entonces devuelve a construido con (Insertar (e, iz), f, dr) SI NO devuelve a construido con (iz, f, Insertar (e, dr)). EsABinBusqVacio (arbol) = BOOLEANO Efecto: si arbol es vacío entonces devuelve cierto, si no, devuelve falso. Pertenece (e, arbol) = BOOLEANO Efecto: Devuelve cierto si e pertenece al árbol y falso en caso contrario. Si arbol está formado construido con (iz, f, dr) entonces SI e = f devuelve CIERTO, si no SI e < f devuelve Pertenece (e, iz), si no devuelve Pertenece (e, dr). Minimo (arbol) = f Requisito: arbol no puede ser un árbol vacío. Efecto: Devuelve f, el menor elemento del árbol. Si arbol está construido con (iz, e, dr) entonces 52 si EsABinBusqVacio (iz) devuelve e, si no devuelve Minimo (iz). 26

27 Especificación algebraica Maximo (arbol) = f Requisito: arbol no puede ser un árbol vacío. Efecto: Devuelve f, el elemento mayor del árbol. Si arbol está construido con (iz, e, dr) entonces si EsABinBusqVacio (dr) devuelve e, si no devuelve Maximo (dr) Eliminar (e, arbol) = arbol Efecto: Devuelve el árbol sin el elemento e. Si arbol es vacío, devuelve un árbol vacío. Si arbol está construido con (iz, f, dr) entonces: SI EsABinBusqVacio (iz) Y (e = f) devuelve dr. Si no, si EsABinBusqVacio (dr) Y (e = f) entonces devuelve iz. SI EsABinBusqVacio(iz) Y NO EsABinBusqVacio(dr) entonces SI e = f devuelve un árbol creado con ConstruirABinBusq ( iz, Minimo(dr), Eliminar (Minimo(dr), dr)), SI NO, SI e < f devuelve un árbol construido con ConstruirABinBusq (Eliminar (e, iz), f, dr), si no devuelve ConstruirABinBusq (iz, f, Eliminar (e, dr)) Buscar(e, arbol) = a Efecto: Devuelve el subárbol a del que el elemento buscado e es la raíz. Si arbol es vacío devuelve a igual a árbol vacío. Si no, SI e = f entonces devuelve a igual a árbol. Si no, SI e<f devuelv el resultado de Buscar(e, iz), y si no devuelve el resultado de Buscar(e, dr) FTAD *) 53 Implementación UNIT TABinBusq; INTERFACE USES TElemento; TYPE TipoABinBusq = ^TipoNodo; TipoNodo = RECORD izdo : TipoABinBusq; raiz : TipoElemento; dcho : TipoABinBusq PROCEDURE CrearABinBusqVacio (VAR arbol: TipoABinBusq); (* POST: Construye un arbol binario de búsqueda sin elementos *) 54 27

28 Implementación PROCEDURE ConstruirABinBusq (ai: TipoABinBusq; r: TipoElemento; ad: TipoABinBusq; VAR arbol: TipoABinBusq); (*PRE:(NO EsABinBusqVacio(ai) Y Maximo(ai)<e) Ó (NO EsABinBusqVacio(ad) Y Minimo(ad)>e) Ó (NO EsABinBusqVacio (ai) Y NO EsABinBusqVacio(ad) Y Maximo(ai)<e<Minimo(ad))*) (*POST: Construye arbol binario de búsqueda a partir de los arboles hijos izdo y dcho y de un nodo raiz *) FUNCTION Raiz (arbol: TipoABinBusq): TipoElemento; (* PRE: NOT EsArbolBinVacio (arbol) *) (* POST: Nodo raiz de arbol *) FUNCTION HijoIzq (arbol: TipoABinBusq): TipoABinBusq; (* PRE: NOT EsArbolBinVacio (arbol) *) (* POST: Subárbol hijo izquierdo de arbol *) FUNCTION HijoDer (arbol: TipoABinBusq) : TipoABinBusq; (* PRE: NOT EsArbolBinVacio (arbol) *) (* POST: Subárbol hijo derecho de arbol *) 55 Implementación FUNCTION EsABinBusqVacio (arbol: TipoABinBusq): BOOLEAN; (* POST: Devuelve TRUE si arbol no tiene elementos y FALSE si los tiene. *) PROCEDURE Insertar (e: TipoElemento; VAR arbol: TipoABinBusq); (* POST: Devuelve un árbol binario de búsqueda que contiene los elementos originales más un nuevo nodo: el que corresponde al elemento e*) PROCEDURE Eliminar(e: TipoElemento; VAR arbol: TipoABinBusq); (* POST: Devuelve el árbol binario de búsqueda con los mismos elementos excepto el elemento e, cuyo nodo es eliminado *) FUNCTION Pertenece (e: TipoElemento; arbol: TipoABinBusq): boolean; (* POST: Devuelve TRUE si e está en el árbol y FALSE en caso contrario *) FUNCTION Maximo(arbol: TipoABinBusq): TipoElemento; (*PRE: NOT EsABinBusqVacio(arbol)*) FUNCTION Minimo(arbol: TipoABinBusq): TipoElemento; (*PRE: NOT EsABinBusqVacio(arbol)*) FUNCTION Buscar(e: TipoElemento; arbol: TipoABinBusq): TipoABinBusq; 56 28

29 Implementación IMPLEMENTATION PROCEDURE Insertar (e: TipoElemento; VAR arbol: TipoABinBusq); (* POST: Devuelve un árbol binario de búsqueda que contiene los elementos originales más un nuevo nodo: el que corresponde al elemento e*) IF EsABinBusqVacio(arbol) THEN (* crear nuevo nodo con el elemento *) NEW(arbol); arbol^.raiz := e; arbol^.izdo := NIL; arbol^.dcho := NIL END ELSE IF e < Raiz(arbol) THEN Insertar(e, arbol^.izdo) ELSE IF e > Raiz(arbol) THEN Insertar(e, arbol^.dcho); 57 Implementación PROCEDURE Eliminar(e: TipoElemento; VAR arbol: TipoABinBusq); (* POST: Devuelve el árbol bin. de búsq. con los mismos elementos excepto el elem. e, cuyo nodo es eliminado *) VAR arbolaux:tipoabinbusq; IF NOT EsABinBusqVacio(arbol) THEN (* sólo actúo si el árbol no es vacío *) IF e = Raiz(arbol) THEN (* el nodo a eliminar es el nodo raíz*) IF HijoIzq(arbol) = NIL THEN (* el enlace al elemento pasará a apuntar a su hijo derecho y después será eliminado*) arbolaux := arbol; arbol:= HijoDer(arbol); dispose (arbolaux) END ELSE IF HijoDer(arbol) = NIL THEN arbolaux := arbol; arbol := HijoIzq(arbol); dispose (arbolaux) 58 END 29

30 Implementación ELSE (* e tiene 2 hijos no vacíos -> e se sustituye por el mínimo del subárbol derecho y este se borra*) arbol^.raiz := Minimo(HijoDer(arbol)); Eliminar(Minimo( arbol^.dcho), arbol^.dcho ) END ELSE (* No estoy en el nodo a eliminar, sigo descendiendo en el árbol buscándolo *) IF e < Raiz(arbol) THEN Eliminar(e, arbol^.izdo) ELSE Eliminar(e, arbol^.dcho ); a^.izq 2 a a^.der Implementación FUNCTION Pertenece (e: TipoElemento; arbol: TipoABinBusq): boolean; (* Implementación iterativa (no recursiva) *) (* POST: Devuelve TRUE si e está en el árbol y FALSE en caso contrario *) VAR encontrado: Boolean; (* Complejidad: O(N) en el caso peor, cuando el árbol es lineal. Si fuese un árbol equilibrado sería O(logN) *) encontrado := FALSE; WHILE NOT EsABinBusqVacio(arbol) AND NOT encontrado DO IF e = Raiz(arbol) then encontrado := TRUE ELSE IF e < Raiz(arbol) THEN arbol:= HijoIzq(arbol) ELSE arbol := HijoDer(arbol); Pertenece := encontrado; { } 60 30

31 Implementación FUNCTION Maximo(arbol: TipoABinBusq): TipoElemento; (*** Implementación no recursiva de Maximo *** *** PRE: NOT EsABinBusqVacio(arbol) ***) IF EsABinBusqVacio(arbol) THEN WRITE('Error en Function Máximo: el árbol es vacío. ') ELSE WHILE NOT EsABinBusqVacio(HijoDer(arbol)) DO arbol := HijoDer(arbol); Maximo := Raiz(arbol); {* NOTA: de forma recursiva sería así: *} {* IF EsABinBusqVacio(arbol) THEN *} {* WRITE('Error en Function Máximo: el árbol es vacío. ') *} {* ELSE *} {* IF EsABinBusqVacio(HijoDer(arbol)) THEN *} {* Maximo := Raiz(arbol) *} {* ELSE *} {* Maximo := Maximo(HijoDer(arbol)); *} 61 Implementación FUNCTION Minimo(arbol: TipoABinBusq): TipoElemento; (*Implementación no recursiva*) (*PRE: NOT EsABinBusqVacio(arbol)*) IF EsABinBusqVacio(arbol) THEN WRITE('Error en Function Máximo: el árbol es vacío. ') ELSE WHILE NOT EsABinBusqVacio(HijoIzq(arbol)) DO arbol := HijoIzq(arbol); Minimo := Raiz(arbol); {* NOTA: La implementación recursiva sería así: *} {* IF EsABinBusqVacio(arbol) THEN *} {* WRITE('Error en Function Máximo: el árbol es vacío. ') *} {*ELSE *} {* IF EsABinBusqVacio(HijoIzq(arbol)) THEN *} {* Minimo := Raiz(arbol) *} {* ELSE *} {* Minimo := Minimo(HijoIzq(arbol)); *} { } 62 31

32 Implementación FUNCTION Buscar(e: TipoElemento; arbol: TipoABinBusq): TipoABinBusq; IF EsABinBusqVacio(arbol) THEN Buscar := NIL ELSE IF e = Raiz(arbol) THEN Buscar := arbol ELSE IF e < Raiz(arbol) THEN Buscar := Buscar(e, HijoIzq(arbol)) ELSE Buscar := Buscar(e, HijoDer(arbol)); END. 63 Uso del TAD TipoABinBusq Podemos asegurar que se construye bien el árbol binario de búsqueda si usamos como constructoras CrearArbolBinVacio, Insertar y Eliminar exclusivamente y evitar construir

33 Árboles de búsqueda Búsqueda de elementos en un árbol binario de búsqueda tiene coste entre O(log n) y O(n) Depende de cómo fue el orden de inserción de elementos O(n) O(log n) Grafos Introducción Definiciones Representaciones Especificación algebraica Una implementación Recorridos Uso del TAD TipoGrafo 66 33

34 Introducción Son las EDs más generales (listas y árboles podrían considerarse casos particulares de grafos) Los árboles se utilizaban para modelar jerarquías Los grafos se utilizan para representar relaciones arbitrarias (conexiones) entre objetos Ejemplos de uso: para almacenar y procesar caminos entre ciudades, redes de ordenadores, conectividades de regiones en imágenes, tráfico aéreo, etc... v2 v3 v1 v5 v4 67 Definiciones Un grafo G es un par G = (V, A) donde V es un conjunto de vértices (o nodos) A es un conjunto de aristas (o arcos) entre pares de ellos Una arista es un par de vértices (v,w) donde v y w pertenecen a V. v2 v3 v1 v5 v

35 Definiciones Grafo dirigido (o digrafo): sus arcos están ordenados u orientados, es decir, (v,w)!= (v,w) En la arista (v, w), v es el origen, w es el destino y w es adyacente a v. Grafo no dirigido: los arcos o aristas no tienen orientación => (v,w) = (w,v) v es adyacente a w y w es adyacente a v (ó v y w son adyacentes) v2 v3 v2 v3 v1 v4 v1 v4 v5 Grafo dirigido v5 Grafo no dirigido 69 Definiciones Grafo etiquetado o ponderado: Grafo cuyos arcos tienen un peso o etiqueta. La arista (v, w, p) tiene una tercera componente p llamada peso o coste. 7 v1 4 v v5 v3 1 2 v4 7 v1 4 v v5 v3 2 v4 Grafo ponderado Grafo dirigido ponderado 70 35

36 Definiciones Grado de un nodo: Número de arcos que contienen a un nodo Grado de entrada y grado de salida: Para grafos dirigidos en función de si los arcos son de salida o de entrada v1 v2 v5 V3 grado 3 v3 v4 v1 v2 v5 v3 V3 grado entrada: 1 V3 grado salida: 1 v4 71 Definiciones Para grafos no dirigidos: dos vértices son adyacentes si existe un arco que los una. v1 Para grafos dirigidos: adyacentes a v1 v2 v2 v5 v5 v3 v3 v4 v4 V1 y V2 son adyacentes (V1 es adyacente a V2 y V2 es adyacente a V1) V1 es adyacente a V2, V3 y V5 El vértice w es adyacente a v si y solo si existe la arista (v,w). V2 es adyacente a V3 (no alrevés). V1 es adyacente a V

37 Definiciones Camino: Secuencia de vértices que hay que atravesar para llegar de un vértice a otro v1 v2 v5 v3 v4 Camino de V1 a V3: V1,V2,V3 Longitud = 2 (nº vertices -1) Camino simple: camino cuyos vértices son diferentes Longitud: Número de arcos de un camino 73 Definiciones Ciclo: posible camino de v a v (pasando por otros) v1 v2 v5 v3 v4 Ciclo a V1: (V1, V2, V3, V5, V1) Bucle: camino de v a v de longitud 1 (los grafos que vamos a ver no suelen tener bucles)

38 Definiciones Circuito: idem ciclo pero para grafos dirigidos v2 v3 v1 v5 v4 Circuito a V1: <V1,V5>, <V5,V3>, <V3,V2>, <V2, V1> 75 Definiciones Grafo completo: si existe una arista entre cualquier par de vértices. v2 v3 v1 v5 v

39 Definiciones Grafo conexo: un grafo no dirigido es conexo si existe un camino desde cualquier vértice a cualquier otro. Un grafo dirigido con esta propiedad se dice que es fuertemente conexo. v3 v2 v1 v5 v4 Grafo no conexo: v1 v2 v3 v5 v4 77 Definiciones Un grafo dirigido es fuertemente conexo si existe un camino desde un vértice a cualquier otro. Si un grafo dirigido no es fuertemente conexo pero el grafo subyacente sin dirección en los arcos es conexo se dice que conexo ó débilmente conexo. v1 v2 v5 v3 v4 Conexo Fuertemente conexo v2 v1 v5 v3 v

40 Definiciones Un grafo se construye incrementalmente añadiendo vértices y aristas progresivamente, de uno en uno tal que: No se puede añadir una arista si previamente no están en el grafo los vértices que conecta. 79 Representaciones Representación estática mediante una matriz de adyacencia: Consideremos grafos dirigidos (los no dirigidos se representan en forma semejante). Supongamos que podemos numerar los vértices iniciando la numeración en 1, 2, Para cada arista (u,v) existente en el grafo, se asigna a[u,v] =TRUE. En caso contrario a[u,v] = FALSE. Ej.: grafo de 5 vértices y 6 aristas. Tamaño de la matriz de adyacencia = (num_max_nodos)

41 Representaciones Una posible implementación de grafo de este tipo viene dada por un Conjunto de Nodos (TipoConjunto) + Matriz de Adyacencia: TYPE TipoNodo = 1..NumMaxNodos; TipoGrafo = RECORD valores = TipoConjuntoNodos; (* TAD TipoConjunto (TipoNodo); *) matriz_adyacencias = ARRAY[TipoNodo, TipoNodo] OF BOOLEAN; Representación Si los valores de los nodos no son de un tipo ordinal o enumerado => no sirven como índices de la matriz de adyacencia (p.e. si son nombres desconocidos en tiempo de compilación): Es preciso relacionar el valor de cada nodo con el índice de la matriz que le corresponde (p.e. usando un vector que haga la correspondencia entre índice y valor): A medida que se lee el grafo se asignan los índices (posiciones disponibles del vector donde se guardan los valores). Madrid Toledo + Cuenca vector de valores A = Matriz de adyacencias Toledo Madrid Cuenca 82 41

42 Representaciones Ejemplo de implementación: TYPE CONST NumMaxNodos = 100; TipoNodo = 1..NumMaxNodos; (*tipo de la numeración de los nodos*) TipoGrafo = RECORD valores = ARRAY [TipoNodo] of TipoElemento; matriz_adyacencias = ARRAY[TipoNodo, TipoNodo] OF BOOLEAN; Representación Si se trata de un grafo ponderado: Para cada arista (u, v) existente: a[u, v]= peso. Si no existe la arista a[u, v] = un peso centinela (o muy grande o muy pequeño) para indicarlo. Ejemplo: a 1 v=(a,b,c) A = b c Si el grafo es no dirigido, la matriz de adyacencias es simétrica

43 Representación La representación de grafos mediante una matriz de adyacencias: es útil cuando el grafo tiene muchas conexiones o aristas. En caso contrario, si num_aristas <<< (num_max_nodos) 2 se desperdicia memoria. Es de fácil uso, con acceso inmediato a las aristas Para encontrar los vértices adyacentes a uno dado se recorre la fila de la matriz de adyacencias correspondiente a ese nodo. Existe un número máximo de vértices o nodos (NumMaxNodos) El grado de salida de un nodo en un digrafo es el nº de elem. de su fila a TRUE. El grado de entrada es el número de elementos de su columna a TRUE. Representación Representación dinámica de grafos mediante listas de adyacencia (Consideremos grafos dirigidos (los no dirigidos se representan en forma semejante). Madrid Toledo Cuenca Vector de registros Listas de adyacencia Toledo Madrid Cuenca Cada vértice del grafo tiene asociada una lista que contiene todos los nodos adyacentes a él. Esta representación es especialmente útil si el grafo es disperso 43

44 Ejemplo de implementación: TipoIndiceNodo = 1..NumMaxNodos; TYPE TipoListaAdyacencias = ^TipoNodoLista; TipoNodoLista = RECORD NodoAdyacente = TipoIndiceNodo; siguiente = TipoListaAdyacencias; TipoNodo = RECORD valor = TipoElemento; lista = TipoListaAdyacencia; End; Representación TipoGrafo = ARRAY [TipoIndiceNodo] OF TipoNodo; Representación Una representación completamente dinámica: TYPE TipoListaAdyacencias = ^TipoNodoListaAdya; TipoNodoListaAdya = RECORD Madrid valoradyacente = TipoElemento; siguiente = TipoListaAdyacencias; Toledo TipoListaNodos = ^TipoNodo; TipoNodo = RECORD valor = TipoElemento; siguiente = TipoListaNodos; listaadya = TipoListaAdyacencia; End; TipoGrafo = TipoListaNodos; Cuenca Cáceres Cuenca Madrid Toledo Cáceres Badajoz Madrid Cuenca 44

45 Representación La representación de grafos mediante listas de adyacencia es útil cuando el grafo es disperso. Para cada vértice se tiene una lista con sus vértices adyacentes. Si el grafo fuese no dirigido, cada arista (u,v) aparece en dos listas, duplicándose. Encontrar todos los vértices adyacentes a algún vértice dado v supone simplemente recorrer su lista de adyacencia. Consultar el grado de entrada de un nodo v en un grafo dirigido requiere recorrer todas las listas de adyacencia para ver cuántas veces es nodo destino. 89 Representación Repr. dinámica de un grafo ponderado Cada nodo de la lista de adyacencia contiene un valor adicional con el peso a c 3 b a 1 c 2 c b 6 Si el grafo es no dirigido, cada arista aparece 2 veces: Madrid Toledo Cuenca Badajoz

46 TAD TipoArco PARÁMETROS FORMALES: TipoNodo TIPO: TipoArco Especificación algebraica TipoArco OPERACIONES: (* CONSTRUCTORAS GENERADORAS*) ConstruirArco: TipoNodo x TipoNodo TipoArco (* OBSERVADORAS SELECTORAS*) Origen: TipoArco TipoNodo Destino: TipoArco TipoNodo VARIABLES v, w: TipoNodo ECUACIONES ENTRE GENERADORAS ConstruirArco(v, w) = ConstruirArco(w, v) (* se pone sólo si el arco es no dirigido *) ECUACIONES (* OBSERVADORAS SELECTORAS*) Origen(ConstruirArco(v, w)) = v Destino(ConstruirArco(v, w)) = w FIN TAD 91 Especificación Algebraica TipoArcoPonderado TAD TipoArcoPonderado (* Tipo de los arcos que tienen peso o etiqueta*) PARÁMETROS FORMALES: TipoNodo, TipoPeso TIPO: TipoArcoPonderado OPERACIONES: (*OPERACIONES CONSTRUCTORAS GENERADORAS*) ConstruirArcoPonderado: TipoNodo x TipoNodo x TipoPeso TipoArcoPonderado (*OPERACIONES OBSERVADORAS SELECTORAS*) Origen: TipoArcoPonderado TipoNodo Destino: TipoArcoPonderado TipoNodo Coste: TipoArcoPonderado TipoPeso (*OPERACIONES OBSERVADORAS NO SELECTORAS*) MenorCoste: TipoArcoPonderado x TipoArcoPonderado Booleano 92 46

47 Especificación Algebraica TipoArcoPonderado VARIABLES a1, a2: TipoArco v, w: TipoNodo c: TipoPeso ECUACIONES ENTRE GENERADORAS ConstruirArcoPonderado(v,w,c)=ConstruirArcoPonderado(w,v,c) (*si es arco no dirigido*) ECUACIONES (*Observadoras no selectoras*) Origen(ConstruirArcoPonderado(v, w, c)) = v Destino(ConstruirArcoPonderado(v, w, c)) = w Coste(ConstruirArcoPonderado(v, w, c)) = c (*Observadoras no selectoras*) MenorCoste(a1, a2) = Coste(a1) < Coste(a2) FIN TAD 93 Especificación algebraica TipoGrafo TAD TipoGrafo (*Dirigido sin pesos*) PARÁMETROS FORMALES: TipoNodo, TipoConjuntoNodos(TipoNodo), TipoArco(TipoNodo), TipoConjuntoArcos(TipoArco) (* TipoConjuntoNodos y TipoArco están parametrizados por TipoNodo, es decir, su parámetro es TipoNodo*) TIPO: TipoGrafo OPERACIONES: (*CONSTRUCTORAS GENERADORAS*) CrearGrafoVacio: TipoGrafo InsertarNodo: TipoNodo x TipoGrafo TipoGrafo PARCIAL InsertarArco: TipoArco x TipoGrafo TipoGrafo (*OBSERVADORAS SELECTORAS*) Nodos: TipoGrafo TipoConjuntoNodos Arcos: TipoGrafo TipoConjuntoArcos 94 47

48 Especificación algebraica (*OPERACIONES OBSERVADORAS NO SELECTORAS*) EsGrafoVacio: TipoGrafo Booleano PARCIAL Adyacentes: TipoGrafo x TipoNodo TipoConjuntoNodos EstaArco: TipoArco x TipoGrafo -> Booleano EstaNodo: TipoNodo x TipoGrafo -> Booleano (*OPERACIONES CONSTRUCTORAS NO GENERADORAS*) BorrarArco: TipoArco x TipoGrafo TipoGrafo BorrarNodo: TipoNodo x TipoGrafo TipoGrafo (*OPERACIONES AUXILIARES*) ExtremosIguales: TipoArco x TipoArco Booleano VARIABLES g: TipoGrafo v, w, y, z: TipoNodo a, a1, a2: TivpoArco c: Real conjuntonodos: TipoConjuntoNodos 95 Especificación algebraica ECUACIONES DE DEFINITUD (*términos bien definidos de op. parciales*) SI EstaNodo(Origen(a), g) Y EstaNodo(Destino(a)=> DEF(InsertarArco(a, g)) SI EstaNodo(v,g) => DEF (Adyacentes(v, g)) ECUACIONES (* Observadoras selectoras *) Nodos(CrearGrafoVacio) = CrearConjuntoVacio Nodos(InsertarNodo(v, g)) = Poner(v, Nodos(g)) (*operación TipoConjunto*) Nodos(InsertarArco(a, g)) = Poner(a, Arcos(g)) (*los nodos de a están en g*) Arcos(CrearGrafoVacio) = CrearConjuntoVacio Arcos(InsertarNodo(v, g)) = Arcos(g) Arcos(InsertarArco(a, g)) = Poner(a, Arcos(g)) 96 48

49 Especificación algebraica (* Observadoras no selectoras *) EsGrafoVacio(CrearGrafoVacio) = CIERTO EsGrafoVacio(InsertarNodo(v, g)) = FALSO EsGrafoVacio(InsertarArco(a, g)) = FALSO Adyacentes(v, CrearGrafoVacio) = CrearConjuntoVacio Adyacentes(v, InsertarNodo(w, g)) = Adyacentes(v, g) Adyacentes(v, InsertarArco(a, g)) = SI Origen(a) = v Poner(Destino(a), Adyacentes(v, g)) SI Destino(a) = v Poner(Origen(a), Adyacentes(v,g)) (*) Adyacentes(v, g) (*) Esta línea no aparecería si fuese dirigido. 97 Especificación algebraica (* Constructoras no generadoras *) BorrarArco(a, CrearGrafoVacio) = CrearGrafoVacio BorrarArco(a, InsertarNodo(v, g)) = InsertarNodo(v, BorrarArco(a,g)) BorrarArco(a, InsertarArco(a1, g)) = SI (Origen(a1) =Origen(a2))Y(Destino(a1)=Destino(a2)) g InsertarArco (a1, BorrarArco(a,g)) BorrarNodo (v, CrearGrafoVacio) = CrearGrafoVacio BorrarNodo(w, InsertarNodo(v, g)) = SI (v = w) g InsertarNodo(v, BorrarNodo(w,g)) BorrarNodo(y, InsertarArco(a, g)) = SI (Origen(a) = y) O (Destino(a) = y) BorrarNodo(y, g) InsertarArco(a, BorrarNodo(y, g)) FIN TAD 98 49

50 Implementación Cuando corresponda, la implementación de TipoGrafo podrá hacer uso de las unidades de los diferentes TADs involucrados: TipoNodo: tipo usado para la numeración de los nodos. TipoArco (TipoNodo): Tipo de los arcos parametrizado por TipoNodo. TipoConjuntoNodos(TipoNodo): Tipo de los conjuntos de nodos (enumerados) del grafo, parametrizado por TipoNodo. TipoElemento: Tipo de la información del nodo; si fuese de un tipo enumerado (p.e 1..NUM_MAX_NODOS) podría coincidir con TipoNodo, y bastaría con usar TipoNodo). TipoConjuntoArcos(TipoArco): necesario sólo si en la implementación están operaciones que involucren este tipo, p.e. la operación Arcos. A continuación se muestra un ejemplo de implementación: 99 Implementación UNIT TNodo; INTERFACE CONST NUM_MAX = 20; TYPE TipoNodo = 1..NUM_MAX; (* Tipo para enumerar los nodos. No haría falta para representación completamente dinámica mediante listas de adyacencia, donde no hay ni matriz ni vector. *) IMPLEMENTATION END

51 Implementación UNIT TArco; INTERFACE USES TNodo; TYPE TipoArco = ARRAY [1..2] OF TipoNodo; PROCEDURE Construir (i,j: TipoNodo; VAR arco: TipoArco); (* POST: "Construye un arco a partir de dos nodos" *) FUNCTION Origen (arco: TipoArco): TipoNodo; (* POST: "Devuelve el nodo origen de un arco *) FUNCTION Destino (arco: TipoArco): TipoNodo; (* POST: "Devuelve el nodo destino de un arco *) 101 Implementación IMPLEMENTATION PROCEDURE Construir (i,j: TipoNodo; VAR arco: TipoArco); (* COMPLEJIDAD: O(1) *) arco[1] := i; arco[2] := j FUNCTION Origen (arco: TipoArco): TipoNodo; (* COMPLEJIDAD: O(1) *) Origen := arco[1] FUNCTION Destino (arco: TipoArco): TipoNodo; (* COMPLEJIDAD: O(1) *) Destino := arco[2] END

52 UNIT TGrafoDirigido; {Grafo No Ponderado} INTERFACE Implementación USES TElemento, TNodo, TArco(TipoNodo), TConjuntoNodos(TipoNodo), TConjuntoArcos(TipoArco); TYPE TipoMatrizAdyacencias = ARRAY[TipoNodo,TipoNodo] OF BOOLEAN; TipoGrafo = RECORD nodos: TipoConjuntoNodos; matrizadyacencias: TipoMatrizAdyacencias; vector: ARRAY[1..MAX_NUM] OF TipoElemento (*) (*) este vector sólo haría falta si TipoElemento no es un tipo que sirva como índice de array, y con objeto de permitir la correspondencia de (número,elemento). En la siguiente implementación no existe este campo, 103 los nodos son de tipo TipoNodo 1 NUM_MAX_NODOS *) Implementación { CONSTRUCTORAS GENERADORAS } PROCEDURE CrearGrafoVacio(VAR grafo:tipografo); (* POST: "Construye un grafo inicial sin nodos ni arcos" *) PROCEDURE InsertarNodo(nodo:TipoNodo; VAR grafo:tipografo;); (* POST: "Devuelve un grafo con los mismos nodos y arcos que en el grafo de entrada más el elemento nodo si no existia" *) PROCEDURE InsertarArco(arco:TipoArco; VAR grafo: TipoGrafo; ); (* POST: Inserta el arco *) { OBSERVADORAS NO SELECTORAS } FUNCTION EsGrafoVacio(grafo:TipoGrafo): Boolean; (* POST: resultado = "grafo es o no vacio" *) FUNCTION EstaNodo (nodo:tiponodo; grafo:tipografo):boolean; (*POST: Decide si un nodo pertenece o no al grafo*)

53 Implementación FUNCTION EstaArco (arco: TipoArco; grafo: TipoGrafo): Boolean; (*decide si un arco pertenece o no al grafo*) PROCEDURE Adyacentes(nodo: TipoNodo; grafo: TipoGrafo; VAR cjtoadya: TipoConjuntoNodos); { POST: Devuelve el conjunto de los nodos adyacentes a uno dado } { OBSERVADORAS SELECTORAS } PROCEDURE Nodos(grafo: TipoGrafo; VAR cjtonodos: TipoConjuntoNodos); {POST: Devuelve el conjunto de los nodos actuales de un grafo} PROCEDURE Arcos(grafo: TipoGrafo; VAR cjtoarcos: TipoConjuntoArcos); {POST: Devuelve el conjunto de los arcos actuales de un grafo} { CONSTRUCTORAS NO GENERADORAS } PROCEDURE BorrarNodo(nodo: TipoNodo; VAR grafo: TipoGrafo;); {POST: Elimina un nodo y sus arcos incidentes en un grafo} PROCEDURE BorrarArco(arco: TipoArco; VAR grafo: TipoGrafo;); {POST: Elimina un arco} 105 Implementación IMPLEMENTATION (* *) PROCEDURE CrearGrafoVacio (VAR grafo: TipoGrafo); (* COMPLEJIDAD: O(NUM_MAX*NUM_MAX) *) VAR i, j: TipoNodo; CrearConjuntoVacio (grafo.nodos); FOR i := 1 TO NUM_MAX DO FOR j := 1 TO NUM_MAX DO grafo.matrizadyacencias[i,j] := FALSE (* *) PROCEDURE InsertarNodo (nodo: TipoNodo; VAR grafo: TipoGrafo); (* COMPLEJIDAD: O(1) *) Poner(nodo, grafo.nodos)

54 Implementación PROCEDURE InsertarArco (arco: TipoArco; VAR grafo: TipoGrafo); (*PRE: Los nodos de arco deben pertencer al grafo *) (* COMPLEJIDAD: O(1) *) VAR i, j: TipoNodo; i := Origen (arco); j := Destino (arco); IF EstaNodo(i, grafo) AND EstaNodo(j, grafo) THEN grafo.matrizadyacencias[i,j] := TRUE ELSE WRITELN('Error en Procedure InsertarArco:algún nodo del arco no está') (* *) FUNCTION EsGrafoVacio (grafo: TipoGrafo): BOOLEAN; (* COMPLEJIDAD: O(1) o O(NUM_MAX), dep. de la impl. de los conjuntos *) EsGrafoVacio := EsConjuntoVacio (grafo.nodos) (* no puede haber arcos cuyos nodos no existen *) 107 Implementación PROCEDURE Adyacentes (nodo: TipoNodo; grafo: TipoGrafo; VAR cjtoady: TipoConjuntoNodos); (* Sean los adyacentes a un nodo aquéllos en los que inciden aristas (nodos destino) con origen en ese nodo: *) VAR aux: 1..NUM_MAX; IF EstaNodo(nodo, grafo) THEN CrearConjuntoVacio (cjtoady); FOR aux := 1 TO NUM_MAX DO IF grafo.matrizadyacencias[nodo,aux] THEN Poner(aux, cjtoady); END ELSE WRITELN( Error en PROCEDURE Adyacentes: el nodo no está en el grafo );