Estructuras de Datos Avanzadas Contenido del Tema

Transcripción

1 T E M A 6 Estructuras de Datos Avanzadas Contenido del Tema 6.1. Introducción 6.2. Pilas 6.3. Colas 6.4. Listas 6.5. Arboles Binarios. Arboles Binarios de Búsqueda 6.6. Otras Estructuras. Introducción Objetivos Especificación e Implementación de nuevas estructuras de datos Técnica: Abstracción de Datos Tipos de Estructuras de Datos: 1) Datos organizados por Posición Pilas, Colas y Listas 2) Datos organizados por Valor Arboles Binarios 1

2 Introducción Estudio de las Estructuras de Datos: Definición de la Estructura de Datos e identificación de su Conjunto de Operaciones Desarrollo de diversas Implementaciones Presentación de Aplicaciones Pilas Definición Pila: Grupo Ordenado, (de acuerdo al tiempo que llevan en la pila) de Elementos Homogéneos (todos del mismo tipo). Acceso a la Pila: añadir y eliminar elementos, SÓLO a través de la CABEZA de la Pila Estructura LIFO (Last Input First Output) Añadir Eliminar 2

3 Pilas. Operaciones Conjunto de Operaciones MÓDULO MPila DEICIÓN TIPOS TElemento= // cualquier tipo de datos TPila= // por definir PROC MeterPila( pila:tpila; elem: TElemento) // Añade un elemento por la cabeza de la pila PROC SacarPila( pila:tpila; elem:telemento) // Saca un elemento por la cabeza de la Pila Pilas. Operaciones Conjunto de Operaciones FUNC CrearPila():TPila // Crea una pila vacía FUNC PilaVacia ( pila :TPila):LÓGICO // Nos dice si una pila está vacía FUNC PilaLlena( pila:tpila):lógico // Nos dice si una pila está llena. PROC DestruirPila( pila:tpila) // Destruye una pila previamente creada Fin 3

4 Pilas. Implementación Implementación 1) Con un Array Array estructura adecuada Elementos Homogéneos Elementos almacenados de forma Secuencial CONSTANTES MAXPILA 100 TIPOS TElemento = ENTERO TPila = ARRAY[1..MAXPILA]DE TElemento Pilas. Implementación Sólo es posible acceder a la Cabeza de la Pila Cómo es posible conocer la posición de la cabeza? 1) Variable entera cabeza Inconveniente: se ha de pasar como parámetro adicional a todas las operaciones sobre la pila 2) Extender el array, en pila[0] almacenaremos el índice del elemento que ocupa la cabeza actual 4

5 Pilas. Implementación CONSTANTES CABEZA 0 MAXPILA 100 TIPOS TPila = ARRAY[CABEZA..MAXPILA]DE TElemento [0] [1] [2] [3] [99] [100] Pilas.Implementación Inconveniente: Solo es posible implementar una pila de enteros (no de cualquier otro tipo de datos) Solución: CONSTANTES MAXPILA 100 TIPOS TElemento= // cualquier tipo de datos TPila=REGISTRO Cabeza:NATURAL Elementos: ARRAY[1..MAXPILA] DE!! "" ## TElemento k k MAXPILA 5

6 Pilas.Implementación IMPLEMENTACIÓN FUNC CrearPila():TPila VARIABLES pila:tpila pila.cabeza 0 RESULTADO pila FUNC PilaVacia( pila:tpila ):LÓGICO RESULTADO pila.cabeza=0 FUNC PilaLlena( pila:tpila ):LÓGICO RESULTADO (pila.cabeza = MAXPILA) PROC DestruirPila( pila:tpila) // No hay que hacer nada. Pilas.Implementación PROC SacarPila( pila:tpila; elem:telemento) elem pila.elementos [pila.cabeza] pila.cabeza pila.cabeza-1 /* precondición: */ la pila no ha de estar vacía PROC MeterPila( pila:tpila; elem :TElemento) pila.cabeza pila.cabeza+1 pila.elementos [pila.cabeza] elem /* precondición: la pila no ha de estar llena */ 6

7 . Pilas.Implementación PROC MeterPila ( pila:tpila; elem:telemento; llena : LÓGICO) Inicio llena PilaLlena(pila) SI ( llena) ENTONCES pila.cabeza pila.cabeza + 1 pila.elementos [pila.cabeza] elem SI Fin /* Sin Prec ondición.introduce un elemento en la pila si no está llena */ PROC SacarPila( pila:tpila ; elem:telemento; vacia:lógico) vacia PilaVacia(pila) SI vacia ENTONCES elem pila.elementos [pila.cabeza] pila.cabeza pila.cabeza-1 SI /* Sin precondición. Saca un elemento de la pila si no está vacía*/ Pilas.Implementación 2) Con una Lista Enlazada de Punteros Comienzo de una lista enlazada Cabeza de la Pila TIPOS TElemento= // cualquier tipo de datos TPila = PUNTERO A TNodoPila TNodoPila = '' (( )) ** + + (( REGISTRO dato:telemento sig: TPila REGISTRO $ $ %% &&,, --. 7

8 Pilas.Implementación PROC MeterPila( pila:tpila; elem: TElemento; llena: LÓGICO) VARIABLES nuevonodo : TPila llena FALSO nuevonodo NUEVO(TNodoPila) nuevonodo^.dato elem nuevonodo^.sig pila pila nuevonodo PROC SacarPila( pila:tpila; elem :TElemento; vacía: LÓGICO) VARIABLES ptr: TPila vacía PilaVacía(pila) SI vacía ENTONCES elem pila^.dato ptr pila pila pila^.sig ELIMINAR(ptr) SI Pilas.Implementación PROC CrearPila():TPila RESULTADO NULO Fin FUNC PilaVacia(pila :TPila ):LÓGICO RESULTADO (pila= NULO) PROC DestruirPila( pila:tpila) Variables ptr: TPila Inicio MIENTRAS(pila NULO)HACER ptr pila pila pila^.sig ELIMINAR(ptr) MIENTRAS 8

9 Pilas. Aplicaciones Aplicaciones Ejemplo1: : Leer una secuencia de caracteres desde teclado e imprimirla al revés Ejemplo2: : Verificar si una cadena de caracteres está balanceada en paréntesis o no abc(defg defg(ijk))(l( ))(l(mn)op)qr SI abc(def def)) ))ghij(kl)m NO Ejemplo3: : Reconocimiento del Lenguaje, L={W$W / W es una cadena de caracteres y W es su inversa} (Suponemos que $ no está ni en W ni en W ) Pilas. Ejemplo1 ALGORITMO Inverso DESDE MPila IMPORTA TPila, CrearPila, MeterPila, SacarPila, Pilavacia, DestruirPila CONSTANTES ENTER CHR(13) TIPOS TElemento = CARÁCTER VARIABLES c : TElemento pila : TPila ll,v:lógico pila CrearPila() LEER(c) MIENTRAS (c ENTER) ( ll) HACER MeterPila(pila,c,ll) Leer(c) MIENTRAS SacarPila(pila,c,v) MIENTRAS ( PilaVacia(pila))HACER SacarPila(pila,c,v) Escribir(c) MIENTRAS DestruirPila(pila) 9

10 Pilas. Ejemplo2 ALGORITMO Balanceo DESDE MPila IMPORTA CrearPila, TPila, MeterPila, SacarPila, PilaVacia, DestruirPila CONSTANTES ENTER CHR(13) Tipos TElemento = CARÁCTER VARIABLES c : TElemento pila : TPila bien,ll, v : LÓGICO Inicio pila CrearPila() bien CIERTO LEER(c) MIENTRAS(bien (c ENTER)HACER SI c= ( ENTONCES MeterPila(pila,c,ll) bien ll EN OTRO CASO SI SI LEER(c) MIENTRAS SI c = ) ENTONCES SacarPila(pila,c,v) bien v SI bien PilaVacia(pila) ENTONCES Escribir( cadena balanceada ) EN OTRO CASO Escribir( cadena no balanceada ) SI DestruirPila(pila) Pilas. Ejemplo3 Algoritmo Lenguaje_L DESDE MPila IMPORTA TPila, CrearPila, MeterPila, SacarPila, DestruirPila CONSTANTES ENTER CHR(13) TIPOS TElemento = CARÁCTER VARIABLES c1, c2 : TElemento pila : TPila bien, ll, v : LÓGICO Inicio pila CrearPila() ll FALSO LEER(c1) MIENTRAS (c1 $ ) ( ll) HACER MeterPila(pila,c1,ll) LEER(c1) MIENTRAS Leer(c1) bien TRUE MIENTRAS (bien (c1 ENTER)) HACER SacarPila(pila,c2,v) bien ( v) (c1=c2) /* He podido sacar el elemnto y conicide */ SI (bien) ENTONCES Leer(c1) SI MIENTRAS SI (bien PilaVacia(pila))ENTONCES Escribir( Si pertenece ) EN OTRO CASO Escribir ( No pertenece ) SI DestruirPila(pila) 10

11 Pilas. Aplicaciones Aplicaciones complejas que se pueden solucionar con pilas: Expresiones Algebraicas Operadores: +, -, *, / Operandos: Letras mayúsculas Notación Infija: El operador binario está situado entre sus dos operandos A+ B Inconveniente: Son necesarias reglas de precedencia y uso de paréntesis para evitar ambigüedades A+B*C Pilas. Aplicaciones Notación Prefija El operador binario esta situado justo antes de sus dos operandos +AB Gramática: <expr_pref>::=<letra> <operador> <expr_pref><expr_pref> <letra> ::= A B... Z <operador> ::= + - * / Ejemplos: A+(B*C) +A*BC (A+B)*C *+ABC Notación Postfija El operador binario está situado justo después de sus dos operandos AB+ Gramática: <exp_post>::=<letra> <expr_post> <exp_post><operador> <letra> ::=A B... Z <operador> ::= + - * / Ejemplos: A+(B*C) ABC*+ (A+B)*C AB+C* 11

12 Pilas. Aplicaciones Ventaja: Usando expresiones prefijas y postfijas no son necesarias reglas de precedencia, ni uso de paréntesis. Las gramáticas que las generan son muy simples, y los algoritmos que las reconocen y evaluan muy fáciles Ejemplo 4: Algoritmo que evalúa una expresión en notación Postfija 1)Usaremos una pila 2)La expresión postfija se almacenará en un array de caracteres y será correcta 3)Los operadores serán: +, -, * y / 4)Los operandos serán letras mayúsculas (a cada una le podemos asignar un valor) Pilas. Ejemplo4 CONSTANTES MAX 20 TIPOS TArray = ARRAY[1..MAX] DE CARÁCTER TElemento=ENTERO FUNC Operando( c:caracter) :ENTERO VARIABLES res:entero CASO c SEA A : res 5 B : res 7 C : res -1 D : res 11 EN OTRO CASO res 0 CASO RESULTADO res 12

13 Pilas. Ejemplo4 FUNC Eval_postfija( exp: TArray; ultimo:natural):entero DESDE MPila IMPORTA TPila, CrearPila, MeterPila, SacarPila, DestruirPila Variables pila : TPila i, op1, op2, result : ENTERO c : CARÁCTER v,ll:lógico FUNC es_operador( c:carácter):lógico RESULTADO (c=`* ) (c=`/ ) (c=`+ ) (c=`- } Pilas. Ejemplo4 Inicio pila CrearPila() PARA i 1 HASTA ultimo HACER c exp[i] SI es_operador(c) ENTONCES SacarPila(pila,op2,v) SacarPila(pila,op1,v) CASO c SEA + :MeterPila(pila,op1+op2,ll) - : MeterPila(pila,op1-op2,ll) * : MeterPila(pila,op1*op2,ll) / : MeterPila(pila, op1/op2,ll) CASO EN OTRO CASO MeterPila(pila, Operando(c)) SI PARA SacarPila(pila,result) DestruirPila(pila) RESULTADO result Fin 13

14 Colas Definición Cola: es un grupo ordenado (con respecto al tiempo que llevan en él) de elementos homogéneos (todos del mismo Tipo) Acceso: los elementos se añaden por un extremo (final) y se sacan por el otro extremo (frente) Estructura FIFO (First Input First Output) = = > >?? > // :: ;; :: < < Colas. Operaciones Conjunto de Operaciones MODULO MCola DEICIÓN TIPOS TElemento =// cualquier tipo de datos TCola= // por definir FUNC CrearCola(): TCola // Crea una cola vacia FUNC ColaVacia( cola:tcola): LÓGICO /* Operación lógica que nos dice si la cola contiene algún elemento o no*/ 14

15 Colas. Operaciones FUNC ColaLlena( cola:tcola):lógico /* Operación lógica que nos dice si la cola está llena o no */ PROC MeterCola( cola: TCola; elem: TElemento) // Introduce un elemento al final de la cola/ PROC SacarCola( cola: TCola; elem: TElemento) // Saca un elemento del frente de la cola PROC DestruirCola( cola:tcola) // Destruye una cola previamente creada Fin Colas. Implementación 1) Con un Array Implementación Se deja fijo el frente de la cola y se mueve el final a medida que se añaden nuevos elementos (Idem Pila) Las operaciones Meter, Crear, ColaVacia y ColaLlena se implementan de una forma similar a sus análogas en Pilas La operación de Sacar es mas complicada: cada vez que saquemos un elemento de la cola se han de desplazar el resto una posición en el array, para hacer coincidir el frente con la primera posición del array Ventaja Simplicidad Inconveniente Ineficiente (colas con muchos elementos o elementos grandes) 15

16 QQ QQ WW Colas. Implementación Ejemplo: Meter(Cola, A ) Meter(cola, B ) Sacar(cola, elem) Desplazar AA BB CC DD EE EE EE EE EE EE EE EE EE EE LL MM NN OO PP PP PP PP PP PP PP PP PP PP RR SS TT UU VV VV VV VV VV VV VV VV VV VV WW AA BB CC DD EE EE EE EE EE EE EE EE EE EE WW ^^ `` aa bb bb bb bb bb bb bb bb bb bb FF GG HH II JJ KK LL XX YY Z Z [[ \\ ]] ^^ XX YY Z Z [[ \\ ]] Colas. Implementación Solución: Utilizar un indice para el frente y otro para el final y permitir que ambos fluctuen por el array Ventaja: operación Sacar más sencilla Inconveniente: Es posible que final sea igual a Maxcola (última casilla del array) y que la cola no esté llena 16

17 hh hh ii z z z Colas. Implementación Ejemplo: Meter(Cola, A ) Meter(cola, B ) cc dd ee ff gg gg gg gg gg gg gg gg gg gg cc dd ee ff gg gg gg gg gg gg gg gg gg gg jj kk ll mm nn ll oo pp jj qq mm rr ss oo pp jj kk ll mm nn ll oo pp jj qq mm rr ss oo tt Meter(cola, C ) Sacar(cola,elem elem) xx yy pp tt uu vv ww ww ww ww ww ww ww ww ww ww ˆˆ ˆˆ ˆˆ ˆˆ ˆˆ ˆˆ ˆˆ ˆˆ ˆˆ ˆˆ {{ }} ~ ~ }} {{ ~ ~ ƒ ƒ z {{ }} ~ ~ }} {{ ~ ~ ƒ ƒ Colas. Implementación Solución: Tratar al array como una Estructura Circular, donde la última posición va seguida de la primera Evitamos que el final de la cola alcance el final físico del array y no esté llena Operación Meter Añade elementos a las posiciones del array e incrementa el índice final Operación Sacar Más sencilla. Sólo se incrementa el índice frente a la siguiente posición 17

18 ÔÔ ÔÔ Š ÁÁ ÉÉ Ê ÈÈ ± ± ÔÔ ÕÕ ÔÔ Colas. Implementación Ejemplo: Š ª ª ««ŽŽ ŒŒ Meter(cola, G ) ª ª ««š š œœ žž ŸŸ œ œ žž Sacar(cola,elem elem) š š œœ žž ŸŸ œ œ žž Colas. Implementación µ µ ¹ ¹ º º»» µ µ ¼¼ ½½ ¾ ¾ º º ÁÁ Ãà ÀÀ  ÅÅ Como sabemos si la cola está vacía o llena? ÆÆ ÄÄ ÇÇ»» Meter(cola, L ) µ µ ¹ ¹ º º»» ³ ³ µ µ ¼¼ ½½ ¾ ¾ º º ² ² Ê ËË ËË ÌÌ ÍÍ ÎÎ ÏÏ ÎÎ ÎÎ ÐÐ ÑÑ ÏÏ ËË ËË ÙÙ ÚÚ ÛÛ ÜÜ ÝÝ ÛÛ ÞÞ ÙÙ ßß ÜÜ àà áá ÞÞ ÒÒ ÖÖ ÓÓ ØØ ÕÕ ÔÔ Sacar(cola,elem elem) ÒÒ ÓÓ ÙÙ ÚÚ ÛÛ ÜÜ ÝÝ ÛÛ ÞÞ ÙÙ ßß ÜÜ àà áá ÞÞ ÖÖ ÕÕ ââ ââ ãã ää åå ææ çç ææ èè éé ææ ââ ââ 18

19 êê êê ëë Solución: Colas. Implementación 1) Disponer de otra variable Contabilizará los elementos almacenados en la cola Variable=0 Cola vacía Variable=MaxCola Cola llena Inconveniente: añade más procesamiento a las operaciones Meter y Sacar 2) Frente apunte a la casilla del array que precede a la del elemento frente de la cola Solución elegida Colas. Implementación Ejemplo: òò óó ôô õõ öö ô ô íí òò øø õõ ùù ú ú ïï ïï îî ññ ðð ëë íí ìì Meter(cola, G ) ïï êê îî ññ ûû ðð ëë íí ìì òò óó ôô õõ öö ô ô íí òò øø õõ ùù ú ú êê Como saber si la cola está llena? Es necesario que la posición a la que apunta frente en cada momento este Reservada òò óó ôô õõ öö ô ô ìì òò øø õõ ùù ú ú ëë Cola Llena: final+1 1 =frente ïï îî ññ üü ðð ýý þþ ÿ ÿ íí ìì 19

20 Colas. Implementación Como saber si la cola está vacía? Cola Vacía: Frente = Final Sacar(cola,elem) Sacar(cola, Crear la cola (inicializarla vacía): frente =Maxcola (índice del array que precede al elemento frente de la cola) y final=maxcola Cola Vacía correcto (frente = final) Colas. Implementación Agrupamos en un registro los índices frente y final, junto con el array que contendrá los elementos de la cola CONSTANTES MAXCOLA 100 TIPOS TElemento = // Cualquier tipo de datos TCola = REGISTRO elementos:array[1..maxcola]de TElemento Maxcola Frente,Final : [1.. MAXCOLA] REGISTRO MaxCola 20

21 Colas. Implementación FUNC CrearCola():TCola VARIABLES cola: TCola cola.frente MAXCOLA cola.final MAXCOLA RESULTADO cola PROC DestruirCola( cola :TCola) // No hay que hacer nada. FUNC ColaLlena( cola:tcola ):LÓGICO RESULTADO (cola.final MOD MAXCOLA)+1 = cola.frente FUNC ColaVacia( cola:tcola ):LÓGICO RESULTADO cola.final = cola.frente Colas. Implementación PROC MeterCola( cola:tcola; elem:telemento) VARIABLES fin:natural fin (cola.final MOD MAXCOLA) + 1 cola.final fin cola.elementos[fin] elem PROC SacarCola( cola:tcola; elem:telemento) VARIABLES ini:natural ini (cola.frente MOD MAXCOLA) + 1 cola.frente ini elem cola.elementos[ini] 21

22 Colas. Implementación 2) Con listas enlazadas con Punteros Usamos dos variables de tipo puntero, frente y final, que apunten a los nodos que contienen los elementos frente y final!! "" ## $ $ %% && $ $ "" '' %% (( )) Que sucedería si intercambiáramos las posiciones de frente y final en la lista enlazada? Colas. Implementación Agrupamos las variables frente y final en un registro TIPOS TElemento = // cualquier tipo de datos TPuntero = PUNTERO A TNodo TNodo = REGISTRO valor : TElemento sig : TPuntero REGISTRO TCola = REGISTRO Frente : TPuntero Final : TPuntero REGISTRO -- ** + +,,.. //

23 Colas. Implementación FUNC CrearCola(): TCola VARIABLES cola:tcola cola.frente := NULO cola.final := NULO RESULTADO cola FUNC ColaVacia( cola: TCola):LÓGICO RESULTADO cola.frente = NULO PROC DestruirCola( cola: TCola) Variables nodo,sgte: TPuntero Inicio SI(cola.Frente NULO) ENTONCES sgte cola.frente MIENTRAS (sgte NULO) HACER nodo sgte sgte sgte^.sig ELIMINAR(nodo) MIENTRAS SI cola.frente NULO cola.final NULO Colas. Implementación PROC MeterCola( cola:tcola; elem:telemento) VARIABLES ptr: TPuntero Inicio ptr NUEVO(TNodo) ptr^.valor elem ptr^sig NULO SI ColaVacia(cola) ENTONCES cola.frente ptr EN OTRO CASO cola.final^.sig ptr SI cola.final nuevonodo PROC SacarCola ( cola:tcola; elem:telemento) VARIABLES temp : TipoPuntero temp cola.frente elem cola.frente^.valor cola.frente cola.frente^.sig SI (cola.frente=nulo) ENTONCES cola.final NULO SI ELIMINAR(temp) 23

24 Colas. Aplicaciones Ejemplo: Reconocimiento del lenguaje. L={W$W/W es una cadena que no contiene a$} Algoritmo Lenguaje_L DESDE MCola IMPORTA TCola, CrearCola, ColaVacia, SacarCola, MeterCola, DestruirCola CONSTANTES ENTER CHR(13) TIPOS TElemento = CARÁCTER VARIABLES bien : LÓGICO c1,c2 : TElemento cola : TCola cola CrearCola() LEER(c1) MIENTRAS (c1 $ ) HACER MeterCola(cola,c1) LEER(c1) MIENTRAS Colas. Aplicaciones Leer(c1) bien CIERTO MIENTRAS (bien (c1 ENTER) HACER SI ColaVacia(cola) ENTONCES bien FALSE EN OTRO CASO SacarCola(cola,c2) SI (c1 c2) ENTONCES bien FALSE EN OTRO CASO LEER(c1) SI SI MIENTRAS SI (bien ColaVacia(cola)) ENTONCES Escribir( Pertenece ) EN OTRO CASO Escribir( No pertenece ) SI DestruirCola(cola) 24

25 Listas Definición de lista Implementación - Estática - Dinámica Listas Definición: Una lista es una colección de elementos homogéneos (del mismo tipo), con una relación lineal entre ellos. Los elementos pueden o no estar ordenados con respecto a algún valor y se puede acceder a cualquier elemento de la lista. En realidad, las pilas y colas vistas en secciones anteriores son listas, con algunas restricciones. 25

26 Listas Operaciones sobre listas: Crear Esta vacía? Está llena? - De forma ordenada Insertar un elemento - De forma no ordenada Eliminar un elemento Imprimir Destruir Listas MÓDULO Mlistas DEICIÓN TIPOS TElemento =// cualquier tipo de datos TLista = // por definir FUNC CrearLista():TLista FUNC ListaVacia( lista:tlista): LÓGICO FUNC ListaLlena( lista:tlista): LÓGICO PROC InsertarLista( lista:tlista; elem:telemento) PROC EliminarLista( Lista:TLista; elem:telemento) PROC ImprimirLista(lista:TLista) PROC DestruirLista( lista: TLista) IMPLEMENTACIÓN... Fin 26

27 Listas Implementación: Representación secuencial Representación enlazada - Dinámica - Estática Listas Dinámicas Utilizaremos punteros para crear la lista enlazada de elementos. Las definiciones de tipos y la implementación de las operaciones se han visto. 27

28 Listas Estáticas Array de registros: Elemento. Enlace al siguiente elemento. Los registros pueden almacenarse en cualquier orden físico y se enlazarán a través del campo enlace. 28

29 Listas Inconveniente Variable estática Elección de Tamaño Máximo Debemos escribir nuestros propios algoritmos de manejo de memoria No disponemos de NUEVO y ELIMINAR. En el array de registros coexistirán dos listas: - Nuestra lista enlazada de elementos. - Una lista enlazada con el espacio libre disponible. Listas 29

30 Listas Consideraciones El cero (o cualquier otro valor distinto de [1..10]) hará las funciones de NULO en las listas enlazadas con punteros. Cuando no existe ningún elemento en la lista (lista vacía) sólo existirá la lista libre, que enlaza todas las posiciones del array. Si la lista se llena, no tendremos lista libre. Para simular el manejo de memoria real mediante asignación dinámica de memoria, consideramos el array y la variable Libre como globales al módulo de implementación de la lista. MÓDULO Mlistas DEICIÓN CONSTANTES VALOR_NULO 0 // Hace las funciones de NULO MAX 100 TIPOS TLista = [0..Max] TElemento = // cualquier tipo de datos TNodo = REGISTRO elemento : TElemento sig : TLista REGISTRO FUNC CrearLista():TLista FUNC ListaVacia( lista:tlista): LÓGICO PROC ListaLlena( lista: TLista): LÓGICO PROC ImprimirLista( lista: TLista) PROC InsertarLista( lista:tlista; elem:telemento) PROC EliminarLista( lista:tlista; elem:telemento) PROC DestruirLista( lista:tlista) 30

31 IMPLEMENTACIÓN TIPOS TMemoria = ARRAY [1..MAX] DE TNodo VARIABLES memoria : TMemoria libre : TLista FUNC CrearLista():TLista RESULTADO VALOR_NULO FUNC ListaVacia( lista:tlista): LÓGICO RESULTADO (lista = VALOR_NULO) FUNC ListaLlena( lista:tlista):lógico RESULTADO (libre = VALOR_NULO) Para los procedimientos NUEVO y ELIMINAR, necesitamos antes implementar las operaciones (NuevoNodo, EliminarNodo) equivalentes a las que usamos al trabajar con memoria dinámica. FUNC NuevoNodo(): Tlista VARIABLES ptr: TLista ptr libre SI (ptr Nulo) ENTONCES SI libre memoria[ptr]. sig RESULTADO ptr PROC EliminarNodo ( p : TLista) memoria[p].sig libre lbre p p VALOR_NULO 31

32 PROC ImprimirLista( lista : TLista) VARIABLES ptr : TLista ptr lista MIENTRAS (ptr VALOR_NULO) HACER Escribir(memoria[ptr].elemento) ptr memoria[ptr].sig MIENTRAS PROC InsertarLista( lista: TLista; elem: TElemento) VARIABLES ptr : TLista ptr NuevoNodo() SI (ptr VALOR_NULO) ENTONCES memoria[ptr].elemento elem memoria[ptr].sig lista lista ptr SI Depende de TElemento PROC EliminarLista ( lista: TLista; elem :TElemento) VARIABLES pav, pret : TLista Fin pav lista pret Nulo // puntero avanzado // puntero retrasado MIENTRAS (memoria[pav].elemento elem) HACER pret pav pav memoria[pav].sig MIENTRAS SI (pret = VALOR_NULO) ENTONCES lista memoria[lista].sig EN OTRO CASO memoria[pret].sig memoria[pav].sig SI EliminarNodo(pav) Suponemos que el elemento a borrar está en la lista 32

33 PROC DestruirLista( lista: TLista) Variables aux: TLista MIENTRAS (lista VALOR_NULO) HACER aux lista lista memoria[lista].sig EliminarNodo(aux) // Mlista Libre 1 PARA ptr 1 HASTA (Max-1) HACER memoria[ptr].sig ptr + 1 PARA memoria[max].enlace VALOR_NULO // Mlista Listas enlazadas circulares Implementación estática o dinámica. El campo de enlace del último nodo apunta al primer nodo de la lista, en lugar de tener el valor NULO. No existe ni primer ni último nodo. Tenemos un anillo de elementos enlazados unos con otros. 33

34 Listas enlazadas circulares Es conveniente, aunque no necesario, tener un enlace (puntero o índice) al último nodo lógico de la lista. Así podemos acceder facilmente a ambos extremos de la misma. p Una lista circular vacía vendrá representada por un valor NULO (o VALOR_NULO). Listas enlazadas circulares Ejemplo: (usando una implementación estática) Ejemplo: (usando una implementación estática) PROC ImprimirLista( lista:tlista) VARIABLES ptr : TLista ptr lista SI (ptr VALOR_NULO) ENTONCES REPETIR Escribir(memoria[ptr].elemento) ptr memoria[ptr].sig HASTA QUE ptr = lista SI Fin 34

35 Listas enlazadas circulares Con una lista enlazada circular es muy fácil implementar una Cola, sin tener que disponer de un registro con dos campos para el frente y para el final. Frente Final p Implementación Listas doblemente enlazadas Es una lista enlazada en la que cada nodo tiene al menos tres campos: - Elemento. El dato de la lista. - Enlace al nodo anterior. - Enlace al nodo siguiente. Los algoritmos para las operaciones sobre listas doblemente enlazadas son normalmente más complicados. Pueden ser recorridas fácilmente en ambos sentidos. lista Implementación 35

36 Listas doblemente enlazadas Una lista doblemente enlazada puede modificarse para obtener una estructura circular de la misma lista Implementación Listas NIVEL DE UTILIZACIÓN Estructura muy utilizada. Ejemplo: Manejo de tablas hash con el método de encadenamiento para el tratamiento de sinónimos. Utilizaríamos un array de listas como tabla hash. (Lo que en el primer tema se llamó Encadenamiento) Las listas tienen como elementos cadenas de caracteres. 36

37 Modulo Mhash DEICIÓN DESDE MLista IMPORTA Tlista CONSTANTES MAXCAD 20 MAXELE 100 TIPOS TCadena = ARRAY [0..MAXCAD-1] DE CARÁCTER TElemento = TCadena TRango = [0.. MAXELE-1] TTablaHash= ARRAY TRango DE TLista PROC Almacenamiento( tabla:ttablahash; dato:telemento) FUNC Búsqueda( tabla:ttablahash; dato:telemento):lógico PROC Eliminación( tabla:ttablahash; dato:telemento) IMPLEMENTACIÓN PROC Almacenamiento( tabla:ttablahash; dato:telemento) Insertar(tabla[Hash(dato)],dato) FUNC Búsqueda( tabla:ttablahash; dato:telemento):lógico RESULTADO Buscar(tabla[Hash(dato)],dato) PROC Eliminación( tabla:ttablahash; dato:telemento) Eliminar(tabla[Hash(dato)],dato) Fin (* Mhash *) 37

38 Árboles binarios Definición: es un conjunto finito de elementos que está vacío o está partido en tres subconjuntos disjuntos. El primer subconjunto contiene un único elemento llamado la raíz del árbol binario. Los otros dos subconjuntos son a su vez árboles binarios, llamados subárboles izquierdo y derecho. El subárbol izquierdo o derecho puede estar vacío. Cada elemento de un árbol binario se denomina nodo. Árboles binarios Un método convencional para representar gráficamente un árbol binario es: B A D E F C Consta de 9 nodos. A es el nodo raiz. El subárbol izquierdo tiene como nodo raiz B. El subárbol derecho tiene C como raiz. La ausencia de ramas indica un árbol vacío. G H I 38

39 Árboles binarios Si A es la raíz de un árbol binario y B es la raíz de su subárbol izquierdo o derecho, se dice que A es el padre de B y B es el hijo izquierdo o derecho de A. Un nodo que no tiene hijos se denomina nodo hoja. Un nodo n1 es un antecesor de un nodo n2 (y n2 es un descendiente de n1) si n1 es el padre de n2 o el padre de algún antecesor de n2. Un nodo n2 es un descendiente izquierdo de un nodo n1 si n2 es el hijo izquierdo de n1 o un descendiente del hijo izquierdo de n1. Un descendiente derecho se puede definir de forma similar. Dos nodos son hermanos si son los hijos izquierdo y derecho del mismo padre. Árboles binarios Árbol estrictamente binario: árbol binario en que cada nodo no-hoja tiene subárboles izquierdo y derecho no vacíos. Nivel de un nodo en un árbol binario: La raíz tiene nivel 0, y el nivel de cualquier otro nodo en el árbol es uno más que el nivel de su padre. Profundidad de un árbol binario: máximo nivel de cualquier hoja del árbol. la longitud del camino más largo desde la raiz hasta una hoja. Árbol binario completo de profundidad d: árbol estrictamente binario con todas sus hojas con nivel d. 39

40 Árboles binarios Un árbol binario contiene m nodos en el nivel L. Contiene como máximo 2m nodos en el nivel L+1. Puede contener como máximo 2 L nodos en el nivel L Un árbol binario completo de profunfidad d contiene exactamente 2 L nodos en cada nivel L, entre 0 y d El número total de nodos en un árbol binario completo de profundidad d es: t n = d = 2 d+1-1 Árboles binarios Árbol ternario: conjunto finito de elementos que está vacío o está partido en cuatro subconjuntos disjuntos. El primer subconjunto contiene un único elemento llamado la raíz del árbol. Los otros tres subconjuntos son a su vez árboles. Árbol n-ario: conjunto finito de elementos que está vacío o está partido en n+1 subconjuntos disjuntos. El primer subconjunto contiene un único elemento llamado la raíz del árbol. Los otros n subconjuntos son a su vez árboles. 40

41 Árboles binarios Operaciones sobre árboles: Crear árbol vacío Crear árbol dada su raíz, y sus hijos derecho e Izquierdo Esta vacío? Está lleno? Devolver el contenido del nodo raíz Devolver el subárbol derecho Devolver el subárbol derecho Destruir Módulo MArbolBin DEICIÓN TIPOS TElemento = // Cualquier tipo de datos TArbolBin = PUNTERO A TNodoArbolBin TNodoArbolBin = REGISTRO dato : TElemento izq,der : TArbolBin REGISTRO FUNC CrearArbolVacio():TArbolBin FUNC CrearArbol( raiz:telemento; izq, dch: TArbolBin ): TArbolBin FUNC ArbolVacio( arbol:tarbolbin):lógico FUNC Info( arbol:tarbolbin):telemento FUNC Izq( arbol:tarbolbin): TArbolBin FUNC Der( arbol: TArbolBin): TArbolBin PROC DestruirArbol( arbol: TArbolBin) Implementación dinámica 41

42 IMPLEMENTACIÓN FUNC CrearArbolVacio():TArbolBin RESULTADO NULO FUNC CrearArbol( raiz:telemento; izq, dch: TArbolBin ): TArbolBin VARIABLES arbol : TArbolBin arbol NUEVO(TNodoArbolBin) arbol^.dato raiz arbol^.izq izq arbol^.der dch RESULTADO arbol FUNC ArbolVacio( arbol:tarbolbin):lógico RESULTADO (arbol = NULO) FUNC Info( arbol:tarbolbin):telemento RESULTADO arbol^.dato FUNC Izq( arbol:tarbolbin): TArbolBin RESULTADO arbol^.izq FUNC Der( arbol: TArbolBin): TArbolBin RESULTADO arbol^.der 42

43 PROC DestruirArbol( arbol: TArbolBin) SI ( ArbolVacio(arbol)) ENTONCES DestruirArbol(arbol^.der) DestruirArbol(arbol^.izq) ELIMINAR(arbol) SI // MArbolBin Módulo MArbolBinEstático DEICIÖN CONSTANTES VALOR_NULO 0 MAX 100 TIPOS TArbolBin = [0..MAX] TNodoArbolBin = REGISTRO dato : TElemento izq,der : TArbolBin REGISTRO FUNC CrearArbolVacio():TArbolBin Implementación estática Se deja propuesto como ejercicio la de los procedimientos y funciones para una implementación estática de un arbol binario FUNC CrearArbol( raiz:telemento; izq, dch: TArbolBin ): TArbolBin FUNC ArbolVacio( arbol:tarbolbin):lógico FUNC Info( arbol:tarbolbin):telemento FUNC Izq( arbol:tarbolbin): TArbolBin FUNC Der( arbol: TArbolBin): TArbolBin PROC DestruirArbol( arbol: TArbolBin) 43

44 Árboles binarios NIVEL DE UTILIZACIÓN Estructura de datos muy útil cuando se deben tomar decisiones de "dos caminos Muy utilizado en aplicaciones relacionadas con expresiones aritméticas. Ejemplos: (12-3)*(4+1) * Árboles binarios Ejemplo: Diseñemos un algoritmo para evaluar una expresión aritmética que está almacenada en un árbol binario. Tipos TipoDecision = (Operador, Operando) TElemento = REGISTRO CASO contenido:tipodecision SEA Operador: oper: CARÁCTER Operando: val: REAL CASO REGISTRO 44

45 FUNC Eval( arbol:tarbolbin):real VARIABLES dato:telemento; result: REAL dato Info(arbol) SI (dato.contenido = Operando) ENTONCES result dato.val EN OTRO CASO CASO dato.oper SEA '+': result Eval(Izq(arbol))+Eval(Der(arbol)) '-': result Eval(Izq(arbol))-Eval(Der(arbol)) '*': result Eval(Izq(arbol))*Eval(Der(arbol)) '/': result Eval(Izq(arbol))/Eval(Der(arbol)) CASO SI RESULTADO result Fin Árboles binarios de búsqueda La estructura lista enlazada es lineal Búsqueda? La estructura árbol Búsqueda más eficiente? Siempre que los datos se distribuyan de forma adecuada Árbol binario de búsqueda 45

46 Árboles binarios de búsqueda Definición: árbol binario en el que el subárbol izquierdo de cualquier nodo (si no está vacío) contiene valores menores que el que contiene dicho nodo, y el subárbol derecho (si no está vacío) contiene valores mayores. E Ejemplo: B H A D F I C G Árboles binarios de búsqueda Operaciones: Crear Buscar Insertar Suprimir Imprimir + Las definidas para un árbol binario general 46

47 Módulo MABB Definición TIPOS TRecorrido = (InOrden,PreOrden,PostOrden) TClave = ENTERO TElemento = REGISTRO clave:tclave... REGISTRO TABB = PUNTERO A TNodoABB TNodoABB = REGISTRO izq,der:tabb elem:telemento REGISTRO // Operaciones típicas de los árboles FUNC CrearABB():TABB FUNC ABBVacio( arbol:tabb):lógico FUNC InfoABB( arbol:tabb):telemento FUNC IzqABB( arbol:tabb): TABB FUNC DerABB( arbol: TABB): TABB PROC DestruirABB( arbol: TABB) // Operaciones Exclusivas de los árboles binarios de búsqueda PROC BuscarABB( arbol:tabb; c:tclave; dato:telemento; EnArbol:LÓGICO) PROC InsertarABB( arbol:tabb; dato:telemento) PROC SuprimirABB( arbol:tabb; c:tclave) PROC ImprimirABB( arbol:tabb; rec:trecorrido) IMPLEMENTACIÓN FUNC CrearABB():TABB RESULTADO NULO FUNC ABBVacio( arbol:tabb):lógico RESULTADO (arbol = NULO) FUNC InfoABB( arbol:tabb):telemento RESULTADO arbol^.dato 47

48 FUNC IzqABB( arbol:tabb): TABB RESULTADO arbol^.izq FUNC DerABB( arbol: TABB): TABB RESULTADO arbol^.der PROC DestruirABB( arbol: TABB) DestruirABB(arbol^.izq) DestruirABB(arbol^.dch) ELIMINAR(arbol) PROC BuscarABB( arbol:tabb; c:tclave; dato:telemento; EnArbol:LÓGICO) // Solución Iterativa VARIABLES ptrarbol: TABB ele:telemento EnArbol FALSO ptrarbol arbol MIENTRAS (( ABBVacio(ptrArbol)) ( EnArbol)) HACER ele = InfoABB(ptrArbol) SI (ele.clave = c) ENTONCES SI MIENTRAS EnArbol CIERTO dato ele SINO SI (c < ele.clave) ENTONCES ptrarbol IzqABB(ptrArbol) EN OTRO CASO ptrarbol DechABB(ptrArbol) 48

49 PROC BuscarABB( arbol:tabb; c:tclave; dato:telemento; EnArbol:LÓGICO) // Solución Recursiva VARIABLES ele:telemento SI (ABBVacio(arbol)) ENTONCES EnArbol FALSO EN OTRO CASO ele = InfoABB(arbol) SI (ele.clave = c) ENTONCES SI EnArbol CIERTO dato ele SINO SI (c < ele.clave ) ENTONCES BuscarABB(IzqABB(arbol),c,dato,EnArbol) EN OTRO CASO BuscarABB(DechABB(arbol),c,dato,EnArbol) SI Árboles binarios de búsqueda Consideraciones acerca de la operación de inserción. B D F A B Entrada: ABCDEFG C A C E G B D E Entrada: DBFACEG A D F G Los mismos datos, insertados en orden diferente, producirán árboles con formas o distribuciones de elementos muy distintas. C E G F Entrada: BADCGFE 49

50 Árboles binarios de búsqueda PROC InsertarABB( arbol:tabb; dato:telemento) // Solución Iterativa VARIABLES nuevonodo,pav,pret:tabb clavenueva:tclave ele:telemento Inicio nuevonodo NUEVO(TNodoABB) nuevonodo^.izq NULO nuevonodo^.der NULO nuevonodo^.elem dato clavenueva dato.clave Los pav mismos arbol datos, insertados // Puntero en orden Avanzado diferente, pret producirán NULO árboles // con Puntero Retrasado formas o distribuciones de elementos muy distintas. MIENTRAS (pav NULO) HACER Árboles binarios de búsqueda pret pav ele = pav^.elem SI (clavenueva < ele.clave ) ENTONCES pav pav^.izq // Voy hacia el hijo izquierdo EN OTRO CASO pav pav^.dch // Voy hacia el hijo derecho SI MIENTRAS ele = pret^.elem SI (clavenueva < ele.clave ) ENTONCES pret ^.izq nuevonodo // Inserto en el hijo izquierdo EN OTRO CASO pret ^.dch nuevonodo // Inserto en el hijo izquierdo SI 50

51 Árboles binarios de búsqueda PROC InsertarABB( arbol:tabb; dato:telemento) VARIABLES Por qué usamos ele:telemento // Solución Recursiva SI (ABBVacio(arbol)) ENTONCES arbol NUEVO(TNodoABB) arbol^.izq NULO arbol^.der NULO arbol^.elem dato EN OTRO CASO ele = InfoABB(arbol) SI (dato.clave < ele.clave) ENTONCES InsertarABB(arbol^.izq, dato) EN OTRO CASO InsertarABB(arbol^.dch, dato) Los mismos datos, insertados en orden diferente, SI producirán árboles con formas SIo distribuciones de elementos muy distintas. Por qué usamos arbol^.izq y arbol^.dch en vez de IzqABB(arbol) y DechABB(arbol? Pasos: Árboles binarios de búsqueda Consideraciones acerca de la operación de suprimir. 1) Encontrar el nodo a suprimir. Equivalente a Buscar 2) Eliminarlo del árbol. 3 casos padre de x x ex-padre de x Caso 1 51

52 Árboles binarios de búsqueda padre de x ex-padre de x x Caso 2 hijo de x ex-hijo de x B J Q B J P Eliminar Q K L N R Z K L N R z Caso 3 M P M PROC SuprimirABB( arbol:tabb; c:tclave) VARIABLES // Solución Iterativa pav,pret:tabb pav arbol pret NULO //Busco el elemento MIENTRAS (pav NULO) (pav^.elem.clave c) HACER pret pav SI (c < pav^.elem.clave) ENTONCES pav pav^.izq EN OTRO CASO pav pav^.der SI MIENTRAS SI (pav = NULO) ENTONCES // No hacer Nada, ya que no hay nada que borrar SINO SI (pav = arbol) ENTONCES // equivalente a: (pret = NULO) SuprimirNodo(arbol) SINO SI (pret^.izq = pav) ENTONCES SuprimirNodo(pret^.izq) EN OTRO CASO SuprimirNodo(pret^.der) SI 52

53 PROC SuprimirNodo( arbol:tabb) Variables // Solución Iterativa temp,ant:tabb Inicio temp arbol SI (arbol^.der = NULO) ENTONCES arbol arbol^.izq // Casos sin Hijos ó sin Hijo derecho SINO SI (arbol^.izq = NULO) ENTONCES arbol arbol^.der EN OTRO CASO // Caso de Sólo Hijo derecho // Caso Hijos derecho y izquierdo temp arbol^.izq // Busco el mayor hijo derecho del hijo izquierdo ant arbol MIENTRAS (temp^.der <> NULO) HACER anterior temp temp temp^.der MIENTRAS arbol^.elem temp^.elem SI (anterior = arbol) ENTONCES anterior^.izq temp^.izq EN OTRO CASO anterior^.der temp^.izq SI SI ELIMINAR(temp) 0 o 1 hijo 1 hijo 2 hijos PROC SuprimirABB( arbol:tabb; c:tclave) // Solución Recursiva VARIABLES ele:telemento SI (ABBVacio(arbol)) ENTONCES // No hacer Nada, ya que no hay nada que borrar EN OTRO CASO SI SI ele = InfoABB(arbol) SI (ele.clave = c) ENTONCES SuprimirNodo(arbol) SINO SI (c < ele.clave ) ENTONCES SuprimirABB(arbol^.izq,c) EN OTRO CASO SuprimirABB(arbol^.dch,c) Por qué usamos arbol^.izq y arbol^.dch en vez de IzqABB(arbol) y DechABB(arbol? 53

54 PROC SuprimirNodo( arbol:tabb) // Solución Recursiva Variables temp:tabb 0 o 1 hijo ele :TElemento FUNC MayorHijoDerecho( arbol:tipoabbúsqueda):telemento // Solución Recursiva SI (ABBVacio(DchABB(arbol))) ENTONCES RESULTADO InfoABB(arbol) EN OTRO CASO 1 hijo RESULTADO MayorHijoDerecho(DchABB(arbol)) SI SI (arbol^.der = NULO) ENTONCES temp arbol arbol arbol^.izq// Casos sin Hijos ó sin Hijo derecho ELIMINAR(temp) SINO SI (arbol^.izq = NULO) ENTONCES temp arbol arbol arbol^.der// Caso de Sólo Hijo derecho ELIMINAR(temp) EN OTRO CASO // Caso Hijos derecho y izquierdo ele MayorHijoDerecho(IzqABB(arbol)) arbol^.elem ele SuprimirABB(arbol^.izq,ele.clave) SI Árboles binarios de búsqueda Consideraciones acerca de la operación de imprimir. Recorrer un árbol es "visitar" todos sus nodos para llevar a cabo algún proceso como por ejemplo imprimir los elementos que contiene. Cómo imprimir los elementos de un árbol? en qué orden?. 54

55 Árboles binarios de búsqueda Para recorrer un árbol binario en general (de búsqueda o no), podemos hacerlo de tres formas distintas: a) Recorrido InOrden. 1) Recorrer el subárbol izquierdo en InOrden Pasos: 2) "Visitar" el valor del nodo raiz y procesarlo 3) Recorrer el subárbol derecho en InOrden b) Recorrido PreOrden. 1) "Visitar" el valor del nodo raiz y procesarlo Pasos: 2) Recorrer el subárbol izquierdo en PreOrden 3) Recorrer el subárbol derecho en PreOrden c) Recorrido PostOrden. 1) Recorrer el subárbol izquierdo en PostOrden Pasos: 2) Recorrer el subárbol derecho en PostOrden 3) "Visitar" el valor del nodo raiz y procesarlo PROC Imp_InOrden( arbol:tabb) SI ( ABBVacio(arbol)) ENTONCES Imp_InOrden(IzqABB(arbol)) ImpNodo(InfoABB(arbol)) Imp_InOrden(DerABB(arbol)) SI PROC Imp_PreOrden( arbol:tabb) SI ( ABBVacio(arbol)) ENTONCES ImpNodo(InfoABB(arbol)) Imp_PreOrden(IzqABB(arbol)) Imp_PreOrden(DerABB(arbol)) SI 55

56 PROC Imp_PostOrden( arbol:tabb) SI ( ABBVacio(arbol)) ENTONCES Imp_PostOrden(IzqABB(arbol)) Imp_PostOrden(DchABB(arbol)) ImpNodo(InfoABB(arbol)) SI Fin PROC ImprimirABB( arbol:tabb; rec:trecorrido) Inicio CASE rec SEA inorden: Imp_InOrden(arbol) preorden: Imp_PreOrden(arbol) postorden: Imp_PostOrden(arbol) CASO Fin Fin (* MArbolBinarioBusqueda *) Árboles binarios de búsqueda Ejemplo: P F S B G H R T Y W Z El recorrido InOrden mostraría: BFGHPRSTWYZ El recorrido PreOrden: PFBHGSRYTWZ El recorrido PostOrden: BGHFRWTZYSP 56

57 Árboles binarios de búsqueda Nivel de utilización Aplicaciones en las que estén implicas operaciones de búsqueda de elementos Ejemplo: Supongamos que deseamos implementar un diccionario inglés/español en que la búsqueda de la traducción de una palabra inglesa sea rápida. Para ello podemos usar un árbol binario de búsqueda en el que el tipo elemento sea un registro con la palabra en inglés (que será la clave) y la palabra en español. Árboles binarios de búsqueda ALGORITMO Diccionario DESE MABB IMPORTA TABB, CrearABB, DestruirABB, BuscarABB, InsertarABB, SuprimirABB, ImprimirABB CONSTANTES MAXCAD = 20 TIPOS TCadena = ARRAY [0..MAXCAD-1] DE CARÁCTER TDic = TABB Tclave = TCadena TElemento = REGISTRO clave:tclave // Palabra inglés traducción: TCadena // Palabra Español REGISTRO 57

58 Árboles binarios de búsqueda PROC InsPalDic( d:tdic; pal: TElemento) InsertarABB(d,pal) PROC BuscaPalDic( d:tdic; inglés:tclave ; pal: TElemento; encontrado:lógico) BuscarABB(d,inglés,pal,encontrado) PROC BorrarPalDic( d:tdic; inglés:tclave) SuprimirABB(d,inglés) Bibliografía : ; < = >? 8 9 : A B : C : : E F G F H I J K I L M N J O P Q K O Q P I J R S T I O U J F E V W X Y Z [ ; Z \ ] \ ^ Y F _ ] ` a [ b c d \ e e f C Y g V a [ h V a \ ] [ Y [ Z V ; i j [ k l = < = F 6 7 m n D 9 o o? m n D 9 A ; : F H P U p P I q I K r s t S t u v v w x L p U P r O q U J y S J O P Q K O Q P I J R S R I O U J M U z { S O U J w _ ] ` a [ b d \ e o o o F 6 7 E 9 } C o o? E 9 } C G ~ F S J U L Q K r s t R S P U z L S q I J K U t u v v w E V W X Y Z [ ; Z \ ] \ ^ Y F a V Y g \ ] V d [ e o o o F 6 7 E ƒ n o l? E ƒ n E F N L L S t p Q I { S R S P U p P I q I K r s t u v v F ; Z \ ] \ ^ Y ; i j V ] \ [ 9 Z \ i i Y c ~ V i e V o o l F 58