UNIVERSIDAD TECNICA DE ORURO FACULTAD NACIONAL DE INGENIERIA INGENIERIA DE SISTEMAS E INFORMATICA

TEXTO GUIA:

ESTRUCTURA DE DATOS

SIS2204

Ing. Juan Gregorio Choque Uño Fecha de Realización: Marzo del 2008
Docente:

Oruro - Bolivia

1

2

CONTENIDO
INTRODUCCION........................................................................................................................6
1.1 ESTRUCTURA DE DATOS. ............................................................................................................................................6 1.2 OPERACIONES SOBRE ESTRUCTURAS DE DATOS. .............................................................................................9

PILAS Y COLAS.......................................................................................................................10
2.1 PILAS. ...............................................................................................................................................................................10 ..................................................................................................................................................................................................16 2.2 COLAS. .............................................................................................................................................................................17 2.3 COLAS CIRCULARES. ..................................................................................................................................................19 ELIMINAR EL NODO DELANTERO DE LA COLA.......................................................................................................20 2.4 APLICACIONES DE LISTAS RESTRINGIDAS. .......................................................................................................22

ARCHIVOS, REGISTROS Y CAMPOS....................................................................................26
3.1 ARCHIVOS ......................................................................................................................................................................26 3.2 TIPOS DE ARCHIVOS. ..................................................................................................................................................26 3.3 REGISTROS Y CAMPOS. .............................................................................................................................................28

TRATAMIENTO DE ARCHIVOS..............................................................................................30
4.1 INTRODUCCION ............................................................................................................................................................30 4.2 OPERACIONES SOBRE ARCHIVOS .........................................................................................................................30 ADICION DE DATOS ........................................................................................................................................................31 ELIMINAR DATOS ...........................................................................................................................................................32 CONSULTAS DE DATOS .................................................................................................................................................33 BUSQUEDA DE DATOS ...................................................................................................................................................34 4.3 PARTICION DE ARCHIVOS ........................................................................................................................................35 PARTICION POR CONTENIDO .......................................................................................................................................36 PARTICION POR UNA SECUENCIA " P " DADA .........................................................................................................36 PARTICIÓN DE ARCHIVOS POR TRAMOS ORDENADOS ........................................................................................37 4.4 MEZCLAS DE ARCHIVOS ...........................................................................................................................................38 MEZCLA POR CONTENIDO TOTAL .............................................................................................................................39 MEZCLA POR SECUENCIAS " P " ..................................................................................................................................39 MEZCLA POR TRAMOS ORDENADAS .........................................................................................................................41 4.5 ORDENACIÓN EXTERNA ...........................................................................................................................................42 ORDENACIÓN POR MEZCLA DIRECTA ......................................................................................................................42 ORDENACIÓN POR VON NEWMAN .............................................................................................................................45 ORDENACIÓN POR MEZCLA EQUILIBRADA ............................................................................................................47 ORDENACIÓN POR DIGITOS .........................................................................................................................................49

3

...........................................................................................................................................63 5......................................................74 ELIMINAR DATOS ...................................................4 LISTAS DOBLEMENTE ENLAZADAS..............................................1 LISTAS ENCADENADAS ..............................................................................................................................................................................................59 OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES .........................................................................................................................80 6.................................88 BÚSQUEDA DE DATOS .................................................................................................................53 OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS ......................82 INSERCIÓN DE DATOS .......................................................................3 LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES.................................................................................69 5..........109 4 .......................................................................73 RECORRIDO ................................................1 DEFINICION...................................................................................................................................................67 ELIMINAR DATOS ..66 INSERCION DE DATOS .......................................................................................................... ..............................................................................................................................................................................................................................................................................................93 IMPLEMENTACIÓN DE LA INSERCIÓN ................................78 MATRIZ DE ADYACENCIA ........................................81 DEFINICION ................55 INSERCION DE DATOS ................................5 ÁRBOLES EQUILIBRADOS O AVL ...........................................................................61 INSERCION DE DATOS .................................................................... ................................................88 ELIMINAR UN DATO ......................................................................................................................................................................................................................................................................................................82 OPERACIONES BASICAS ......................................................................................................................72 OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS CIRCULARES............................ ....................................................................................................................................... ...............................................78 6... .................................................................................................................................................................................78 REPRESENTACIÓN ....................................................2 LISTAS SIMPLEMENTE ENLAZADAS ...........................................................................................................................................................................................................................52 5............54 BUSQUEDA ...............................................65 RECORRIDO ....................................................................................................................................................103 IMPLEMENTACIÓN DE LA ELIMINACIÓN ............................................................................................................................52 5..........................................................................................................................................................................................................................................................61 ELIMINAR DATOS ...............................................................................92 DEFINICIÓN .....................................................................................................................................91 6................................................................................................................................................................................................................................................................................................................................................................................76 ÁRBOLES.52 TIPOS DE LISTAS.................79 6............................................................................................................................................................................................................64 OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS................................................................................................................................................................... ...........................79 ESTRUCTURA DINÁMICA PURA ...............................3 ARBOL BINARIO .....LISTAS ENCADENADAS................................................60 RECORRIDO ..........................................................................................................................................................................................79 LISTA DE ADYACENCIA .......................90 6............................................................................................... .....................58 5......................................................................................................................4 ÁRBOLES BINARIOS DE EXPRESIONES.................................................................................................2 CONCEPTOS ASOCIADOS .........................................................................................................................................................................55 ELIMINAR DATOS ...........................................................93 INSERCIÓN EN AVL .....................5 LISTAS CIRCULARES DOBLEMENTE ENLAZADAS...........................................................................................................................................................................................................................................................................................................................................................................................................................90 CONSTRUCCIÓN A PARTIR DE UNA EXPRESIÓN EN NOTACIÓN CONVENCIONAL..................100 BORRADO EN AVL ........................................................................60 BUSQUEDA .......................................................................................................................................................................73 INSERCION DE DATOS .......................................................................................54 RECORRIDO ......................................

......................................................... ........................................................................................... ...........2 ALMACENAMIENTO DE UN GRAFO EN MEMORIA........................................................................................................3 APLICACIONES...................................................................................ÁRBOLES BINARIOS DE EXPRESIONES.................. ..................126 5 .............................115 7...............................122 7..............................................................................115 7...113 GRAFOS................................................................................................1 DEFINICIONES................................

OR.1 Estructura de Datos 1. False y como operaciones las definidas en el álgebra de Boole (AND.Análisis de datos y operaciones 2. >=.. Una estructura de datos es la implementación física de un tipo de datos abstracto. Se denominan tipos de datos ordinales a aquellos en los que cada valor tiene un predecesor (excepto el primero). y un único sucesor (excepto el último): Carácter.Elección del Tipo de Datos Abstracto 3.1 ESTRUCTURA DE DATOS. >. predecesor (Pred) y sucesor (Suc) de un elemento. Entero. <>) Se denominan tipos de datos escalares a aquellos en los que el conjunto de valores está ordenado y cada valor es atómico: Carácter. CONTENIDO 1. el diseño deberá realizarse siguiendo tres pasos fundamentales: 1.TEMA 1 INTRODUCCION OBJETIVOS Conceptuar las diferentes etapas por las que atraviesa el procesamiento de datos desde la abstracción de los mismos hasta la obtención de los resultados en la computadora. Real y Booleano. Debido al proceso de abstracción. multiplicación y división entera TDA Real: tiene como tipo el conjunto de números reales y como operaciones la suma. Los lenguajes de alto nivel suelen presentar tres funciones adicionales asociadas a los tipos de datos ordinales: posición (Ord)..2 Operaciones Sobre Estructuras de Datos 1. Entero y Booleano. =. y como operaciones la suma.. NOT) TDA Carácter: tiene como tipo el conjunto de caracteres definido por un alfabeto dado y como operaciones todos los operadores relacionales (<. resta multiplicación y división TDA Booleano: tiene como tipo el conjunto de valores booleanos True.Elección de la implementación Tipos de datos básicos TDA Entero: tiene como tipo el conjunto de números enteros. 6 . <=. resta. Estructuras de datos y tipos de datos abstractos (TDA) Un tipo de datos es una colección de valores Un tipo de datos abstracto (TDA) es un tipo de datos definido de forma única mediante un tipo y un conjunto dado de operaciones definidas sobre el tipo.

Ahora bien. tal que cada elemento tiene un predecesor (excepto el primero) y un sucesor (excepto el último) y los operadores asociados son: • Insertar: inserta un elemento x. Una de ellas es mediante arreglos. TDA Arreglo: colección homogénea de longitud fija tal que cada una de sus componentes pueden ser accedidas individualmente mediante uno o varios índices. Estructura Es un conjunto de elementos entrelazados regidos por una serie de leyes. La lista es una estructura dinámica ya que su longitud dependerá del número de elementos que tenga. intersección y diferencia de conjuntos. Estructura de Datos Una estructura de datos es una colección organizada de elementos de datos bajo las leyes de la informática. con los cuales se forman las estructuras de datos que incluyen los diferentes lenguajes: 7 . que es dinámica independientemente de su implementación. aumentará al insertar y se reducirá al suprimir. que serán de tipo ordinal. se realiza mediante una implementación estática. En general. son los tipos de datos. Estos elementos. la lista puede implementarse de formas muy diferentes. Las operaciones asociadas a los tipos compuestos o estructurados son las de almacenar y recuperar sus componentes individuales. Por ejemplo. En general el término “lista” se utiliza cuando el TDA se implementa sobre memoria principal mientras que “secuencia” suele reservarse para implementaciones sobre memoria secundaria. la lista. las estructuras que nos presenta el mundo real están regidas por las leyes físicas. TDA Registro: tipo de datos heterogéneo compuesto por un número fijo de componentes denominadas campos a las que se accede mediante un selector de campo. dado que son divisibles en componentes que pueden ser accedidas individualmente. Los TDA básicos son los utilizados con mayor frecuencia. un TDA muy utilizado en aplicaciones informáticas es el TDA lista definido de la siguiente forma: TDA lista (o Secuencia): colección homogénea de datos. El TDA Conjunto no es estructurado ya que no está organizado mediante el modo de acceso a sus componentes individuales. o ladrillos. en una posición p de la lista • Localizar: localiza la posición p en la que se encuentra el dato x • Recuperar: encuentra el elemento x que esta en la posición p • Suprimir: elimina de la lista el elemento de la posición p • Suprimir_dato: elimina de la lista cualquier aparición del elemento x • Anula: ocasiona que la lista se vacíe • Primero (Fin): proporciona el primer (último) elemento de la lista • Imprimir: imprime todos los elementos de la lista en su orden. Así. y que indican la posición de la componente dentro de la colección. pero además cada problema puede requerir la definición de varios TDA propios.Otro tipo de datos son los denominados compuestos. mientras que el Arreglo y el Registro si lo son. Los registros pueden tener como campos tipos de datos simples o arreglos o incluso otros registros. ordenados según su posición en ella. Los TDA compuestos básicos: TDA Conjunto: colección de elementos tratados con las operaciones unión.

orientados por objetos. Estructura Física. Este problema. al relacionar lógicamente los elementos para satisfacer un requerimiento determinado. los programadores estaban insatisfechos por el nivel de abstracción que lograban. es tener un conjunto fijo de estructuras y un conjunto poderoso de primitivas que permiten su manipulación. Estructura Lógica. La cantidad de memoria que se le asigna a la variable. struct CARACTER car. El enfoque de los nuevos lenguajes. Debido a lo limitado de los lenguajes de alto nivel. Es la estructura que define el usuario a nivel de análisis y parte de diseño.• • • • • Binarios Enteros Reales Caracteres o Doble precisión o Vectores o Arreglos bidimensionales o Arreglos n-dimensionales o Registros Complejos El tipo de dato determina: • • • Los rangos de la variable. a través de los tipos de datos definidos por el usuario. Las operaciones que se pueden realizar. 8 . brindandole al usuario la oportunidad de definir datos (atributos) y operaciones (métodos). se ha superado al proveer los nuevos lenguajes con mecanismos que le permiten al programador construir sus propias abstracciones con base en su necesidad. en memoria auxiliar. Corresponde a la forma en que a través de un lenguaje de programación se crea la estructura lógica. struct ID_CARRO { char placa[6]. struct PROPIETARIO prop.

}. struct CARACTERISTICAS { char marca[20]. struct NOMBRE nomb. y una vez establecidas se definen como funciones. }. 9 . Función Constructora Son los algoritmos y mecanismos que permiten construir una estructura. Estas funciones son los mecanismos o procesos. Función de Eliminación Permite la exclusión de un elemento de una estructura.}. Función Inversa Las funciones de acceso proveen un nombre o valor. struct NOMBRE { char nombre[10]. }. char apellido_2[10]. Función de Acceso Son los algoritmos a través de los cuales se llega a una estructura y sus elementos Función de Prueba Por medio de la función de acceso se llega a un elemento y se prueba si posee determinado atributo. Función Destructora Son los algoritmos y mecanismos que desasignan memoria y liberan recursos del sistema.2 OPERACIONES SOBRE ESTRUCTURAS DE DATOS. Asigna memoria en forma dinámica o espacios en medios magnéticos. se determina la posición del elemento de dato en la estructura. struct PROPIETARIO { char direccion[50]. char color[10]. en que dado un valor o un nombre. char apellido_1[10]. Son varias las operaciones que se efectúan sobre las estructuras de datos. 1. Función de Inserción Permite la inclusión de un elemento en una estructura. int modelo[2].

3 Colas Circulares 2. PILA SECUENCIAL Aquí se trabaja como una lista secuencial de acceso restringido.5 Ejercicios En este capítulo se introducen dos tipos de listas.4 Aplicaciones de Listas Restringidas 2. Por ejemplo. Cuando la pila está vacía.1 Pilas 2. Para su manejo se requieren dos apuntadores. que se conoce como el tope de la pila. solo de una manera muy limitada. la pila de carritos de los supermercados.1 Pila. porque el último carro que se coloca es el primero que se saca. CONTENIDO 2. que se pueden actualizar. Esta propiedad de la pila se conoce como LIFO (Last In First Out. El apuntador TOPE apunta al último elemento de la pila. 2. BASE=TOPE. llamado TOPE de la pila. uno que indica la posición del último elemento insertado. Una pila es una lista en donde tanto las inserciones como las supresiones se hacen por el mismo extremo.1 PILAS. Son estructuras bastante importantes utilizadas en multitud de aplicaciones. Figura 2. se inserta y se elimina por el mismo extremo. pilas y colas. el apuntador BASE no apunta a ningún elemento de la pila 10 .TEMA 2 PILAS Y COLAS OBJETIVOS Emplear y desarrollar aplicaciones empleando estructuras estáticas de datos como apoyo a procesos más complejos. no hay elementos. último que entra primero que sale). y otro denominado BASE que apunta al fondo de la pila.2 Colas 2.

la base apunta al elemento 0 del arreglo. Precondición: Que exista el arreglo. que como se había determinado. 6. 2. Esta es la estructura estática con la que se trabajan estos algoritmos. 3. Prueba de Pila Vacía: En general es importante. Poscondición: Retorna verdadero cuando no hay elementos en la pila. Para la implementación de esta estructura de datos. Eliminar el elemento tope de la pila (POP). se inicia la lista restringida. Probar si la pila está vacía. Precondición: No hay. Iniciación de una pila. 5. Este algoritmo retorna un valor verdadero si la pila está vacía. para todo tipo de estructura. pues el proceso varía dependiendo de esta condición. Destruir la pila. En caso contrario retorna el valor falso. Insertar un elemento en el tope de la pila (PUSH).OPERACIONES CON PILAS Las operaciones primitivas que se efectúan sobre una pila son: 1. 11 . INIC_PILA Inicio BASE = 0 TOPE = BASE Fin Aquí. ENTERO PILA_VACIA() Inicio Si (TOPE==BASE) Entonces RETORNA VERDADERO Sino RETORNA FALSO Fin-Si Fin Esta rutina se emplea en el algoritmo ELIM_PILA que saca el elemento que apunta el TOPE de la pila. no corresponde a ningún elemento de la lista. En el arreglo PILA. se hará uso de un arreglo que aquí llamamos PILA. de dimensión M. Iniciar la pila (dejarla en condiciones de pila vacía). establecer si se encuentra vacía. Poscondición: Condición de pila vacía. Acceder al elemento del tope de la pila. 4.

Es posible que no se pueda hacer la inserción debido a que no hay nodos disponibles recordemos que con la variable I se indica si se pudo. hacer la inserción. o rechazar la inserción e informar al sistema operacional para una terminación anormal de la tarea.2 Estado de la pila luego de la inserción La condición de saturación generalmente es un error y significa que el área disponible está llena y que aun se tratan de colocar más datos en ella. tratar de manejar dicha condición para superarla. en primer lugar.I) Inicio I = Verdadero Si (NO PILA_VACIA()) Entonces DATO = PILA[TOPE] Sino I = Falso Fin-Si Fin Insertar un Dato en la Pila: Se coloca DATO en un nodo que queda en el TOPE de la pila.I) Inicio I = Verdadero Si (TOPE>=M) Entonces I = Falso Sino TOPE = TOPE + 1 PILA[TOPE] = DATO Fin-Si Fin Figura 2. Poscondición: En DATO queda una copia del elemento que apunta el índice TOPE si hay elementos en la pila. o no. 12 . ACCE_PILA(DATO. INSER_PILA(DATO.Acceder al Elemento Tope de la Pila: Con esta operación se lee el último elemento de la pila y se lleva a DATO. La política común es. Precondición: TOPE < M Poscondición: I verdadero indica que se hizo la inserción de DATO y el índice TOPE apunta a DATO. en caso contrario DATO queda indefinido. Precondición: Pila válida.

la cual no es una condición de error. Poscondición: Si se pudo realizar la operación. DATO queda con elemento que había en el tope de la pila. Al disminuir TOPE el elemento anterior permanece en el área de memoria como basura. Precondición: Pila válida. 13 . ALGORITMO DEST_PILA Inicio I = Verdadero Mientras I Hacer ELIM_PILA(DATO.I) Rutina_usa (Dato) Fin-M Fin En muchas aplicaciones es necesario vaciar la pila.I) Inicio I = Verdadero Si (NO PILA_VACIA()) Entonces DATO = PILA[TOPE] TOPE = TOPE . Se sacan todos los elementos de la lista. Precondición: Pila válida.1 Sino I = Falso Fin-Si Fin La condición de pila vacía se presenta cuando se trata de obtener un elemento inexistente. Poscondición: Pila vacía. Es semejante a la condición que se presenta cuando se está procesando un archivo secuencial y se llega al fin del archivo. en caso de que no llegue. Si la pila estaba vacía I es falso y DATO indeterminado. para esto se incluye la rutina apropiada que utiliza DATO dentro del ciclo. simplemente se liberan los recursos o se inicia el proceso de los datos anteriores. I verdadero.Eliminar un Elemento de la Pila: En DATO se coloca el elemento que inicialmente apunta al TOPE de la pila. ALGORITMO ELIM_PILA(DATO. Destruir la Pila. Esta condición se puede considerar en el sentido de que hay una serie de recursos disponibles para procesar el DATO que se espera.

las subrutinas y los diferentes componentes de los sistemas operacionales requieren la utilización de varias pilas. el hecho de que haya saturación implica una terminación anormal. Manejo de Dos Pilas y Operaciones Primitivas.VACIA) Inicio Si (IP=1) Entonces Si (BASE1 = TOPE1) VACIA = V Sino VACIA = F 14 . Como se vio en la inserción. Vacía queda en V si la pila IP está vacía sino vacía queda en F. TOPE1 = BASE1 BASE2 = M. Poscondición: Las dos pilas en condición de pila vacía. perdiéndose todo lo procesado. buscando optimizar el uso de la memoria. El área común es todo el arreglo con sus M elementos. La base de la pila 1 tiene el índice 0 y el índice de la base de la pila 2 es M. Poscondición: No hay cambio en la pila. las cuales se pueden disponer de muchas formas.3 Pilas enfrentadas. En los siguientes algoritmos se incluye la variable IP (indicador de pila) que dirá sobre cual de las dos pilas se debe realizar la operación.3 y dejar claro cómo se trabajan los índices y a que nodos apuntan. Iniciación de las Pilas. INIC2PILAS Inicio BASE1 = 0. Figura 2. ALGORITMO 2PILASVAC(IP. Se debe observar la figura 2. Precondición: Arreglo válido. En los lenguajes de programación.DISTRIBUCIÓN DE PILAS. TOPE2 = BASE2 Fin Prueba de Pila Vacía Precondición: IP solo puede timar valores 1 o 2.

Poscondición: Inserción de DATO en una de las dos pilas o la imposibilidad de hacerlo.Sino Fin-Si Si (BASE2 = TOPE2) VACIA = V Sino VACIA = F Fin-Si Fin-Si Fin Acceder al Elemento de una de las Dos Pilas Precondción: IP solo puede tomar valores de 1 o 2. ALGORITMO INSER2PILAS(DATO. Precondición: IP es 1 o 2.I) Inicio I = V 2PILASVAC(IP. I es falso. ACC2PILAS(DATO.1 PILA[TOPE2] = DATO Fin-Si Sino I = V Fin-Si Fin 15 . I=FALSO.IP.VACIA) Si (VACIA) Entonces I = F Sino Si (IP=1) Entonces DATO = PILA[TOPE1] Sino DATO = PILA[TOPE2] Fin-Si Fin-Si Fin Insertar un Dato en una de las Dos Pilas. no hay saturación mientras ( TOPE1+1) < TOPE2.I) Incio I = F Si ((TOPE1+1) < TOPE2) Entonces Si (IP=1) Entonces TOPE1 = TOPE1 + 1 PILA[TOPE1] = DATO Sino TOPE2 = TOPE2 . sino I es verdadero. Poscondición: Si hay datos en la pila IP. y en Dato queda copia del elemento indicado por el tope de la pila IP.IP.

IP.Eliminar un Elemento de una de las Pilas Precondición: IP solo puede tomar los valores 1 o 2. ALGORITMO ELIM2PILAS(DATO.1 Sino DATO = PILA[TOPE2] TOPE2 = TOPE2 + 1 Fin-Si Sino I = F Fin-Si Fin Destruir una de las Pilas. Poscondición: Se elimina el elemento tope de pila IP.I) Inicio I = V 2PILASVAC(IP.IP.IP. Precondición: Poscondición: Se elimina el elemento tope de pila IP.VACIA) Si (NO VACIA) Entonces Si (IP = 1) Entonces DATO = PILA[TOPE1] TOPE1 = TOPE1 . ALGORITMO DESTR2PILAS(IP) Incio Si (IP = 1) Entonces Mientras I Ejecute ELIM_2PILAS(DATO.I) Rutina_Usa(Dato) Fin-M Sino Mientras I Ejecute ELIM_2PILAS(DATO.I) Rutina_Usa(Dato) Fin-M Fin-Si Fin 16 .

Iniciar una cola Probar si la cola está vacía Acceder al elemento delantero de la cola Insertar un elemento en la cola Eliminar el elemento delantero de la cola Destruir la cola INICIAR COLA. First Out) El primer elemento en entrar será el primero en salir. los aviones que esperan despegar de un aeropuerto forman una cola. El apuntador U. 2. El apuntador D.2 COLAS.2. Para su manejo se requieren dos índices. último. COLA SECUENCIAL Aquí se trabaja la cola como una lista secuencial de acceso restringido. con M posiciones disponibles. Se tiene un arreglo COLA asignado para almacenar la cola. similares a las operaciones de la pila: 1. 4. ULTIMO que indica el último elemento insertado en la cola. 3.4 Cola. Figura 2. Precondición: Arreglo válido Poscondición: Se tiene condición de cola vacía INIC-COLA Inicio D = 0 U = D Fin 17 . el que llega a la pista queda de último y el que va a despegar está de delantero en la cola. Se dice que una cola tiene política FIFO(First In. Es una lista de proceso restringido en la cual las inserciones se hacen por un extremo llamado "último" y las eliminaciones se hacen por el otro extremo llamado "delantero". apunta al primer elemento en la cola OPERACIONES CON COLAS Sobre una cola se pueden efectuar las siguientes operaciones primitivas. y DELANTERO que indica el primer elemento de la cola. Por ejemplo. 6. dentro del arreglo COLA. se inserta por el último y se suprime por delante. delantero. 5. apunta al último elemento insertado.

La variable I indica si se pudo o no hacer la inserción.I) Inicio I = V Si (U > M) Entonces I = F Sino Si (COLA_VACIA()) Entonces D = 1 U = D Sino U = U + 1 Fin-Si COLA[U] = DATO Fin-Si Fin 18 . quedando como último.I) Inicio I = V Si (NO COLA_VACIA()) Entonces DATO = COLA[D] Sino I = F Fin-Si Fin INSERTAR UN ELEMENTO EN LA COLA. Precondición: Que exista la cola Poscondición: La cola queda con un elemento adicional DATO. ENTERO COLA_VACIA() Inicio Si (D = 0) Entonces RETORNA V Sino RETORNA F Fin-Si Fin ACCEDER A UN ELEMENTO EN LA COLA Precondición: Arreglo válido Poscondición: Se saca en DATO el elemento que indica D.PROBAR SI LA COLA ESTÁ VACÍA Precondición: Arreglo válido Poscondición: Si la cola está vacía retorna verdadero. sino I es falso. que queda como último elemento de la cola. sino falso. INSER-COLA(DATO. Es posible que no se pueda hacer la inserción debido a que no hay espacio. Se coloca DATO en el nodo siguiente al último. ACCED-COLA(DATO. o hay terminación normal.

3 COLAS CIRCULARES. cuando hay memoria desperdiciada. sino. Se elimina el elemento que está de delantero en la cola. llegando incluso a condiciones de saturación. ELIM-COLA(DATO. Observemos que en el numeral anterior. DESTRU-COLA(IP) Inicio I=V Mientras I Ejecute ELIM-COLA(DATO. y las inserciones también van desplazando el apuntador U.ELIMINAR UN ELEMENTO DE LA COLA. 19 . Poscondición: Se elimina el primer elemento de la cola. hacer un manejo de índices.I) Rutina-Usa(Dato) Fin-M Fin 2. Precondición: Que haya cola. Una solución a este inconveniente es formar una cola circular.I) Inicio Si (COLA_VACIA()) Entonces I = F Sino Dato =Cola [D] I = V Si (D == U) Entonces U = 0 D = U Sino D = D + 1 Fin-Si Fin-Si Fin DESTRUIR LA COLA Precondición: Cola válida. I = falso. Poscondición: Cola vacía. al hacer eliminaciones. Es decir. se va corriendo el apuntador D. si existe.

INSERCIÓN EN COLA CIRCULAR Aunque es similar al de inserción en colas comunes. y por la condición de saturación: D=U. si hay espacio. Figura 2.I) Inicio I = V Si (COLA_VACIA() Entonces D = 1 U = 1 COLA[U] = DATO Sino U = U+1 Si (U = M) Entonces U = 1 Sino Fin-Si Si (D=U) Entonces I = F Sino COLA[U] = DATO Fin-Si Fin-Si Fin ELIMINAR EL NODO DELANTERO DE LA COLA 20 . acceso y destrucción de la cola son similares a los del caso anterior. I =falso. Precondición:Que haya cola. para enviarlo a 0.5 Después de que U = M se U = 1. hay saturación.6 Si se presenta una inserción. sino. Poscondición: D apunta al nuevo nodo. INSER-COL-CIR(DATO. cuando U = M. Los de inserción y eliminación varía por la condición inicial: U=0 U=D.Figura 2. prueba. Los algoritmos de iniciación. se debe considerar. También se debe tener en cuenta la nueva condición de saturación.

sino. Poscondición: U apunta al último elemento de la cola.I) Inicio I = V Si (COLA_VACIA()) Entonces I = F Sino DATO = COLA[D] Si (D=U) Entonces D = 0 U = D Sino D = D + 1 Si (D = M) Entonces D = 1 Sino Fin-Si Fin-Si Fin-Si Fin 21 . queda la cola en condición de cola vacía.7 (a) Condición inicial crítica (b) Condición final una vez se ha eliminado el nodo delantero Precondición: Que haya cola.Figura 2. ALGORITMO ELIM-COLA-CIR(DATO. si hay elementos.

así se facilita la evaluación de la expresión.. tiene mayor prioridad que el operador que está en el tope de la pila. 3. En este tipo de notación los operadores aparecen después de los operandos. J=1. ^ Observaciones sobre la expresión infija. -. se encuentra en un arreglo X. en especial en sistemas operativos. Todos los operandos pasan directamente a una cola salida..1 *. /. la evaluación de una expresión. 2. un paréntesis izquierdo o derecho.2. se desocupa la pila hasta encontrar el paréntesis izquierdo y se mandan los operadores a la cola de salida. Los operadores van a una pila. es una letra (operando). 1. de izquierda a derecha y sigue el siguiente manejo: 1. Si el operador que entra es de prioridad menor o igual al del tope de la pila../ ^ 2 3 El algoritmo analiza carácter a carácter la expresión infija. hasta que el operador tenga mayor prioridad al del tope de la pila. Resta Multiplicación. Vamos a suponer que se tienen los siguientes operadores. con sus respectivas prioridades. 4. . la pila se desocupa enviando los operadores a la cola. o uno de los operadores = .. Se supone que la entrada es una expresión infija válida. 22 . compiladores e interpretadores.. Si es un paréntesis derecho ")". se coloca en el tope de la pila. se manda a la pila. Son muchas las aplicaciones de estas listas restringidas. División Potencia Operador Prioridad = 0 +. +. ALGORITMO DE NOTACIÓN INFIJA A POSFIJA La gran mayoría de lenguajes representa las expresiones aritméticas en la llamada forma INFIJA. *.N. Vamos a trabajar una aplicación universal. Si es un paréntesis izquierdo "(". La expresión infija que se va a convertir a posfija. Desocupar la pila. con N posiciones.4 APLICACIONES DE LISTAS RESTRINGIDAS.. Otra manera de hacerlo es usando notación POSFIJA o POLACA. Asignación Suma. donde X[J]. Su posición depende de los que haya en el tope de la pila: Si el operador que entra. en la cual los operadores se encuentran dentro de los operandos. 5.

Se define una función de prioridad P: P( ) ) = -1 P(( ) = -1 P( = ) = 0 P(+) = 1 P(-) = 1 P(*) = 2 P(/) = 2 P(^) = 3 ALGORITMO INF-A-POSF Precondición: Únicamente los caracteres ya definidos.I) Si (I) Entonces J = 1 K = 1 Mientras (K < N) Ejecute Si (X[K] = LETRA) Entonces Y[J] = X[K] J = J+1 Sino Si (X[K] = ")" ) Entonces Mientras (PILA [TOPE]) <> "(" ) Ejecute Y[J] = PILA[TOPE] J = J+1 TOPE = TOPE .1 Sino Mientras (P(X[K])<= P(PILA[TOPE]) Ejecute Y[J] = PILA[TOPE] J = J+1 TOPE = TOPE-1 Fin-Mientras TOPE=TOPE+1 PILA[TOPE] = X[K] Fin-Si Fin-Si K=K+1 Fin-Mientras Mientras [(PILA[TOPE]) <>(I)] Ejecute Y[J] = PILA[TOPE] J = J+1 TOPE = TOPE -1 Fin-Mientras 23 . No se espera la entrada de constantes ni de referencia a funciones 4.2. Los operandos consisten de una sola letra 3. Poscondición: Comience CREA_PILA D = 0 TOPE = 0 INSER-PILA( . No deben aparecer funciones unarias.1 Fin-Mientras TOPE = TOPE .

puede ser una letra o un operador (<= . J=1. ALGORITMO EVAL-POL Precondición: Poscondición: Comience TOPE = 0 K = 1 Mientras (K<=N) Ejecute Si (X[K] = OPERANDO) Entonces TOPE = TOPE +1 PILA[TOPE] = X[K] Sino AUX1 = PILA[TOPE] TOPE = TOPE-1 AUX2 = PILA[TOPE] AUX3 = AUX2 (X[K]) AUX1 PILA[TOPE] = AUX3 Fin-Si K = K +1 Fin-Mientras Termine Evaluación de una expresión Vamos a seguir los dos algoritmos anteriores para la evaluación de la siguiente expresión: G = ((AB)*C)+(D/(E ^F)) 1.N. Cada X(J). X . /. Conversión a Posfija.. *.Sino Fin-Si Termine ALGORITMO DE EVALUACIÓN EN NOTACIÓN POSFIJA En este caso se tiene una expresión aritmética en notación posfija se encuentra en un arreglo X. -. +. que hace que se ejecute esa operación entre los dos nodos operandos que se tengan en los nodos superiores de la pila.. El resultado se guarda en el tope de la pila.. 1 2 3 COLA . G G G PILA = =( 24 .. Los operandos se van guardando en una pila hasta cuando se encuentra un operador. ).

F=5 X COLA 1 G 2 GA 3 GAB 4 G3 5 G3C 6 G 15 7 G 15 D 8 G 15 D E 9 G 15 D E F 10 G 15 D 32 11 G 15 2 12 G 17 13 17 PILA G G4 G41 G3 G35 G 15 G 15 64 G 15 64 2 G 15 64 2 5 G 15 64 32 G 15 2 G 17 17 25 . C=5. Evaluación de la notación Posfija. B=1. E=2. D=64 .4 G 5 GA 6 GA 7 GAB 8 GAB9 GAB10 GAB-C 11 GAB-C* 12 GAB-C* 13 GAB-C* 14 GAB-C*D 15 GAB-C*D 16 GAB-C*D 17 GAB-C*DE 18 GAB-C*DE 19 GAB-C*DEF 20 GAB-C*DEF^ 21 GAB-C*DEF^/ 22 GAB-C*DEF^/+ 23 GAB-C*DEF^/+= =(( =(( =((=((=( =(* =(* = =+ =+( =+( =+(/ =+(/( =+(/( =+(/(^ =+(/(^ =+(/ =+ 2. donde A=4.

Ejemplo : 26 . con el objetivo principal de ahorro de memoria. Existen dos mecanismos de implementación: USO DE DELIMITACIONES DELIMITADOR DE CAMPOS : Existe un símbolo específico para delimitar los campos ( . Aprovechar de una forma eficiente el medio de almacenamiento secundario de datos. CAMPOS DE LONGITUD VARIABLE.1 Archivos 3. .TEMA 3 ARCHIVOS.3 Archivos Secuenciales y Directos 3. REGISTROS Y CAMPOS OBJETIVOS Estructurar la información con el soporte fundamental para el almacenamiento externo de datos. 3. Cintas .2 TIPOS DE ARCHIVOS. ARCHIVOS SECUENCIALES.. Se realiza este tipo de definición de campos de longitud variable.1 ARCHIVOS Un archivo es un conjunto de registros relacionados entre sí.2 Registros y Campos 3. Son aquellos en los que los registros se graban unos a continuación de otros y el acceso a un registros determinado. Un archivo almacena grandes volúmenes de información en unidades externas (Floppy.). necesita forzosamente el paso por todas los registros anteriores. que se puede identificar y manipular de modo unitario. ya que con campos de longitud fija se realiza un desperdicio de memoria. que forman una entidad. *) DELIMITADOR DE REGISTROS : Símbolo diferente al delimitador de campo. Para la implementación de este tipo de campos se lo realiza con archivos de tipo texto. CONTENIDO 3. HD.

Los campos definidos de esta manera son almacenados en memoria con una longitud fija de datos. Es lograr una nueva disposición en el soporte de los registros de un archivo. Ordenamiento o Clasificación. 8 SIS-1103. OPERACIONES SOBRE ARCHIVOS Creación. con una secuencia de ubicación determinada por el valor de sus campos. Para evitar deterioros de información el archivo es cerrado durante el tiempo que no se utiliza y no debe permitir su acceso. Consiste en crear un archivo idéntico a otro y existencte. Es la eliminación de todo el archivo. SIS-2204. sin importar si se realiza el uso parcial o completo del campo. 8 SIS-2204. SIS-1103. en un soporte de los registros de un determinado archivo. Copiado o Duplicación. por primera vez. 9 BALLIVIÁN. LA PAZ@17.Nombre Dirección Edad Lista de Materias $CLAUDIA.2207 Para distinguir algunos registros que contienen los mismos campos se recurre a un campo que contiene información única o diferente que se le llama clave. Apertura y Cierre. sin que se afecte el original. Ejemplo : Nombre Dirección Edad Lista de Materias 7 CLAUDIA. Borrado. Son aquellos en los que los registros se pueden localizar mediante una dirección. Este orden puede ser ascendente o descendente. se puede hacer prohibiendo definitivamente su acceso o destruyendo la información que hay en el. manipularse y tener acceso a los registros. SIS-1103$ANA. ARCHIVOS DIRECTOS. El acceso a los registros es directo. MAT. BALLIVIÁN@ 17. 8 MAT. Consiste en la grabación.2207 SUBCAMPO DE LONGITUD Registro con un numero constante de campos. CAMPOS DE LONGITUD FIJA. 2 17. Un archivo debe poseer las condiciones necesarias para ser abierto. 27 .

de manera que queden uno a continuación del otro. los campos son los atributos de los objetos de estudio. Contenido o valor. Consiste en dividir un archivo en dos. Función o Intercalación. otro archivo que contenga los registros de ambos y mantenga su ordenación. El campo se puede dividir en subcampos. 3. Partición. que estan relacionados entre sí por contener información relativa a una entidad particular y superior. dejen libres fuera de la parte de soporte ocupada por el archivo todos los espacios correspondientes que hallan sido eliminados del mismo.Concatenación. independiente de las demás. Longitud variable Campos múltiples 28 . de acuerdo a alguna característica determinada de sus registros. Un registro es un conjunto organizado de datos del mismo o diferente tipo. consiste en obtener de dos archivos ordenados por un mismo campo y con la misma estructura. Intersección. TIPOS DE CAMPOS.3 REGISTROS Y CAMPOS. Un campo es una unidad mínima de información. dentro del registro. REGISTROS. Ubicación dentro del registro. Consiste en obtener de dos archivos. Existen tres tipos de campos • • • Longitud fija. Longitud o dimensión. con la misma estructura. • • • • Nombre ( identificador ) de campo que es elegido por el programador. CAMPOS. Consiste en reorganizar todos los registros de un archivo. ocupando todos los huecos de memoria existentes entre ellos. Los registros están compuestos por campos. Compactación o Empaquetamiento. de la que forman parte y los unifica. Llamada mezcla. un archivo que contenga ambos. Los componentes de un registro se denominan campos. Consiste en formar un único archivo mediante los registros comunes de dos archivos distintos. Representa un concepto global en la finalidad unitaria del registro y se caracteriza por el tipo de datos asociados y el tamaño de memoria que necesita para su almacenamiento. cada campo tiene los siguientes atributos.

Recuperación (Consultas y Listados). almacenada en el. • • Consultas: Se accede a uno o varios registros determinados de un archivo y se visualiza el contenido de sus campos. Consiste en introducir nuevos datos en el archivo o en eliminar o modificar los ya existentes. OPERACIONES SOBRE REGISTROS. Diseñado por el programador. Borrados: Se eliminan uno o varios registros del archivo. En cuanto a su estructura interna.TIPOS DE REGISTROS Registro Lógico. En ambos casos la suma de las longitudes de los campos es la misma para cada registro. Su longitud variable puede estar determinada por un valor máximo o también sin ninguna limitación. al final o en cualquier lugar del mismo. Información que el sistema puede transferir como una unidad. • • • Inserciones: Se introducen uno o varios registros en un archivo. el registro puede tener el mismo número de campos de igual longitud cada uno. borrando su contenido definitivamente o prohibiendo su acceso. Registros de Longitud Variable. en una sola operación de entrada o salida. Aquí se analizan las operaciones que solo afectan a algunos registros. Cada uno de los componentes de un archivo que posee una estructura para almacenar información referente a un tema general del archivo. 29 . o diverso número de campos de diferentes longitudes. Registro Físico. ya creado. Actualización o Mantenimiento. Registros según la longitud de sus campos: Registros de Longitud Fija. por impresora o pantalla. Modificaciones: Consiste en cambiar los datos de uno o varios campos de cualquier registro de archivo. Consiste en acceder a los registros de un archivo para obtener una información determinada. Listados: La visualización de la información es una lista ordenada. Su tamaño varía de un registro a otro. Su tamaño no varía. Entre las agrupaciones estructuradas de registros se tienen los archivos de datos y las bases de datos. Todas estas operaciones necesitan la operación de búsqueda como preliminar para localizar los registros deseados.

2. El objetivo principal del siguiente tema es realizar las siguientes operaciones para el tratamiento de archivos: 1.2 Operaciones en Archivos 4. para lo cual se toca el tema de métodos de ordenación externa.5 Métodos Ordenación Externa 4. debido a que esta es imprescindible para el usuario. Actualización de la información. las cuales son: 1.1 INTRODUCCION Un archivo es una colección de registros.2 OPERACIONES SOBRE ARCHIVOS Las operaciones básicas sobre archivos son: 1. Recuperación de información. Almacenamiento de información. 3.4 Mezclas de Archivos 4.1 Introducción 4. CONTENIDO 4. donde cada registro esta conformado por un conjunto de campos. Se hace énfasis en la recuperación de la información.TEMA 4 TRATAMIENTO DE ARCHIVOS OBJETIVOS Desarrollar las operaciones básicas sobre la información almacenada en un medio secundario. Adición de datos Eliminación de datos Consultas Búsquedas Existen otras operaciones complejas. Partición de Archivos 2. 4. Mezcla o fusión de Archivos 30 .3 Partición de Archivos 4. 2. 3. Desarrollar nuevos mecanismos de procesamiento de acuerdo a las características del problema. 4. para contar con información en forma inmediata.

es necesario el uso de un archivo auxiliar.Estas últimas son operaciones auxiliares. 2. 3. Se deben seguir los siguientes: 31 . Manteniendo el orden del archivo ADICION DE DATOS EN DESORDEN (al final). necesarias para los métodos de ordenación externa. Adición de datos en desorden 2. Si existe entonces: mostrar ' Ya Existe '. Si no : Añadir el dato al final del Archivo ADICION DE DATOS EN ORDEN Para añadir un registro manteniendo el orden del archivo. ADICION DE DATOS Una de las tareas mas comunes en archivos es la adición de datos. Leer Dato. Buscar Dato en el Archivo. se puede añadir datos de dos maneras a un archivo: 1. Pasos a realizar para añadir un registro en un archivo: 1.

Eliminar lógicamente 2. y por lo tanto no es usado con frecuencia. 32 . que permite marcar el registro como eliminado. LOGICAMENTE: Este tipo de eliminación ahorra tiempo cuando se usa grandes volúmenes de información. Eliminara físicamente FÍSICAMENTE: En este tipo de eliminación es necesario usar un archivo Auxiliar. por lo que este proceso es lento.ELIMINAR DATOS Se puede eliminar datos de dos maneras: 1. Ya que se cuenta con un campo adicional.

FIN SI 33 . FIN SI Fin mientras Consultas con rango: El valor de la clave especificada hace referencia a un conjunto o rango de registros.reg) SI Edad > 17 ENTONCES .. CRITERIOS DE SELECCIÓN Consulta Simple: Cuando la clave del registro es específica y hace referencia a un solo registró.. Ejemplo: Mientras no eof (F) y reg <= clave hacer Leer (F.. para lo cual debe existir un criterio de selección de la información. Esto por ser más rápida la eliminación lógica que la eliminación física......reg) SI Nombre = 'Veronica' ENTONCES ... FIN SI Fin mientras Consulta funcional: La clave hace referencia a valores que responden. a la evaluación de un proceso o fusión. y al finalizar el día utilizan la eliminación de física. Ejemplo : Mientras no eof (F) y reg <= clave hacer Leer (F. CONSULTAS DE DATOS Se recupera la información sin alterar el estado del registro.Muchas aplicaciones usan primeramente la eliminación lógica... Ejemplo: Mientras no eof (F) y reg <= clave hacer Leer (F..reg) SI Edad = prom(Edad) ENTONCES ...

. FIN SI Fin mientras BUSQUEDA DE DATOS Existen dos formas de búsqueda de datos: 1. Ejemplo: Mientras no eof (F) y reg <= clave hacer Leer (F.. Ejemplo: Realizar la búsqueda del registro.reg) Mientras no eof (F) y reg <= clave hacer Leer (F. Inicio Fin Leer Clave Abrir (F.reg) Fin mientras Si reg=clave Entonces Mostrar " Existe el dato" Si no Mostrar "No existe el dato" Fin si Cerrar (F) 34 .... donde Dato='MARIA'.Fin mientras Consulta lógicas: Una combinación de las tres anteriores por medio de operaciones logicas. Secuencial en un archivo ordenado 2.reg) SI Edad = prom(Edad) or Nombre ='Martha' ENTONCES . Secuencial en un archivo desordenado BÚSQUEDA SECUENCIAL EN UN ARCHIVO ORDENADO Se realiza el recorrido de los registros de archivo hasta el incumplimiento de una condición o que finalice el archivo.Lectura) Leer (F.

Lectura) Leer (F. 3. Ejemplo: Realizar la búsqueda del registro. ALGORITMO Inicio Leer Dato Abrir (F.reg) Fin mientras Si reg=clave Entonces Mostrar " Existe el dato" Si no Mostrar "No existe el dato" Fin si Cerrar (F) Fin 4. 35 . Partición por secuencias ordenadas. Partición por el contenido 2. Partición por una secuencia ' P ' dada.3 PARTICION DE ARCHIVOS A partir de un archivo se genera dos o más archivos de trabajo Existen tres tipos de partición de archivos: 1.BÚSQUEDA SECUENCIAL EN UN ARCHIVO DESORDENADO Se realiza el recorrido de los registros hasta encontrar el registro o hasta que se finalice el archivo. donde Dato='MARIA'.reg) Mientras no eof (F) y reg <> clave hacer Leer (F.

Reg) Si Reg = Clave Entonces Grabar (Carrera.PARTICION POR CONTENIDO Se debe establecer un criterio de partición. Se copia 'P' registros de Arch a Arch1. 36 . luego los siguientes 'P' registros de Arch a Arch2. esto se repite hasta terminar de leer el archivo Arch Ejemplo: Realizar la partición del archivo ARCH en dos archivos ARCH1 y ARCH2. Reg) Fin si Fin Mientras Cerrar (FNI) Cerrar (Carrera) Fin PARTICION POR UNA SECUENCIA " P " DADA Se establece un numero entero P que índica las secuencias para realizar la partición. Donde el archivo F1 es solo lectura y el archivo F2 para escritura. utilizando la secuencia de partición (P = 2). Ejemplo: Crear un archivo llamado CARRERA seleccionando Clave = 'SIS' del Archivo FNI. ALGORITMO Inicio Leer Clave Abrir FNI (Lectura) Abrir Carrera (Escritura) Mientras no eof (FNI) Hacer Leer (FNI. para determinar que registros de F1 se destinan al archivo F2.

A ) Si no eof (C) Entonces Copiar_Tramo (C. Arch2. y : Archivo. Reg) Grabar (y. B ) 37 . P) Si no eof (Arch) Entonces Copiar_Secuencia(Arch. Arch1. luego se toma otro tramo ordenado del archivo C para copiarlo al archivo B este proceso se repite hasta que finalice de leer todo el archivo C. Ejemplo: Particionar el archivo C en dos archivos A y B por secuencias ordenadas. ALGORITMO Inicio Abrir A (Lectura) Abrir B (Lectura) Abrir C (Escritura) Mientras no eof (C) Hacer Copiar_Tramo (C.ALGORITMO Inicio Leer (P) Abrir Arch(Lectura) Abrir Arch1(Escritura) Abrir Arch2(Escritura) Mientras no eof (Arch) Hacer Copiar_Secuencia(Arch. P: entero) Inicio Cont = 0 Mientras (no eof (x)) y (cont < P ) Hacer Leer (x. P) Fin si Fin Mientras Cerrar (Arch) Cerrar (Arch1) Cerrar (Arch2) Fin Copiar_Secuencia (Var x. Reg) Cont = Cont +1 Fin mientras Fin PARTICIÓN DE ARCHIVOS POR TRAMOS ORDENADOS Se toma primeramente un tramo ordenado del archivo C y se copia al archivo A.

Mezcla por Secuencias Ordenadas. y : Archivo) Inicio Repetir Copiar_Dato ( x. 3. Mezcla por Contenido Total. Reg) Si eof (x) Entonces Fin_Tramo = TRUE Si no Pos = File Pos (x) Leer (x. Reg1) Seek (x.4 MEZCLAS DE ARCHIVOS El proceso de unir dos o más archivos se le denomina mezcla de archivos. y ) Hasta Fin_Tramo Fin Copiar _Dato ( Var x. Pos) Fin_Tramo = Reg > Reg1 Fin si Fin si Fin 4. 2. Existen tres tipos al igual que en particiones: 1. y :Archivo) Inicio Si eof (x) Entonces Fin_Tramo = TRUE Si no Leer (x. Reg) Grabar (y. 38 . Mezcla por Secuencias " P ".Fin Fin si Fin Mientras Cerrar (A) Cerrar (B) Cerrar (C) Copiar_Tramo (Var x.

39 . B en un archivo C. Reg) Grabar (C. utilizando las secuencias P = 2 para realizar dicha operación. este proceso se los realiza primeramente copiando toda la información de A al C y posteriormente B al C. que indica las secuencias para realizar la mezcla de dos archivos. B en un tercer archivo C. Reg) Fin Mientras Cerrar (A) Cerrar (B) Cerrar (C) Fin MEZCLA POR SECUENCIAS " P " Se establece un numero entero 'P'. Reg) Fin Mientras Mientras no eof (B) Hacer Leer (B. B en un tercer archivo C. Ejemplo: Mezclar los Archivos A. ALGORITMO Inicio Abrir A (Lectura) Abrir B (Lectura) Abrir C (Escritura) Mientras no eof (A) Hacer Leer (A. Reg) Grabar (C. Ejemplo: Realizar la Mezcla de A. El resultado de la mezcla es una secuencia ordenada de datos.MEZCLA POR CONTENIDO TOTAL Se procede a la unión de dos archivos A.

ALGORITMO Inicio Leer (P) Abrir A (Lectura) Abrir B (Lectura) Abrir C (Escritura) Mientras no eof (A) y no eof (B) Mezclar_SecP Fin Mientras Mientras no eof (A) Hacer Copiar_SecP (A. y : Archivo.P-SecA) SecA =P Fin si Fin si Hasta SecA=P y SecB=P Fin Copiar_SecP (Var x. Reg) Cont = Cont +1 Fin Mientras Fin Hacer 40 .P-SecB) SecB =P Fin Si Si no Copiar_SecP (B. PosA) PosB = FilePos(B). C.P) SecA=SecA+1 Si SecA=P Entonces Copiar_SecP (B. PosB) Si RegA < RegB Entonces Copiar_SecP (A. RegA). C. C. SecB=0 Repetir PosA = FilePos(A).Seek (A. P : Entero) Inicio Cont = 0 Mientras no eof (x) y Cont < P Hacer Leer (x. Grabar (y.P) SecB=SecB+1 Si SecB=P Entonces Copiar_SecP(A. P) Fin Mientras Mientras no eof (B) Hacer Copiar_SecP (B. C.Leer(B. Reg).Leer(A. C.Seek (B. RegB). C. P) Fin Mientras Cerrar (A) Cerrar (B) Cerrar (C) Fin Mezclar_SecP Inicio SecA =0.

tomando tramos ordenados. PosB) Si Reg1 < Reg2 Entonces Copiar_Dato (A.MEZCLA POR TRAMOS ORDENADAS Se realiza la mezcla los archivos A y B en el archivo C. C) Fin Mientras Cerrar (A) Cerrar (B) Cerrar (C) Fin Mezclar_Tramo Inicio Repetir PosA = FilePos (A) Leer (A. ALGORITMO Inicio Abrir A (Lectura) Abrir B (Lectura) Abrir C (Escritura) Mientras no eof (A) y no eof (B) Mezclar_Tramo Fin Mientras Mientras no eof (A) Hacer Copiar_Tramo (A. utilizando las secuencias ordenadas. RegA) Seek (A. C) Fin Si Hacer 41 . Es decir se realiza la mezcla del primer tramo ordenado de A con la de B. RegB) Seek (B. C) Fin Mientras Mientras no eof (B) Hacer Copiar_Tramo (B. PosA) PosB = FilePos (B) Leer (B. C) Si Fin_Tramo Entonces Copiar_Tramo (B. Ejemplo: Realizar la mezcla A y B en un tercer archivo C.

Si no Fin Fin si Hasta Fin _Tramo Copiar_Dato (B.Pos) Fin_Tramo = Reg > Reg1 Fin si Fin si Fin 4. Para lo cual existen distintos métodos de ordenación externa exclusivos que son las siguientes: • • • • Ordenación por Mezcla Directa. Reg1) Seek (x. ORDENACIÓN POR MEZCLA DIRECTA El método solo funciona con archivos donde su longitud sea múltiplo de 2n. Todos estos métodos hacen el uso de archivos auxiliares. y : Archivo) Inicio Repetir Copiar_Dato (x. Ordenación por Mezcla Equilibrada. Ordenación Von Newman. Reg) Si eof (x) Entonces Fin_Tramo = TRUE Si no Pos = File Pos (x) Leer (x.5 ORDENACIÓN EXTERNA Debido a la limitación en memoria interna y a la enorme información que es almacenada en los archivos. y) Hasta Fin_Tramo Fin Copiar_Dato (Var x. y: Archivo) Inicio Si eof (x) Entonces Fin_Tramo = TRUE Si no Leer (x. para realizar el proceso de ordenación de archivos. hace el uso de los siguientes archivos: 42 . C) Si Fin_Tramo Entonces Copiar_Tramo (A. Ordenación por Dígitos. no es posible utilizar los métodos de ordenación interna. Reg) Grabar (y. C) Fin si Copiar_Tramo ( Var x.

ALGORITMO Inicio Sec = 1 Abrir C (Lectura) Repetir Abrir B (Escritura) Abrir A (Escritura) Seek (C. 0) Particionar Seek (A. copiar la primera mitad del archivo C en el archivo A. 0). 2. Repetir los pasos 1 y 2 hasta que la secuencia sea mayor que la mitad del archivo a ordenar (secuencia{2n}> long(C)/2) Ejemplo: Ordenar los siguientes datos. 0) Mezclar 43 .1. Donde: n = 0.C Archivo a ordenar A. Seek (B. Partir el archivo C en la mitad.3. Seek (C.2. 3. 0). y la otra mitad en el archivo B.. Mezclar los archivos auxiliares A y B por secuencias de 2n..B Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1.

Cerrar A; Cerrar B Sec = Sec * 2 Hasta Sec > (Filesize (C) Div 2) Cerrar C Fin Particionar Inicio Max = Filesize (C) Div 2 Para J = 1 Hasta Max Hacer Leer C, Reg Grabar A, Reg Fin Para Para J = 1 Hasta Max Hacer Leer C, Reg Grabar B, Reg Fin Para Fin Mezclar Inicio

Mientras no eof (A) y no eof (B) Hacer Mezclar_Sec Fin Mientras

Fin Mezclar_Sec Inicio SecA = 0; SecB = 0 Repetir PosA = FilePos (A); Leer A, RegA; PosB = FilePos (B); Leer B, RegB; Si RegA < RegB Entonces Leer A, Reg Grabar C, Reg SecA =SecA + 1 Si SecA = Sec Entonces Copiar_SecP (B, C, SecB = Sec Fin si Si no Leer B, Reg Grabar C, Reg SecB = SecB + 1 Si SecB = Sec Entonces Copiar_SecP (A, C, SecA = Sec Fin si Fin si Hasta (SecA = Sec) y (SecB = Sec) Fin Copiar_SecP (Var x, y : Archivo; Sec : Entero) Inicio Cont = 0 Mientras no eof (x) y (Cont < Sec) Hacer Leer (x, Reg) Grabar (y, Reg) Cont = Cont +1;

Seek (A, PosA) Seek (B, PosB)

Sec-SecB);

Sec-SecA);

44

Fin

Fin Mientras

ORDENACIÓN POR VON NEWMAN
El método solo funciona con archivos donde su longitud sea múltiplo de 2n, hace el uso de los siguientes archivos: C Archivo a ordenar A,B Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1. Partir el archivo C en secuencias de 2n, copiar intercaladamente las secuencias del archivo C, primeramente en el archivo A, y luego en el archivo B. 2. Mezclar los archivos auxiliares A y B por secuencias de 2n. Donde: n = 0,1,2,3... 3. Repetir los pasos 1 y 2 hasta que la secuencia sea mayor que la mitad del archivo a ordenar (secuencia{2n}> long(C)/2) Ejemplo: Ordenar los siguientes datos.

45

ALGORITMO
Inicio Sec = 1 Abrir C (Lectura) Repetir Abrir B (Escritura) Abrir A (Escritura) Seek (C, 0) Particionar Seek (A, 0); Seek (B, 0); Seek (C, 0) Mezclar Cerrar A; Cerrar B Sec = Sec * 2 Hasta Sec > (Filesize (C) Div 2) Cerrar C

Fin Particionar Inicio Mientras no eof (C) Hacer Copiar_SecP (C, A, Sec) Si no eof (C) Entonces Copiar_SecP(C,B,Sec) Fin si Fin mientras Fin Copiar_SecP (Var x, y : Archivo; Sec : Entero) Inicio Cont = 0 Mientras no eof (x) y (Cont < Sec) Hacer Leer (x, Reg) Grabar (y, Reg) Cont = Cont +1; Fin Mientras Fin Mezclar Inicio Mientras no eof (A) y no eof (B) Hacer Mezclar_Sec Fin Mientras

Fin

Mezclar_Sec Inicio SecA = 0; SecB = 0 Repetir PosA = FilePos (A) Leer A, RegA Seek (A, PosA) PosB = FilePos (B) Leer B, RegB Seek (B, PosB)

46

Sec-SecA). SecB = Sec Fin si Si no SecB = SecB + 1 Si SecB = Sec Entonces Copiar_SecP (A. primeramente en el archivo A.B Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1. Reg SecA =SecA + 1 Si SecA = Sec Entonces Copiar_SecP (B.Hasta Fin Si RegA < RegB Entonces Leer A. y luego en el archivo B. Partir el archivo C en secuencias ordenadas. 2. 3. SecA = Sec Fin si Fin si (SecA = Sec) y (SecB = Sec) ORDENACIÓN POR MEZCLA EQUILIBRADA El método funciona con todo tipo de archivos. copiar intercaladamente las secuencias ordenadas del archivo C. C. Repetir los pasos 1 y 2 hasta que la mezcla de secuencias sea igual a uno (n_tramos=1). C. 47 . Sec-SecB). hace el uso de los siguientes archivos: C Archivo a ordenar A. Ejemplo: Ordenar los siguientes datos. Reg Grabar C. Mezclar los archivos auxiliares A y B por secuencias ordenadas.

Reg Si eof (x) Entonces Fin_Tramo = TRUE Si no Pos = FilePos (x) Leer (x).B) Fin si Fin mientras Fin Copiar_Tramo (x. 0). Cerrar A. y : Archivo) Inicio Repetir Copiar_Dato (x. Seek (C. Cerrar B Hasta Num_Tramos =1 Cerrar C Fin Particionar Inicio Mientras no eof (C) Hacer Copiar Tramo (C. Pos ) Fin_Tramo = Reg > Reg1 Fin si Fin Mezclar Inicio Mientras no eof (A) y no eof (B) Hacer Mezclar_Tramos Num_Tramos = Num_Tramos + 1 Fin Mientras Fin si 48 . y : Archivo) Inicio Si eof (x) Entonces Fin_Tramo = TRUE Si no Leer (x). 0). y) Hasta Fin_Tramo Fin Copiar_Dato (var x. 0) Num_Tramos = 0 Mezclar.Abrir B (Escritura). Reg Grabar (y). Reg1) Seek (x.ALGORITMO PRINCIPAL Inicio Abrir C (Lectura) Repetir Abrir A (Escritura). A) Si no eof (C) Entonces Copiar_Tramo(C. Seek (B. Seek (A. 0) Particionar Seek (C.

. decenas. A1. etc. hace el uso de los siguientes archivos: C Archivo a ordenar A0. PosA) PosB = File Pos (B). C) Fin si Fin si Hasta Fin _Tramo Fin ORDENACIÓN POR DIGITOS El método funciona solo con archivos que almacenan datos numéricos con cifras elevadas. 2.Mientras no ef (A) Hacer Copiar_Tramo (A. RegA)... decena. Repetir los pasos 1 y 2 hasta que se haya inspeccionado todos los dígitos. Seek (B. A9 Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1. C) Num_Tramos = Num_Tramos + 1 Fin Mientras Fin Mezclar_Tramo Inicio Repetir PosA = File Pos (A). Mezclar los 10 archivos auxiliares A0. Leer (A. empezando del archivo A0 y finalizando en el archivo A10. Leer (B. Se debe empezar inspeccionando por la posicion de la unidad.. C) Si Fin_Tramo Entonces Copiar_Tramo (A. PosB) Si RegA < RegB Entonces Copiar_Dato (A.. Partir el archivo C de acuerdo al digito inspeccionado. centena. C) Fin Si Si no Copiar_Dato (B. centenas. es decir unidades. C) Si Fin_Tramo Entonces Copiar_Tramo (B. 49 .A9 en orden.. C) Num_Tramos = Num_Tramos + 1 Fin Mientras Mientras no ef (B) Hacer Copiar_Tramo (B. ejemplo si el digito inspeccionado es 1 este dato debe copiarse al archivo A1. RegB). 3.etc. Seek (A.

0) Mezclar Dig = Dig + 1 Cerrar_Archivos Hasta Dig > 4 Cerrar C Fin Particionar Inicio Mientras no eof (C) Hacer 50 . 0) Seek (C.9] of Archivo Inicio Abrir C (Lectura) Dig = 0 Repetir Abrir_Archivos Seek (C.Ejemplo:Ordenar los siguientes datos.. 0) Particionar Para I = 0 Hasta 9 Hacer Seek (Arch [ i ].. ALGORITMO FUNCION PRINCIPAL Var Arch : [0..

Reg Fin Mientras Fin Para Abrir_Archivos Inicio Para I = 0 Hasta 9 Hacer NOMBRE = 'DATOS'+ CHR(48 + i)+ '. Reg Grabar C. Reg Fin Mientras Fin Para I = 0 Hasta 9 Hacer Mientras no eof (Arch [I]) Hacer Leer Arch [I].DAT' Abrir Arch [i] (Escritura) Fin Para Fin Cerrar_Archivos Inicio Para I = 0 Hasta 9 Hacer Cerrar Arch [ i ] fin Para Fin 51 .Fin Mezclar Inicio Leer C. Reg Aux = Reg Div (Exp(Dig * Ln (10))) Pos = Aux Mod 10 Grabar Arch [Pos].

se realiza en tiempo de ejecución y en forma dinámica. La cantidad de nodos que una lista enlazada puede contener esta limitada por la memoria del computador.3 Listas Simplemente Enlazadas Circulares 5. La adición / eliminación en estas estructuras de datos.2 Lista Simplemente Enlazada 5.4 Listas Doblemente Enlazadas 5. Existen los siguientes tipos de listas enlazadas: Listas simplemente enlazadas 52 . mediante un enlace o puntero.TEMA 5 LISTAS ENCADENADAS OBJETIVOS Emplear estructuras dinámicas de datos en el procesamiento de la información. TIPOS DE LISTAS. Desarrollar algoritmos para optimizar las operaciones básicas que se llevan a cabo en proceso de ejecución en estructuras lineales.1 Introducción 5.5 Listas Doblemente Enlazadas Circulares 5.1 LISTAS ENCADENADAS Las listas enlazadas son estructuras de datos lineales. que constan de una secuencia de nodos que se encuentran enlazados uno con otro. CONTENIDO 5.

Un campo enlace (o puntero) que indica la posición del siguiente elemento de la lista.2 LISTAS SIMPLEMENTE ENLAZADAS Una lista simplemente enlazada se representa tal como se muestra en la siguiente grafica: Donde: El nodo Raíz es un puntero al primer elemento de la lista.Listas simplemente enlazadas circulares Listas doblemente enlazadas Listas doblemente Enlazadas circulares 5. NODO 53 . Cada elemento (nodo) de la lista simplemente enlazada debe tener dos campos: • • Un campo información (info) que contiene el valor de ese elemento y puede contener cualquier tipo estándar o definido por el usuario.

es necesario el uso de un puntero auxiliar ACT. en las listas simplemente enlazadas se puede realizar las siguientes operaciones básicas: • • • • Inserción Eliminación Búsqueda Recorrido RECORRIDO Para realizar el recorrido en una lista simple. empezando por la RAIZ y finalizando cuando el puntero ACT apunta a NIL. con la cual se visita toda la lista. ALGORITMO: Recorrido(Dato:Integer) Inicio Actual = Raíz Mientras(Actual <> Nil) hacer Actual =Actual^. OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS Como cualquier estructura de datos.sig 54 .Existe una marca para fin de lista. también representada por una barra inclinada o el signo eléctrico de tierra. Declaración de un nodo usando el lenguaje Pascal: Type pnodo = ^nodo nodo = record End. que es la constante NIL. }. Declaración de un nodo usando el lenguaje C: struct Nodo { int info. struct Nodo *sig. info : Integer. Sig :pnodo.

inf<>Dato) hacer Actual =Actual^. entre las cuales se tiene: • • • • Insertar cuando lista esta vacía Insertar al principio Insertar al final Insertar al medio de dos nodo En todas ellas se realiza una tarea común: • • • Crear una nuevo nodo Almacenar el elemento Agregar los enlaces respectivos INSERTAR CUANDO LISTA ESTA VACIA: 55 . INSERCION DE DATOS Existen distintas formas de adición de nodos a una lista simple. de acuerdo a los propósitos de uso de estos.sig Fin Mientras Si Actual^.inf = Dato entonces Mostar "El Dato Esta en la Lista" Sino Mostrar "No Existe el Dato" Fin si Fin. BUSQUEDA Para realizar la búsqueda en una lista simple.Mostar Actual^.inf Fin Mientras Fin. es necesario el uso de un puntero auxiliar ACT. ALGORITMO: Buscar(Dato:Integer) Inicio Actual = Raíz Mientras(Actual<>Nil) y (Actual^. con la cual se busca empezando por la RAIZ y finalizando cuando el puntero ACT apunta al elemento buscado o a NIL.

sig= nil(2) INSERTAR AL PRINCIPIO: Insertar(3) • • • • New(Nuevo) Nuevo^.Insertar(5) • • • • New(Nuevo) Nuevo^.inf= 5 Raiz = nuevo (1) Nuevo^.sig = Raiz(1) Raiz = Nuevo (2) INSERTAR AL FINAL: Insertar(13) 56 .inf= 3 Nuevo^.

Inf) Hacer Anterior = Actual Actual = Actual^.sig =Act(1) Ant^.sig = Nuevo(2) ALGORITMO : Insertar (Dato:Entero) Inicio New(Nuevo) Nuevo^.sig = Raiz Raiz = Nuevo Si no Nuevo^.sig =Nuevo(1) Nuevo^.sig = Actual 57 .inf = Dato Si Raiz = Nil Entonces Raiz = Nuevo Nuevo^ sig = Nil Si no Anterior = Raiz Actual = Raiz Mientras (Actual <>Nil) y (Dato> Actual^.• • • • New(Nuevo) Nuevo^.inf= 7 Nuevo^.sig =Nil(2) INSERTAR AL MEDIO DE DOS NODOS: Insertar(7) • • • • New(Nuevo) Nuevo^.inf= 13 ant^.sig Fin Mientras Si Anterior =Actual Entonces Nuevo^.

es necesario buscarlo en la lista primeramente. Eliminar un elemento distinto del primero ELIMINAR EL PRIMER ELEMENTO Dada la siguiente lista: Eliminar(5) • • Raiz= act^. Fin si Fin si Anterior^. La búsqueda se realiza con dos punteros auxiliares ANT y ACT.Fin. el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento. Eliminar el primer elemento 2.sig(1) Dispose(act) ELIMINAR UN ELEMENTO DISTINTO DEL PRIMERO Dada la siguiente lista: Eliminar(9) 58 . Existen dos casos que se presentan al eliminar un dato: 1.sig = Nuevo ELIMINAR DATOS Para eliminar un dato de una lista simple. si el dato se encuentra en la lista.

• • ant^.sig Dispose(act) ALGORITMO: Eliminar (Dato:Entero) Inicio Si Raiz = nil then Mostrar ‘No existe Datos’ Si no Anterior = Raiz Actual = Raiz Mientras (Actual <> Nil) y (Actual^. Existen dos tipos de listas enlazadas simples circulares: 59 . Por lo cual en estas listas no existe ni primero ni último elemento.sig Sino Anterior^.sig = Actual^.inf = Dato entonces Si Anterior = Actual entonces Raiz = Actual^.sig Fin Mientras Si Actual^.3 LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES. aunque se debe elegir obligatoriamente un puntero para referenciar la lista. Una lista circular es aquella en la cual el puntero siguiente del último elemento apunta hacia el primer elemento.sig = act^. Tiene el inconveniente de que requiere un diseño cuidadoso para evitar caer en un bucle infinito. Esta lista presenta la gran ventaja de que cada nodo en una lista circular es accesible desde cualquier nodo.inf <> Dato) Hacer Anterior = Actual Actual =Actual^.sig Fin si Dispose(Actual) Sino Imprimir "No Existe el Dato" Fin si Fin si Fin. 5.

OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES Como cualquier estructura de datos. ALGORITMO: Recorrido(Dato:Integer) Inicio Actual = Raíz^.• Listas simples circulares sin nodo cabecera • Listas simples circulares con nodo cabecera El manejo de la primera es complejo. en las listas simplemente enlazadas circulares se puede realizar las siguientes operaciones básicas: • • • • Inserción Eliminación Búsqueda Recorrido RECORRIDO Para realizar el recorrido en una lista simple circular. es necesario el uso de un puntero auxiliar ACT. debido a su fácil manejo.inf 60 .sig Mostarc Actual^. con la cual se visita toda la lista.sig Mientras(Actual <> Raiz) hacer Actual =Actual^. empezando por la RAIZ y finalizando cuando el puntero ACT apunta a NIL. de tal modo que solo se usaremos las listas enlazadas con nodo cabecera.

inf = Dato entonces Mostar "El Dato Esta en la Lista" Sino Mostrar "No Existe el Dato" Fin si Fin.inf <> Dato) hacer Actual =Actual^. es necesario el uso de un puntero auxiliar ACT. Fin Mientras BUSQUEDA Para realizar la búsqueda en una lista simple. que es el de crear una nuevo nodo para almacenar al elemento que será agregado a la lista.sig Mientras(Actual <> Raiz) y (Actual^. INSERTAR CUANDO LISTA ESTA VACIA: Insertar(5) 61 . ALGORITMO : Buscar(Dato:Integer) Inicio Actual = Raíz^. de acuerdo a los propósitos de uso de estos.Fin. INSERCION DE DATOS Existen distintas formas de adición de nodos a una lista simple circular. Entre las cuales se tiene: • • Insertar cuando lista esta vacía Insertar al medio de dos nodos En todas ellas se realiza una tarea común. con la cual se busca empezando por la RAIZ y finalizando cuando el puntero ACT apunta al elemento buscado o a NIL.sig Fin Mientras Si Actual^.

sig = Raiz Si no Anterior = Raiz Actual = Raiz^ sig Mientras (Actual <> Raiz) y (Dato> Actual^.sig = Nuevo (2) ALGORITMO : Insertar (Dato:Entero) Inicio New(Nuevo) Nuevo^.inf = Dato Si Raiz = Nil Entonces New(Cab) Raiz = Cab Cab^.inf= 7 Nuevo^.• • • • • • New(Cab) New(Nuevo) Nuevo^.Inf) Hacer 62 .sig= Raiz (3) INSERTAR AL MEDIO DE DOS NODOS: Insertar(7) • • • • New(Nuevo) Nuevo^.inf= 5 Raiz = Cab (1) Cab^.sig = Act (1) Ant^.sig= nuevo (2) Nuevo^.sig =Nuevo Nuevo^.

La búsqueda se realiza con dos punteros auxiliares ANT y ACT. Existen dos casos que se presentan al eliminar un dato: • • Eliminar él ultimo elemento de la lista Eliminar un elemento distinto del ultimo ELIMINAR EL ULTIMO ELEMENTO DE LA LISTA Dada la siguiente lista: Eliminar(9) Para eliminar el ultimo elemento.sig = Nuevo Fin si Fin. es necesario liberar la memoria de los nodos que apuntan a ANT y ACT. • • • Dispose(ant) Dispose(act) Raiz = nil (1) ELIMINAR UN ELEMENTO DISTINTO DEL ULTIMO Dada la siguiente lista: 63 .sig = Actual Anterior^.sig Fin Mientras Nuevo^. si el dato se encuentra en la lista. es necesario buscarlo en la lista primeramente. el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento.Anterior = Actual Actual = Actual^. ELIMINAR DATOS Para eliminar un dato de una lista simple circular.

inf <> Dato) Hacer Anterior = Actual Actual =Actual^.sig Dispose(act) ALGORITMO: Eliminar (Dato:Entero) Inicio Si Raiz = nil then Mostrar ‘No existe Datos’ Si no Anterior = Raiz Actual = Raiz^. Estos recorridos se pueden conseguir manteniendo dos campos de enlace en cada nodo en lugar de uno.sig Fin Mientras Si Actual^.sig entonces Dispose(Anterior) Raiz = Nil Sino Anterior^.4 LISTAS DOBLEMENTE ENLAZADAS.sig Mientras (Actual <> Raiz) y (Actual^.sig Fin si Dispose(Actual) Sino Imprimir "No Existe el Dato" Fin si Fin si Fin. 64 . En muchas aplicaciones se requiere recorrer la lista en dos direcciones. 5.sig = act^.inf <>Raiz entonces Si Anterior = Actual^.Eliminar(5) • • ant^.sig = Actual^.

El predecesor se llama enlace izquierdo y el sucesor enlace derecho. también representada por una barra inclinada o el signo eléctrico de tierra. campo info contiene cualquier tipo estándar de datos. que es la constante NIL.Estos enlaces(punteros) se utilizan para denotar la dirección del predecesor y sucesor de un nodo dado. Nodo Fin es un puntero al ultimo elemento de la lista.contiene dos campos de enlace se denominará lista lineal doblemente enlazada. apunta al anterior nodo de la lista. Declaración de un nodo usando el lenguaje Pascal: Type pnodo = ^nodo nodo = record info : Integer. End. Declaración de un nodo usando el lenguaje C: Struct nodo { int info. Sig :pnodo. OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS. Donde: • • • Nodo Inicio es un puntero al primer elemento de la lista. Las operaciones básicas para manipular listas doblemente enlazadas son: 65 . campo enlace sig. }. apunta al siguiente nodo de la lista. struct nodo *Ant. Una lista cuya Estructura de Nodo. NODO Donde: • • • campo enlace ant. Existe una marca para fin de lista. * Sig. Ant.

inf 66 .    Inserción Eliminación Recorrido Búsqueda RECORRIDO En una lista doble circular es posible realizar dos tipos de recorridos. ALGORITMO: Inicio Actual = Fin} Mientras Actual <> Nil Hacer Mostrar Actual^.   Recorrido en forma ascendente Recorrido en forma descendente RECORRIDO EN FORMA ASCENDENTE Este recorrido se inicia cuando el puntero apunta a INICIO y se recorre de nodo a nodo con el puntero SIG hasta que el nodo apunte a NIL. RECORRIDO EN FORMA DECENDENTE Este recorrido se inicia cuando el puntero apunta a FIN y se recorre de nodo a nodo con el puntero ANT hasta que el puntero apunte a NIL. ALGORITMO: Inicio Actual = Inicio Mientras Actual <> NIL hacer Mostrar Actual^. esto debido a que en estas listas existen enlaces en ambas direcciones.inf Actual = Actual^.sig Fin Mientras Fin.

de acuerdo a los propósitos de uso de estos.ant Fin Mientras Fin.inf= 5 Inicio = nuevo (1) Fin = nuevo (2) Nuevo^.ant= nil (3) Nuevo^. INSERTAR CUANDO LISTA ESTA VACIA: Dada la siguiente lista: Insertar(5) • • • • • • New(Nuevo) Nuevo^. INSERCION DE DATOS Existen distintas formas de adición de nodos a una lista doble. que es el de crear una nuevo nodo para almacenar al elemento que será agregado a la lista.sig= nil (4) INSERTAR AL PRINCIPIO Dada la siguiente lista: Insertar(3) 67 .Actual = Actual^. Entre las cuales se tiene: • • • • Insertar cuando lista esta vacía Insertar al principio Insertar al final Insertar al medio de dos nodos En todas ellas se realiza una tarea común.

ant = Nuevo(3) Nuevo^.ant = Ant(4) INSERTAR AL MEDIO DE DOS NODOS: Dada la siguiente lista: 68 .sig = Act(2) Act^.ant = Nil(4) INSERTAR AL FINAL: Dada la siguiente lista: Insertar(13) • • • • • • New(Nuevo) Nuevo^.inf= 3 Inicio = Nuevo(1) Nuevo^.sig = Nuevo(1) Nuevo^.inf= 13 ant^.sig = Nil(2) Fin = Nuevo(3) Nuevo^.• • • • • • New(Nuevo) Nuevo^.

Final = Nuevo Nuevo^.ant = Nil Si no Si Actual = Nil Entonces Final = Nuevo Si no Actual^.ant = Nuevo Fin si Nuevo^. es necesario buscarlo en la lista primeramente.inf= 7 Ant^. Dato) Hacer ELIMINAR DATOS Para eliminar un dato de una lista doble.sig = Inicio Inicio^.ant = Anterior Fin si Fin si Fin.ant = Nil.sig = Nuevo(1) Nuevo^.sig = Act(2) Act^.ant = Nuevo Inicio = Nuevo Nuevo^.ant = Nuevo(3) Nuevo^.sig Fin Mientras Si Actual = Anterior Entonces Nuevo^. Nuevo^.inf < Anterior = Actual Actual =Actual^.ant = Ant (4) ALGORITMO: Insertar (Dato:Entero) Inicio New(Nuevo) Si Inicio = Nil Entonces Inicio = Nuevo. 69 .sig = Nil Si no Anterior = Inicio Actual = Inicio Mientras (Actual <> Nil) y( Actual^.sig = Nuevo Nuevo^.Insertar(7) • • • • • • New(Nuevo) Nuevo^.sig = Actual Anterior^.

Inicio = Inicio^. Existen dos casos que se presentan al eliminar un dato: • • • Eliminar el primer elemento Eliminar un elemento distinto del primero Eliminar él ultimo elemento ELIMINACIÓN AL PRINCIPIO: Dada la siguiente lista: Eliminar(5) 1.sig 2. si el dato se encuentra en la lista. el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento.La búsqueda se realiza con dos punteros auxiliares ANT y ACT.ant = Nil Dispose(act) ELIMINACIÓN AL MEDIO: Dada la siguiente lista: Eliminar(8) 70 . Inicio^.

Ant = Anterior Si no Final = Anterior 71 .sig^.1. Final = Ant Dispose(act) ALGORITMO: Eliminar (Valor: Entero) Inicio Anterior = Inicio Actual = Inicio Mientras (Actual <> Nil) y (Actual^.sig 2. Ant^.inf <> Valor Entonces Mostrar "No Existe el Elemento" Si no Si Actual=Anterior Entonces Si Actual^.ant = Nil Si no Final = Nil Inicio = Nil Fin si Si no Si Actual^.sig = Act^.sig <> Nil entonces Actual^.sig Fin Mientras Si Actual^. Act^.sig <> Nil Entonces Inicio = Inicio^.sig^.ant = Ant Dispose(act) ELIMINACIÓN AL FINAL: Dada la siguiente lista: Eliminar (9) 1.sig Inicio^.sig = nil 2.inf <> Valor) hacer Anterior = Actual Actual =Actual^.sig = Act^. Ant^.

sig = Actual^.5 LISTAS CIRCULARES DOBLEMENTE ENLAZADAS. 72 . de tal modo que solo se usaremos las listas enlazadas con nodo cabecera. Una lista doble circular es aquella en la cual el puntero siguiente del último elemento apunta hacia el primer elemento. Tiene el inconveniente de que requiere un diseño cuidadoso para evitar caer en un bucle infinito.Fin si Anterior^. aunque se debe elegir obligatoriamente un puntero para referenciar la lista. Existen dos tipos de listas enlazadas simples circulares: Listas dobles circulares sin nodo cabecera Listas dobles circulares con nodo cabecera El manejo de la primera es complejo.sig Fin Fin si Fin. si 5. Esta lista presenta la gran ventaja de que cada nodo en una lista doble circular es accesible desde cualquier nodo. En estas listas no existe ni primero ni último elemento. debido a su fácil manejo.

esto debido a que en estas listas existen enlaces en ambas direcciones. ALGORITMO: Inicio Actual = Raiz^.   Recorrido en forma ascendente Recorrido en forma descendente RECORRIDO EN FORMA ASCENDENTE Este recorrido se inicia cuando el puntero apunta a Raiz^.inf Actual = Actual^. 73 .sig Fin Mientras Fin. Las operaciones básicas para manipular listas doblemente enlazadas son:     Inserción Eliminación Recorrido Búsqueda RECORRIDO En una lista doble circular es posible realizar dos tipos de recorridos.ant y se recorre de nodo a nodo con el puntero ANT hasta llegar al nodo Raiz.OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS CIRCULARES.sig y se recorre de nodo a nodo con el puntero SIG hasta llegar al nodo Raiz. RECORRIDO EN FORMA DECENDENTE Este recorrido se inicia cuando el puntero apunta a Raiz^.sig Mientras Actual <> Raiz hacer Mostrar Actual^.

ant Fin Mientras Fin.inf Actual = Actual^.ant Mientras Actual <> Raiz Hacer Mostrar Actual^.inf=9 Raiz = Cab (1) Cab^.ant = Nuevo (4) Nuevo^.ALGORITMO: Inicio Actual = Raiz^.sig = Cab (3) Cab^.ant = Cab (5) 74 .sig = Nuevo (2) Nuevo^. INSERCION DE DATOS Existen dos formas de inserción de datos a una lista doblemente enlazada circular: • • Inserción en una lista vacía Insertar al medio de dos nodos INSERCIÓN EN UNA LISTA VACIA Insertar(9) • • • • • • • • New(Cab) New(nuevo) nuevo^.

sig = Nuevo Nuevo^.ant = Nuevo Nuevo^.ant = NodoC Si no Anterior = Raiz Actual = Raiz^.ant = Nuevo(3) Nuevo^.sig = Act(2) Act^.inf < dato) Hacer Anterior = Actual Actual =Actual^. 75 .ant = Ant(4) ALGORITMO: Insertar (dato:entero) Inicio New(Nuevo) Nuevo^.sig = Actual Actual^.ant = Nuevo Fin si Fin.sig = Nuevo(1) Nuevo^.sig Mientras (Actual <> Raiz) y (Actual^.ant = Anterior Actual^.inf = Dato Si Raiz = Nil Entonces New(NodoC) Raiz = NodoC NodoC^.sig Fin Mientras Nuevo^.INSERTAR AL MEDIO DE DOS NODOS: Insertar(6) • • • • • • • New(Cab) New(nuevo) nuevo^.inf=6 Ant^.sig = NodoC NodoC^.

el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento. si el dato se encuentra en la lista.ELIMINAR DATOS Para eliminar un dato de una lista doble circular. Existen dos casos que se presentan al eliminar un dato: • • Eliminar él ultimo elemento Eliminar un elemento ELIMINAR ÉL ULTIMO ELEMENTO Eliminar(9) • • • Dispose(ant) Dispose(act) Raiz = Nil ELIMINAR UN ELEMENTO Eliminar(9) 76 . es necesario buscarlo en la lista primeramente. La búsqueda se realiza con dos punteros auxiliares ANT y ACT.

sig = Actual^.sig Actual^.sig Fin Mientras Si (Actual^.• • • Ant^.ant = Ant(2) Dispose(act) ALGORITMO: Eliminar (Valor:Entero) Inicio Anterior = Raiz Actual = Raiz^.ant= Anterior Fin si Dispose(Actual) Fin si Fin.sig ^.sig ^.inf <> Valor) Hacer Anterior = Actual Actual =Actual^.sig(1) Act^.sig = Anterior) Entonces Dispose(Anterior) Raiz = Nil Si no Anterior^.sig Mientras (Actual <> Raiz) y (Actual^. 77 .sig = Act^.inf <> Valor) Entonces Mostrar "No Existe el Elemento" Si no Si Actual^.

Un árbol es una lista en la que cada uno de sus elementos apunta a uno. Dos árboles son iguales cuando tengan igual número de nodos. estén dispuestos de igual manera REPRESENTACIÓN Un árbol es una estructura de datos no lineal que establece una jerarquía entre sus elementos. Lista de adyacencia. 78 . además. de forma que la estructura puede estar vacía o compuesta por un elemento del tipo base T del que cuelgan un número finito de estructuras árbol similar. a las que llamaremos subárboles. CONTENIDO 6. por tanto está compuesto de elementos del mismo tipo base T.1 Introducción 6. Un árbol puede ser representado. en tres formas diferentes:   Matriz de adyacencia.2 Conceptos Asociados 6. ninguno o varios elementos del mismo tipo. Un árbol es una estructura dinámica y homogénea.4 Árboles Equilibrados o AVL 6. y entre sí son disjuntos.3 Árbol Binario de Búsqueda 6.1 DEFINICION.TEMA 6 ÁRBOLES OBJETIVOS Desarrollar aplicaciones con estructuras ramificadas que optimizan las operaciones básicas. igual contenido en ellos y. Encontrar nuevas formas de organización de datos en forma ramificada de acuerdo a las características de la aplicación.

 Estructura dinámica pura. Ejemplo: ESTRUCTURA DINÁMICA PURA En ella. EnlaceN: PNodo. todos los componentes o nodos.. siendo n el número de nodos. y referenciales por medio de punteros.. 79 .n] OF BOOLEAN donde n es el número de nodos que tiene el árbol y cada posición de la matriz indicará si existe un enlace entre dos nodos.. Esto es normal hacerlo en lenguajes en que no pueden crearse componentes dinámicamente. MATRIZ DE ADYACENCIA Es un array [1. Ejemplo: LISTA DE ADYACENCIA Es una tabla de 1 a n.1. Enlace1. donde cada elemento de la tabla representa cada uno de los nodos del árbol y de cada uno de los elementos sale un puntero a una lista que está formada por todos los nodos que están enlazados con él... Vamos a tener un tipo como: PNodo=^Nodo. Nodo=RECORD Info:Tinfo. END. se representan por punteros explícitos..n.

Nivel : Es el número de ramas que hay que recorrer para llegar a él desde la raíz. Raíz: Es aquel nodo que no tiene antecesores. llamado descendiente o hijo. todos son descendientes directos o indirectos de el. el grado de un árbol es igual al del nodo con mayor grado.6.2 CONCEPTOS ASOCIADOS A continuación veremos algunos conceptos asociados a los Arboles. tendiendo en cuenta que la raíz tiene nivel uno. Antecesor o padre: Es un nodo del que cuelga algún otro. Rama: Es cada uno de los enlaces que existe entre los nodos de un árbol. 80 . Grado de un nodo: Es el número de descendientes directos que tiene. así como al propio m. Nodo: Cada uno de los elementos de un árbol. es decir. Subárbol: Se llama subárbol de raíz m al conjunto de nodos que dependen directa o indirectamente de él.

llamados subárbol izquierdo y derecho de la raíz. es decir. Se les conoce con el nombre de árboles binarios. Longitud de camino interno de un arbol: Es la suma de las longitudes de camino de todos sus nodos. LCI = 1+2+2+3+3+3 = 14 Longitud de camino externa: Es la suma de las longitudes de camino de todos los Nodos Especiales (Es aquel que se hace colgar de aquellos nodos que no tienen completo el cupo de descendientes). que no tiene ningún descendiente.3 ARBOL BINARIO Los árboles de grado 2 tienen una especial importancia. 81 . Nodo interno: Es aquel que no es hoja. LCE = 3+4+4+4+4+4+4 = 27 Longitud de camino interna media: Es la longitud de camino interna partido del número de nodos 6. Se define un árbol binario como un conjunto finito de elementos (nodos) que bien está vació o está formado por una raíz con dos árboles binarios disjuntos.Nodo terminal u hoja: Es aquel que tiene grado cero.

del recorrido del árbol. De esta forma si recorremos los nodos de un nivel. Si el árbol está organizado de tal manera que la clave de cada nodo es mayor que todas las claves del subárbol izquierdo. Esta operación se considera entonces como un parámetro de una tarea más general que es la visita de todos los nodos o. almacenamos en la cola los punteros a todos los nodos del nivel siguiente. empezando por el nodo raíz. Para ello se utiliza una estructura auxiliar tipo "cola" en la que después de mostrar el contenido del nodo. 82 . se utilizará la palabra árbol para referirse a árbol binario. entonces los nodos individuales se visitan en un orden específico. DEFINICION Los árboles binarios se utilizan frecuentemente para representar conjuntos de datos cuyos elementos se identifican por una clave única. RECORRIDO EN AMPLITUD. Recorrido en profundidad. y menor que todas las claves del subárbol derecho se dice que este árbol es un árbol binario de búsqueda. mientras mostramos su contenido. En el recorrido por amplitud se visitan los nodos por niveles. Existen dos formas básicas de recorrer un árbol: o o Recorrido en amplitud.En los apartados que siguen se considerarán únicamente árboles binarios y. Si se considera la tarea como un proceso secuencial. por lo tanto. se almacenan los punteros correspondientes a sus hijos izquierdo y derecho. como se denomina usualmente. Los árboles de grado superior a 2 reciben el nombre de árboles multicamino. Ejemplo: OPERACIONES BASICAS Una tarea muy común a realizar con un árbol es ejecutar una determinada operación con cada uno de los elementos del árbol. y pueden considerarse como organizados según una estructura lineal.

de acuerdo al orden en que se visitan los nodos.inf Si ptr^der <> nil entonces Cima=cima+1 Pila[cima] = ptr^. Al contrario que las listas enlazadas. Para visualizar o consultar los datos en un árbol se necesita recorrer el árbol. Fin_mientras RECORRIDO EN PROFUNDIDAD. los recorridos se conocen como:    Recorrido inorden Recorrido preorden Recorrido postorden 83 . Existen métodos de recorrido de un árbol binario. de forma que será preciso elegir cuidadosamente el tipo de recorrido. 10. un segundo valor. 5. 15.izq Fin_si Fin. Según sea la estrategia a seguir. 25 El algoritmo: Amplitud Inicio Ptr = raiz Cima = 1 Inicio=1 Pila[cima] = Ptr Mientras Inicio<=cima hacer ptr=Pila[Inicio] inicio++ Mostrar ptr^. los árboles no tienen un primer valor.Resultado: 20. 30. etc.der Fin_si Si ptr^izq <> nil entonces Cima=cima+1 Pila[cima] = ptr^.

) . por lo que siguiendo con el orden (Raiz.) El algoritmo usando recursividad: preorden (var p:pnodo) inicio si p <>nil entonces escribir p^.Visitar el nodo (Raiz) .Visitar el nodo (Raiz) ..Recorrer el subárbol derecho (der. · Por ultimo se visita el subárbol derecho que consta de los nodos (C. se visita primero C. luego F y por ultimo G. izq.). · Primero se visita el nodo raíz A.inf preorden (p^. der.Recorrer el subárbol izquierdo (izq..). Este consta de los nodos (B.Recorrer el subárbol izquierdo (izq. Siguiendo el orden (Raiz. luego D y por ultimo E. El recorrido es: A-B-D-E-C-F-G El algoritmo sin usar recursividad: 84 .) .izq) preorden (p^.Recorrer el subárbol derecho (der. · Después se visita el subárbol izquierdo. los nodos se han numerado en el orden que son visitados en el recorrido preorden . der. F y G). se visita primero B. el método implica los siguientes pasos: .Las tres etapas básicas en el recorrido de un árbol binario recursivamente son: .der) fin si fin En el árbol.) RECORRIDO PREORDEN Si el árbol no esta vació. D y E). izq.

.izq) escribir p^.izq <> nil entonces Ptr = ptr^. Fin_mientras RECORRIDO INORDEN Si el árbol no esta vació.der Fin_si Si ptr^.Visitar el nodo (Raiz) . 85 .Recorrer el subárbol izquierdo (Izq) .inf Si ptr^der <> nil entonces Cima=cima+1 Pila[cima] = ptr^. el método implica los siguientes pasos: . los nodos se han numerado en el orden que son visitados en el recorrido enorden.izq Sino Ptr = pila[cima] Cima=cima-1 Fin_si Fin.der) fin si fin En el árbol.Recorrer el subárbol derecho (Der) El algoritmo usando recursividad: inorden (var p:pnodo) inicio si p <> nil entonces inorden (p^.Preorden Inicio Cima = 1 Pila[cima] = nil Ptr = raiz Mientras ptr <> nil hacer Mostrar ptr^.inf inorden (p^.

· Después se visita el nodo raíz A. F y G).der <> nil entonces Ptr = ptr^. Este consta de los nodos (B. se visita primero F.izq Fin_mientras Ptr = pila[cima] Cima=cima-1 Tieneder =false Mientras Ptr <> nil y no tieneder hacer Mostrar ptr ^. el método implica los siguientes pasos: . Der).Recorrer el subárbol derecho (Der) . RECORRIDO POSTORDEN Si el árbol no esta vació. siguiendo el orden (Izq.inf Si ptr^. Der).der Tieneder = true Sino Ptr = pila[cima] Cima=cima-1 Fin_si Fin_mientras Fin_mientras Fin. · Por ultimo se visita el subárbol derecho que consta de los nodos (C. se visita primero D. luego C y por ultimo G. Raiz. El recorrido es: D-B-E-A-F-C-G El algoritmo sin usar recursividad: Inorden Inicio Cima = 1 Pila[cima]=nil Ptr = raiz Mientras ptr <> nil hacer Mientras ptr <> nil hacer Cima=cima+1 Pila[cima] = ptr Ptr = ptr^.Recorrer el subárbol izquierdo (Izq) . Raiz. por lo que siguiendo con el orden (Izq. luego B y por ultimo E.Visitar el nodo (Raiz) El algoritmo usando recursividad: postorden (var p:pnodo) 86 .· El primer recorrido es el subárbol izquierdo del nodo raíz. D y E).

F y G). los nodos se han numerado en el orden que son visitados en el recorrido preorden. se visita primero D.izq Fin_mientras Ptr = pila[cima] Cima = cima-1 Salir = false 87 .der Fin_si Ptr = ptr^.inicio si p <> nil entonces postorden (p^. · Por ultimo se visita el subárbol derecho que consta de los nodos (C.der) escribir p^.izq) postorden (p^. Siguiendo el orden (Izq. · Primero se visita el subárbol izquierdo.inf fin si fin En el árbol. se visita primero F. Raiz). D y E). Este consta de los nodos (B. luego G y por ultimo C. Der.der <> nil entonces Cima = cima+1 Pila[cima]= -ptr^. luego E y por ultimo B. El recorrido es: D-E-B-F-G-C-A El algoritmo sin usar recursividad: Postorden Inicio Cima = 1 Pila[cima]=nil Ptr = raiz Mientras ptr <> nil hacer Mientras ptr <> nil hacer Cima=cima+1 Pila[cima] = ptr Si ptr^. · Por ultimo se visita el nodo raíz A. por lo que siguiendo con el orden (Izq. Der. . Raiz).

dato) Fin_si Fin_si Fin.inf = dato Raiz^. Mientras ptr <> nil y no salir hacer Si prt > 0 entonces Mostrar prt^. ELIMINAR UN DATO Existen varios casos de eliminación en un arbol binario de búsqueda: Nodo que no tiene hijos: Solución : Ptr = nil Nodo que tiene un hijo: 88 .izq = nil Raiz^.inf entonces Insertar (raiz^. se realiza de acuerdo al valor que se debe insertar.der = nil Sino Si dato > raiz^.dato) Sino Insertar(raiz^.dato:entero) Inicio Si raiz = nil entonces New(raiz) Raiz^.inf Ptr = pila[cima] Cima = cima-1 Sino Ptr = -ptr Salir=true Fin_si Fin_mientras Fin_mientras INSERCIÓN DE DATOS La inserción de datos en un arbol binario de búsqueda.der. si el dato es menor que la raíz es insertada en el subárbol izquierdo. Insertar(Var raiz:pnodo.Fin. si el dato es mayor que la raíz es insertada en el subárbol derecho.izq.

El nodo del subárbol derecho que se encuentra mas a la izquierda 89 . donde el nodo a ser eliminado puede ser reemplazado por los siguientes nodos: caso a).Solución : Ptr = ptr^.El nodo del subárbol izquierdo que se encuentra mas a la derecha caso b).izq Nodo que tiene dos hijos: En este caso existen dos posibilidades de reemplazo...der Solución : Ptr = ptr^.

der = nil entonces Ptr=aux^. · Si la clave buscada es mayor que la clave raíz.izq Sino Reemplazar(aux^. · Si las claves son iguales.inf entoces Eliminar (dato.inf aux = Ader Ader = Ader^. 6.der) Sino Ptr^.ptr^. BÚSQUEDA DE DATOS La búsqueda de un nodo comienza en el nodo raíz y sigue estos pasos: · La clave buscada se compara con la clave del nodo raíz.ALGORITMO : Eliminar(dato:integer. el arbol de la figura representa la expresión (A+B)*C. la búsqueda se reanuda en el subárbol derecho. o si el subárbol esta vació. Las expresiones 90 .izq=nil entonces Ptr =aux^.inf = Ader^. la búsqueda se reanuda en el subárbol izquierdo. Por ejemplo.4 ÁRBOLES BINARIOS DE EXPRESIONES Los árboles binarios se utilizan para almacenar expresiones. Reemplazar(Var Ader:pnodo) Inicio Si Ader^.izq) Sino Aux =ptr Si aux^.der) Sino Si dato < ptr^.der <> nil entonces Reeplazar(Ader^.inf entonces Eliminar(dato. · Si la clave buscada es menor que la clave raíz.izq) Fin_si Fin_si Free(aux) Fin_si Fin_si Fin_si Fin.der Sino Si aux^.Var ptr:pnodo) Inicio Si ptr = nil entonces Mostrar "no existe el elemento" Sino Si dato > ptr^.ptr^. la búsqueda se detiene.izq Fin_si Fin.

como estructura de datos auxiliares. extraer de la pila de punteros los dos últimos apuntadores. Ejemplo: Sea la expresión : Q= 4+5^(2*3)+8 1. Cuando se lee un OPERANDO se crea un árbol de un nodo y se mete el apuntador a el en correspondiente pila. 4. La notación infija es la empleada habitualmente y requiere el uso de paréntesis. una pila de punteros a los nodos de un árbol y otra pila de operadores para retenerlos temporalmente hasta que llegue el momento de incorporarlos al árbol. Los pasos a seguir son lo siguientes.El ) saca los operadores de la pila hasta el ( 91 .- 2. Cuando se lee un OPERADOR se retiene en la pila de operadores. Cuando se lee un PARÉNTESIS IZQUIERDO se retiene en la pila de operadores.matemáticas se pueden escribir según diversos tipos de notaciones. El apuntador a este nuevo árbol se coloca ahora en la pila de apuntadores. pero únicamente cuando es necesario modificar la prioridad entre los distintos operadores. Los operadores se van poniendo en esta pila hasta encontrar uno con mayor o igual prioridad. Con estos tres elementos. El proceso termina cuando se acaba la entrada y la pila de operadores queda vacía.. en cuyo caso se sacan los que hubiera en la pila de mayor o igual prioridad y se coloca en ella este ultimo operador leido. Nota: Al sacar de la pila de operadores uno de ellos. Cuando se lee un PARÉNTESIS DERECHO se sacan los OPERADORES que hubiera en la pila de operadores hasta encontrar el paréntesis izquierdo. se forma un nuevo árbol cuya raíz almacena el operador y los punteros anteriores. 5. 3. 2. CONSTRUCCIÓN A PARTIR DE UNA EXPRESIÓN EN NOTACIÓN CONVENCIONAL Para construir se utilizaran. 1.

.5 ÁRBOLES EQUILIBRADOS O AVL Es una suavización de las restricciones para formar árboles perfectamente equilibrados.3.- 6.El + saca de la pila todos los operadores con mayor prioridad que el y l continuación se coloca el 4.- 5. Un árbol AVL (llamado así por las iniciales de sus inventores: Adelson-Velskii y Landis) es un árbol binario de 92 .

que en el momento de insertar lo vamos a poner a TRUE para después controlar si se ha desequilibrado o no. Si a la hora de sumar o restar un uno se sale del rango hay que reequilibrar. las alturas de sus subárboles izquierdo y derecho no difieren en más de 1. Por definición. 0 ó 1.altura subárbol izquierdo. incluso en el peor de los casos. este valor debe ser -1. Cuando insertamos por la derecha incrementamos el valor del campo de equilibrio. Vamos a añadir un campo nuevo a la declaración del tipo TArbol. que se llamará factor de equilibrio (equ). además una variable global llamada crecido de tipo BOOLEAN. ya que la altura del subárbol izquierdo es igual que la del derecho. sino que además conduce a un procedimiento de reequilibrado relativamente sencillo. se pueden realizar en O(lon n) unidades de tiempo. En un árbol AVL. de modo que no es necesario explorar todo el árbol después de cada inserción o borrado. Condiciones para variar equ: o o o o La inserción se hace en las hojas Cuando creamos un nuevo nodo el campo de equilibrio vale 0. El algoritmo para mantener un árbol AVL equilibrado se basa en reequilibrados locales. Insertar un nodo con una clave dada. las siguientes operaciones: Encontrar un nodo con una clave dada. este factor de equilibrio (equ) es la diferencia entre las alturas del árbol derecho y el izquierdo: FE = altura subárbol derecho . para un árbol AVL. Borrar un nodo con una clave dada. Se sube restando o sumando 1 hasta llegar a un cero. que quedarán representados en los casos mostrados a continuación. 93 . DESEQUILIBRIOS Y REEQUILIBRIOS Al insertar un nuevo nodo en un árbol equilibrado se pueden producir desequilibrios. y a una longitud de camino media prácticamente idéntica a la del árbol perfectamente equilibrado. INSERCIÓN EN AVL La inserción se hace siempre en las hojas. DEFINICIÓN La definición no sólo es simple.búsqueda en el que para cada nodo. y vamos a tener un campo de equilibrio. Cuando insertamos por la izquierda decrementamos el valor del campo de equilibrio.

Se añade al subarbol izquierdo del nodo A un nuevo dato "X".IZQUIERDA SIMPLE. 94 . DESEQUILIBRIO DERECHA -DERECHA SIMPLE. Se corrige con la rotación izquierda-izquierda simple. DESEQUILIBRIO IZQUIERDA . donde se observa que el nodo B ya se encuentra crecido en 1 nivel en su subarbol izquierdo. las cajas rectangulares representan subárboles. ya que el subarbol izquierdo del nodo B se encuentra crecido ahora en 2 niveles. Simples transformaciones restauran el equilibrio deseado. que tendrá al final el campo de equilibrio a 0. que consiste en subir el nodo A. Dado el siguiente Arbol Balanceado. lo que causa un desequilibrio en el arbol. y la altura añadida por la inserción se indica con cruces.En las figuras.

lo cual implica que no puede haber nodos desbalanceados más arriba en el árbol. y b corresponde al nodo N. Nótese que ahora el nuevo árbol tiene la misma altura que antes de insertar el elemento. Nótese también que el árbol sigue cumpliendo con la propiedad de ser ABB. DESEQUILIBRIO IZQUIERDO-DERECHO COMPUESTO Dado el siguiente Arbol Balanceado. lo que causa un desequilibrio en el arbol. La figura muestra la situación antes y después de la rotación simple. lo cual se logra cambiando las referencias derecha de b e izquierda de d. Se añade al subarbol derecho del nodo A un nuevo dato "X". N'. para recuperar la condición de balance se necesitaria bajar A en un nivel y subir E en un nivel.Se reequilibra con rotación derecha-derecha simple. 95 . la altura de N es la altura de C+1. quedando este último como nueva raíz del árbol. donde se observa que el nodo B ya se encuentra crecido en 1 nivel en su subarbol izquierdo. Idealmente. ya que el subarbol izquierdo del nodo B se encuentra crecido ahora en 2 niveles. Es el reflejado del anterior. por lo que es necesaria una sola rotación simple para devolver la condición de balance al árbol. donde el elemento X fue insertado en E. Antes de la inserción. C+1.

96 .IZQUIERDO COMPUESTO Se reequilibra con rotación derecha-izquierdo compuesto. DESEQUILIBRIO DERECHO .Se corrige con la rotación izquierda-derecha compuesta. es el reflejado del anterior. Se sube el nodo C que pasa a tener el campo de equilibrio a 0.

y en el nodo 68 se pasa a -2. y b. ningún elemento hacia arriba del árbol queda desbalanceado.drcho = n n = n1 Realizada la rotación. Se ha roto el criterio de equilibrio y debe de reestructurarse. al regresar por el camino de búsqueda cambia los factores de equilibrio.Para el caso de la figura. A este proceso de dos rotaciones simples se le conoce como rotación doble. la altura de N antes de la inserción era G+1. los factores de equilibrio serán siempre O en las rotaciones simples. nl y n2 referencia al nodo que viola la condición de equilibrio y a los descendientes en el camino de búsqueda. obteniéndose el resultado de la figura. EJEMPLO DE INSERCIONES DE NODOS A continuación se simulan las inserciones de nodos en un árbol de búsqueda equilibrado. Para recuperar el balance del árbol es necesario subir C y E y bajar A. El factor de equilibrio actual de un nodo y el nuevo al añadir un nodo se representan como superíndices de los nodos. Los movimientos de los punteros para realizar esta rotación II n^. partiendo del árbol vació. Por comodidad se supone que el campo clave es entero. Nótese que el nuevo árbol cumple con la propiedad de ser ABB después de la rotación doble. Insertar las claves 68-45-29: Una vez insertado el nodo con la clave 29. Al ser los factores de equilibrio -l y -2 deben de realizarse una rotación de los nodos II para rehacer el equilibrio. ya rotado. y la segunda entre d. y como la altura del nuevo árbol N' es la misma que antes de la inserción del elemento. así el del nodo 45 pasa a -1.izqdo = n1^. El árbol queda de la forma siguiente: 97 . lo cual se logra realizando dos rotaciones simples: la primera entre d y f.drcho n1^. por lo que solo es necesaria una rotación doble para recuperar el balance del árbol después de la inserción. Los punteros n.

se observa que dicho factor queda incrementado en 1 pues la inserción ha sido por la derecha.Izqdo = n n = n1 Una vez realizada la rotación. a la derecha del nodo 75. como ocurre en todas las rotaciones simples.Inserción de las claves 75 y 90 Una vez insertado el nodo con la clave 90. y regresar por el camino de búsqueda para así calcular los nuevos factores de equilibrio. En el nodo con clave 68 queda roto el equilibrio.Drcho = n1^. Izqdo n1^. el árbol queda como sigue: Insertamos la clave 70 98 . los factores de equilibrio de los nodos implicados será 0. Para reestructurar se realiza una rotación DL Los movimientos de los punteros para realizar esta rotación DD: n^.

para insertar el nodo con la clave 70 se sigue el camino : Derecha de 45 izquierda de 75 y se inserta por la derecha al nodo 68. al regresar por el camino de búsqueda. Queda, los factores de equilibrio se incrementan en 1 si se fue por la rama derecha, se decrementa en ¡ si se fue por la rama izquierda. En el nodo 45 cl balanceo se ha roto. La rotación de los nados para reestablecer el equilibrio es DI. Los movimientos de los punteros para realizar esta rotación DI n1^. Izqdo = n2^. Drcho n1^. Drcho = n1 n^. Drcho = n2^. Izqdo n2^. Izqdo = n n = n2 Los factores de equilibrio de los nodos implicados en la rotación dependen del valor antes de la inserción del nodo referenciado por n2 según esta tabla: si n^.fe n1^.fe n2^.fe Con esta rotación el árbol quedaría n2 ^.fe= -1 n2^.fe = 0 0 0 1 0 0 0 n2^. fe =1 -1 0 0

Inserción de la clave 34 99

El camino seguido para insertar el nodo con clave 34 ha seguido el camino de izquierda dc 68, izquierda de 45, derecha de 29. Al regresar por el camino de búsqueda, el factor de equilibrio del nodo 29 se incrementa en 1 por seguir el camino de la rama derecha, el del nodo 45 se decrementa en 1 por seguir la rama izquierda y pasa a ser -2, se ha roto el criterio de equilibrio. La rotación de los nodos para reestablecer el equilibrio es ID. Los movimientos de los punteros para realizar esta rotación ID n1^. Drcho = n2^.Izqdo n2^. Izgdo = nl n^. Izgdo = n2^.Drcho n2^. Drcho = n n = n2 Los factores de equilibrio de los nodos implicados en la rotación dependen del valor antes de la inserción del nodo referenciado por n2, según esta tabla: si n^.fe n1^.fe n2^.fe Con esta rotación el árbol quedaría n2 ^.fe= -1 n2^.fe = 0 1 0 0 0 0 0 n2^. fe =1 0 -1 0

IMPLEMENTACIÓN DE LA INSERCIÓN
100

Un algoritmo que inserte y reequilibre dependerá en forma crítica de la forma en que se almacene la información relativa al equilibrio del árbol. Una solución consiste en mantener la información sobre el equilibrio, de forma completamente implícita, en la estructura misma del árbol. En este caso, sin embargo, el factor de equilibrio debe "averiguarse" cada vez que se encuentre afectado por una inserción, con el consiguiente trabajo resultante. Otra forma (la que vamos a usar) consiste en atribuir a, y almacenar con, cada nodo un factor de equilibrio explícito. La definición de nodo se amplía entonces a:
TYPE Nodo=RECORD Clave:Tclave; Info:Tinfo; Izq,Der:^Nodo; Equi:-1..1 END

El proceso de inserción de un nodo consta fundamentalmente de las tres partes consecutivas siguientes: · Seguir el camino de búsqueda hasta que se comprueba que la clave aún no está en el árbol. · Insertar el nuevo nodo y determinar el factor de equilibrio resultante. · Volver siguiendo el camino de búsqueda y comprobar el factor de equilibrio de cada nodo. Aunque este método realiza algunas comprobaciones que son redundantes, una vez que se establece el equilibrio, éste no necesita comprobarse en los antecesores del nodo en cuestión. En cada paso se debe mandar información sobre si la altura del subárbol (en el cual se ha realizado la inserción) ha aumentado o no. Por lo tanto se extiende la lista de parámetros del procedimiento con el BOOLEAN Crecido, que debe ser un parámetro de tipo variable, ya que se utiliza para transmitir un resultado.

procedure insertar (dato : word; var p : pnodo; var h : boolean); var p1,p2:puntero; begin if p = nil then begin new (p); h:= true; with p^ do begin inf:= dato; izq:= nil; der:= nil; equi:= 0; contador:= 1; end; end else if dato < P^.Inf Then begin Insertar (dato,p^.Izq,h); if h then {la rama izq. ha crecido}

101

equi := -1 else p1^.izq := p. if pl^. 102 . end else begin { rotación DI doble } p2 := p1^.equi :=+1. h := false.equi = +1 then p1^.equi:=0. p^.izq := p.der := p1^.der. h:=false.equi = +1 then begin {rotacion DD simple} p^.izq := p1.equi :=0. p1^.izq := pl^.izq. p2^. +1: begin {reequilibrar} p1 := p^.equi = -1 then p^. p := p1.equi = +1 then p^. end end else if dato > p^. p2^. if p2^.izq := p2^.der. -1: begin {reequilibrar} p1 := p^. end.der.der:=p.equi=0. end.equi := 0. p1^. p^.case p^.equi:=0. if p1^. h). if h then {la rama derecha ha crecido} case p^.izq.der. p^. p2^. p^.der := p2^.equi := 0.equi := 0.izq. if p2^. if p2^. 0: p^.inf then begin insertar (dato.izq.equi of -1: begin p^. p2^. end. p := p2. p1^.equi = -1 then begin { rotacion II simple } p^.equi of +1: begin p^.der := p1.equi:=-1.equi :=0.der.izq. p := p1.equi := -1 else p^.der. 0: p^. end.izq := p2^.der := p. p1^.equi := +1 else p^. p^.der := p2^. p^. h:= false. end else begin { rotación ID doble} p2 := p1^.

end. RAIZ. y después es borra este último. se intercambia los valores de la raíz por los de ese nodo. BORRADO EN AVL Vamos a ver solo las distintas posibilidades que se pueden dar al borrar un nodo en el lado derecho. 103 . p^. EQUILIBRIOS Y DESEQUILIBRIOS CASO 1. p := p2. Se puede haber desequilibrado por la izquierda porque al borrar se ha disminuido en uno la altura del árbol.equi = -1 then p1^. Entonces lo borramos y el campo de equilibrio pasa a -1. el árbol acaba vació. Si solo tiene dos nodos se Si solo está el nodo a borrar.contador := p^. end. end.2: Si no hay ningún subárbol vació se sube el nodo de más a la derecha del subárbol izquierdo.2: Si tiene un 1. Caso 1. Caso 2. A la izquierda es simétrico.equi := +1 else p1^.equi := 0. Al borrar equilibramos y pasa a ser 0 ya que restamos 1. h := false. Caso 2. h:=false. sube el no-borrado hacia arriba.1: Si el campo de equilibrio tiene un cero. los dos subárboles son iguales.1: Si alguno de los subárboles que salen de la raíz está vació. entonces el subárbol derecho tiene una altura más que el izquierdo. end. Caso 1.equi := 0. entonces el otro estará vació o solo tiene un nodo.contador +1. end. CASO 2. end end else begin p^.if p2^. BORRADO EN EL SUBÁRBOL DERECHO. por ser un árbol equilibrado.

Al borrar en el derecho se rompe el equilibrio.3.3.Caso 2.3: Si tiene un -1.2 Caso 2. la altura del subárbol izquierdo es mayor que la del derecho. puede ser: 104 .3.3 Que visto de otra forma. Caso 2. que pasa a -2.1 Caso 2.Hay tres casos.

debe de restaurarse el equilibrio. En la eliminación debe de continuar el proceso puesto que se puede producir más de una rotación en el retroceso realizado por el camino de búsqueda. En el algoritmo de inserción. se regresa por el camino de búsqueda calculando los nuevos factores de equilibrio (Fe) de los nodos visitados. EJEMPLO DE BORRADO DE NODOS Una vez eliminado el nodo siguiendo los criterios establecidos anteriormente. pudiendo llegar hasta la raíz del árbol. Si en alguno de los nodos se viola el criterio de equilibrio. una vez que era efectuada una rotación el proceso terminaba ya que los nodos antecedentes mantenían el mismo factor de equilibrio. 105 . o bien porque al reestructurar haya quedado reducida la altura del subárbol.Tienen altura N-2 y por lo demás se tratan igual. que el bloque 2'2 sea el más pequeño. o que lo sea el 2'1.Mediante rotación izquierda-derecha compuesta queda: Hay otros dos casos. En los procedimientos se utiliza el argumento boolean hh. será activado cuando la altura del subárbol disminuya debido a que se haya eliminado un nodo.

es violado el criterio de equilibrio. resulta que el Fe del nodo con clave 39 pasaría a ser -2 ya que ha decrementado la altura de la rama derecha. Hay que reestructurar el árbol de raíz 39 Rotación ii por que N^. Al tener dos ramas.feß (-1-1) y n1^. 106 . Al volver por el camino de búsqueda para calcular los Fe.En el árbol de la figura va a ser eliminado el nodo con la clave 42: al ser un nodo hoja el borrado es simple. se suprime el nodo. Al volver por el camino de búsqueda para determinar los Fe. el factor de equilibrio del nodo 11 pasaría a ser 2 y por tanto hay reestructurar el árbol de raíz II. toma el nodo más a la derecha de la rama izquierda que es el de clave 11.fe <=0 El árbol resultante es Ahora se elimina el nodo con la clave 21.

Rotación ID por que
N^.fe ß (1+1) y n1^.fe < 0 El árbol resultado es :

En estos dos ejemplos se observa que después de realizar la eliminación de un nodo, y cuando se regresa por el camino de búsqueda, el factor de equilibrio del nodo visitado disminuye en 1 si la eliminación se hizo por su rama derecha y se incrementa en 1 si la eliminación se hizo por su rama izquierda. Consideremos ahora este árbol equilibrado:

Se elimina el nodo de clave 25. Como es un nodo hoja se suprime. La supresión se hace por la rama izquierda, por lo que la altura de la rama derecha correspondiente aumenta en 1, y lo mismo ocurre con el factor de equilibrio. 107

Los factores de equilibrio quedan:

Rotación DD por que
N^.fe = 1+1 N1^.fe >= 1 El árbol resultante es:

Al seguir regresando por el camino de búsqueda, el nodo raíz debe de incrementar su Fe con lo que pasaría a +2, por consiguiente hay que restaurar el árbol, la rotación es derecha-izquierda ya que

N^.fe 1+1 y n1^.fe <0 El nuevo árbol queda así es

108

IMPLEMENTACIÓN DE LA ELIMINACIÓN
En el algoritmo de supresión se introducen dos procedimientos simétricos de equilibrado: Equilibrar1 se invoca cuando la altura de la rama izquierda ha disminuido y Equilibnar2 se invocará cuando la altura de la rama derecha haya disminuido. En el procedimiento Equilibrar1 al disminuirla altura de la rama izquierda, el factor de equilibrio se incrementa en 1. Por lo que de violarse el factor de equilibrio la rotación que se produce es del tipo derecha-derecha, o derecha-izquierda.
procedure Rotaciondd (var N: Ptrae; Nl: ptrae); begin N^.Drcho:=N1^.Izqdo; N1^. Izgdo:=n; if N1^. Fe= 1 then begin N^.Fe:=0; N1^.Fe:=0 end else begin N^.Fe:= 1; Nl^.Fe:= -1; end, N :=N1; end; procedure Rotaciondi (var N: Ptrae; Nl: Ptrae); var N2 : Ptrae; begin N2:=Nl^.lzqdo; N^.Drcho:=N2^.Izqdo; N2^.Izqdo:=N; Nl^.lzqdo:=N2^.Drcho; N2^.Drcho:=Nl; if (N2^.Fe=l ) then N^.Fe=-l else N^. Fe: =0 if (N2^.Fe=-l) then N1^.Fe:=1 else Nl^.Fe:=0; N2^.Fe:=0; N :=N2; end;

109

Fe:=O. end. Fe >= 0 then begin if N1^.Fe :=-1. hh:= false end.Izqdo:= N1^.Fe:=l else N^. if (N2^. N1^. N2^. N1^.Fe=-l) then N^. N1:Ptrae) var n2:ptrae. procedure Equilibrarl(var N:Ptrae: var hh. N^. end.Fe := 0.Fe :=0.Fe of -1: N^. {No disminuye de nuevo la altura} Rotaciondd(N. Fe = 0 then hh. begin N^. 1: begin {Hay que restaurar el equilibrio} Nl:= N^.Fe= -1 then begin N^. N1: Ptrae). N1^.Fe:= O. begin N2= N1^.Fe:= 1.f2=1) then N1^. {Es determinado el tipo de rotación} if N1^.= false.Izqdo:= Nl. end else begin N^. N := N1. N:= N2. O: begin N^.Drcho..drcho. N1) end.Drcho:= N2^Izqdo.Fe:=-1 else N1^.drcho.Drcho:= N. 110 . bolean) {hh: activado cuando ha disminuido en altura la rama izquierda del nodo N} var Nl :Ptrae: begin case N^. end.Drcho:=N.procedure Rotacionii(var N: Ftrae.Izqdo:= N2^. N1) end else Rotaciondi(N.Fe:=0.Drcho.Fe:=O. procedure Rotacionid(Vat N:Ptrae.Fe := 1 end. N1^. if N1^. if (N2^. end. N2^. N2^.

N1) end else Rotacion_id(N.Fe := 0.Drcho<>nil then begin bor(d^. De producirse una violación del criterio de equilibrio.En el procedimiento Equilibnar2 al disminuir la altura de la rama derecha.Drcho. var hh: boolean). end. la rotación será del tipo izquierda-izquierda.hh) end else begin q^. 0: begin N^. o izquierda-derecha. begin 111 . A continuación son escritos los procedimientos de borrar_balanceado y el procedimiento anidado bor. d:=d^. {No disminuye de nuevo la altura} Rotacion_ii(N.info:=d^. La principal diferencia está en que en el momento que una rama disminuye en altura es llamado el procedimiento respectivo de equilibrar.Fe := -1. end. hh:= false end. -1: begin {Hay que restaurar el equilibrio} Nl:= N^.Izqdo. Nl) end. {Es determinado el tipo de rotación} if N1^. if hh then {Ha disminuido rama derecha} Equilibrar2 (d.Fe = 0 then hh.Fe of 1: N^.info. hh:= true end. hh). el factor de equilibrio queda decrementado en 1. bolean) {hh: activado cuando ha disminuido en altura la rama izquierda del nodo N} var Nl :Ptrae: begin case N^.var hh:boolean.= false.Izqdo. procedure bor(var d: ptrae. end. El algoritmo que sigue es el mismo que el de borrado en los árboles de búsqueda sin criterio de equilibrio.X: Tipoinfo) var q: Ptrae. procedure borrar_balanceado(var R:Ptrae. procedure Equilibrar2(var N:Ptrae: var hh. q: =d. begin if d^.Fe <= 0 then begin if N1^.

x) if hh then Equilibrar2(R. end..info then begin borrar_balanceado(R^.(R. hh) end. dispose(q).Izqdo.hh .info then begin borrar_balanceado(R^.Drcho= nil then begin R:= q^.end. if q^.lzqdo. hh:= true{Disminuye la altura} end else if q ^. Hh) end else begin {ha sido encontrado el nodo} q:= R.hh).Izqdo=nil then begin R:=q^. x): if hh then Equilibrarl. if not ArbolVacio( R ) then if x < R^.hh .Izqdo.drcho. if hh then Equilibrar1(R. hh) end else if x>R^. hh:= true end else begin bor(q^.Drcho. 112 .

Los operadores se van poniendo en esta pila hasta encontrar uno con mayor o igual prioridad. se forma un nuevo árbol cuya raíz almacena el operador y los punteros anteriores. Las expresiones matemáticas se pueden escribir según diversos tipos de notaciones. Con estos tres elementos. como estructura de datos auxiliares. 9. Cuando se lee un OPERADOR se retiene en la pila de operadores. El apuntador a este nuevo árbol se coloca ahora en la pila de apuntadores.- 113 . 10. una pila de punteros a los nodos de un árbol y otra pila de operadores para retenerlos temporalmente hasta que llegue el momento de incorporarlos al árbol.ÁRBOLES BINARIOS DE EXPRESIONES Los árboles binarios se utilizan para almacenar expresiones. Los pasos a seguir son lo siguientes. La notación infija es la empleada habitualmente y requiere el uso de paréntesis. Cuando se lee un PARÉNTESIS DERECHO se sacan los OPERADORES que hubiera en la pila de operadores hasta encontrar el paréntesis izquierdo. Nota: Al sacar de la pila de operadores uno de ellos. 6. 8. pero únicamente cuando es necesario modificar la prioridad entre los distintos operadores. 7. Cuando se lee un OPERANDO se crea un árbol de un nodo y se mete el apuntador a el en correspondiente pila. CONSTRUCCIÓN A PARTIR DE UNA EXPRESIÓN EN NOTACIÓN CONVENCIONAL Para construir se utilizaran. Ejemplo: Sea la expresión : Q= 4+5^(2*3)+8 1. Cuando se lee un PARÉNTESIS IZQUIERDO se retiene en la pila de operadores. Por ejemplo. El proceso termina cuando se acaba la entrada y la pila de operadores queda vacía. el arbol de la figura representa la expresión (A+B)*C. en cuyo caso se sacan los que hubiera en la pila de mayor o igual prioridad y se coloca en ella este ultimo operador leido. extraer de la pila de punteros los dos últimos apuntadores.

- 5..El ) saca los operadores de la pila hasta el ( 3..El + saca de la pila todos los operadores con mayor prioridad que el y l continuación se coloca el 4.2.- 114 .

2 Grafo Dirigido 115 . G. B.2 Almacenamiento de un Grafo en Memoria 7. CONTENIDO 7. I. Por ejemplo el arco JK o el arco EG o GE. F. E.1.1 Grafo Un grafo es una estructura de datos compuesta por vértices y arcos.1 Definiciones 7. en la construcción de circuitos eléctricos. cartografía y otras muchas áreas del conocimiento. 7. 7. No se puede hablar del arco AC pero si del AB y del BC. J. H. D. en las estrategias de ventas. gráficamente un grafo se puede ver así: Figura 7.1.3 Aplicaciones Los grafos son estructuras de datos. utilizadas comúnmente en el manejo de redes.1 Grafo El conjunto de vértices es: v = {A. K. 7. L} Un arco une dos vértices adyacentes. Desarrollar algoritmos de procesamiento de una manera óptima.TEMA 7 GRAFOS OBJETIVOS Analizar e implementar estructuras tipo malla para la representación de sistemas.1 DEFINICIONES. C. en el área de economía.

la adyacencia se expresa desde o hacia. CONTROLADOR. También se dice que estos vértices son adjuntos. Como en el siguiente ejemplo: 116 . por ejemplo: Figura 7.2 Grafo con arcos dirigidos El arco SERVIDOR-CONTROLADOR. Por ejemplo para el siguiente grafo: Figura 7. es completamente válido. TERMINAL BRUTA } 7. DISPOSITIVO DE SALIDA.Un grafo dirigido o dígrafo. El conjunto de vértices del dígrafo anterior es: V = { SERVIDOR. ESTACION DOS.3 Adyacencia los vértices A y B son adyacentes.1. ESTACION UNO.3 Adyacencia Se dice que existe adyacencia entre dos vértices si están unidos por un arco. En el caso de dígrafos. En este dígrafo no existe el arco CONTROLADOR-SERVIDOR. es aquel en el que sus arcos tienen una orientación.

se pueden visitar todos los demás. y D es adyacente hacia E.6 Incidencia en un dígrafo. y nunca llega a A. 7. Para simplificar se emplea la siguiente notación: • • AB: A es adyacente hacia B y B es adyacente desde A. si una de sus puntas llega a ese vértice. se dice que A es adyacente hacia B.1. 7. Por ejemplo: 117 .5 Grafos y Digrafos Fuertemente Conectados Un grafo está fuertemente conectado si desde cualquier vértice se puede llegar a todos los demás. Este arco no es incidente en A ya que ese arco sale de A. es incidente en A y B. El arco a es incidente en B. Para el caso de los dígrafos: Figura 7. A es adyacente desde C y a su vez D desde B.5 Incidencia en un grafo El arco a.Figura 7. Por ejemplo: Figura 7. CA: C es adyacente hacia A y A es adyacente desde C. o si desde cualquier vértice.4 Incidencia Los arcos inciden en los vértices.1.4 Adyacencia en un dígrafo Para este caso. Un arco es incidente en un vértice.

Por ello este dígrafo está fuertemente conectado.8 Grafo fuertemente conectado De la misma manera.1.B.7 Camino Simple 118 .10 Dígrafo débilmente conectado. Desde los vértices A. D y E se puede llegar a todos los otros vértices. Por ejemplo: Figura 7. Esta propiedad la cumple el siguiente dígrafo: Figura 7. 7. 7.6 Grafos y Digrafos débilmente conectados Un grafo o dígrafo es débilmente conectado. En este caso desde B no se puede llegar a ningún otro nodo. si por lo menos desde un vértice no podemos llegar a los demás. por ello es un dígrafo débilmente conectado.9 Dígrafo fuertemente conectado.Figura 7.1. un dígrafo está fuertemente si desde cualquier vértice se pueden visitar todos los demás. C.

se puede recorrer la estructura. se puede recorrer todo el grafo. se pueden recorrer todos los vértices sin repetir ninguno. B y H son visitados dos veces.1. consiste exactamente de n arcos.12 Grafo de Euler El recorrido desde el vértice A puede ser : ACDEFGBEHDAHBA. 7. Para los dígrafos pueden existir para cada vértice dos tipos de grado: • GRADO DE ENTRADA 119 . Como se puede observar los nodos D.Se presenta cuando a partir de cualquier vértice. 7. En el grafo anterior se encuentra el siguiente circuito Hamiltoniano : A C D E F G B H A. Un grafo Hamiltoniano que recorre n vértices. sin repetir ningún vértice ni ningún arco.9 Circuito Hamiltoniano Si partiendo de cualquier vértice . el nodo A es visitado 3 veces pero todos los arcos son recorridos una sola vez. Ejemplo: Figura 7. y finalmente se llega al vértice origen.1. Es decir se pueden visitar los vértices o nodos cuantas veces sea necesario.10 Grado de un vertice Es el número de arcos que inciden en un vértice. 7.11 Camino simple Partiendo del vértice C.1. Por ejemplo: Figura 7.8 Grafo de Euler Es un camino cerrado que recorre todos los arcos del grafo. pero los arcos solo se pueden recorrer una vez. E. sin repetir vértices ni arcos.

los grados de entrada y salida para cada vértice son: VERTICE A B C D E GRADOENTRADA 2 2 1 0 2 GRADOSALIDA 0 0 3 3 1 7.14 Grafo Regular 120 . Para la figura anterior.13 Grados de entrada y de salida. se determinan por el número de arcos que inciden en el vértice y los grados de salida se determinan por el número de arcos que parten del vértice. Figura 7.11 Grafos Regulares Un grafo se dice que es regular . si todos los vértices tienen el mismo grado.• GRADO DE SALIDA Los grados de entrada de un vértice en un dígrafo. Por ejemplo: Figura 7.1.

7. 4.15 Grafo con arcos cíclicos (AA y BB) En la anterior figura se tienen dos arcos cíclicos.17 Grafos completos de 2. Ejemplo: Figura 7. 5 y 6 vértices. Por ejemplo los siguientes grafos son completos: Figura 7. 121 . 3.1. 7. uno en A y el otro en B.14 Grafos Completos Un grafo es completo si cada vértice tiene un grado igual a n-1.13 Grafos Simples Un grafo es simple.12 Arco Cíclico Un arco es cíclico si parte de un vértice y llega al mismo vértice.1. 7.1. si no tiene arcos cíclicos y existe un solo arco entre dos vértices. donde n es el número de vértices que componen el grafo.

Existen varias formas de almacenar estas estructuras en memoria. etc. 7. otra lista tendrá almacenados todos los adjuntos al vértice I. comenzando por los vértices de más arriba y los de más a la izquierda como orden de prioridad.7.18 122 . • • • COMO LISTA DE ADYACENCIA COMO MATRIZ DE ADYACENCIA COMO MATRIZ DE INCIDENCIA Figura 7.19 Lista de adyacencia del grafo de la figura 7. debemos trabajar con un arreglo de listas.2. Esta es la lista de adyacencia para el grafo anterior (figura 7. Cada una de estas listas almacena los adjuntos a un vértice dado. Por ejemplo una lista tendrá almacenados todos los adjuntos al vértice E.19): Figura 7.18 Grafo a almacenar en memoria.2 ALMACENAMIENTO DE UN GRAFO EN MEMORIA.1 Lista De Adyacencia Para almacenar un grafo en una lista de adyacencia.

INICIAR_GRAFO ( nv) Inicio i=1 Mientras ( i <= nv) Ind[i]= 0 Sig[i]=A i=i + 1 Fin-Mientras Fin El algoritmo Leer_grafo se encarga de leer el índice de cada vértice y sus correspondientes adjuntos (que forman una lista) para así formar el grafo. i.2. Aquí la estructura nodo está conformada por dos campos. donde nv es el número de vértices del grafo. ad ) j=j + 1 Fin-Mientras i =i + 1 Fin-Mientras Fin El algoritmo ins_grafo se encarga de crear el nodo en memoria que conformará la lista de adyacencia para el vértice i. ad) sig [i] =nuevo q =A p =*grafo [i]. LEER_GRAFO(nv) Inicio INICIAR_GRAFO(nv) i =1 Mientras ( i <= nv) Ejecute nad =NumAdjuntos[i] j =1 Mientras( j <= nad) Ejecute ad =Lea(adjunto) ins _ grafo (grafo. como también colocar el valor NULO para el campo siguiente. ad) Inicio ASIGNA_NODO (nuevo.1 Almacenamiento en memoria.7. dentro del arreglo grafo. La rutina Iniciar_grafo se encarga de colocar un cero en el campo de indice de cada elemento de la estructura grafo.1. INS_GRAFO (grafo.sig Mientras (p=A) Haga 123 . Grafo es un arreglo de estructuras de tipo nodo. i. El primero es el campo indice que es el identificador de un nodo. El segundo es el campo siguiente que es un apuntador a otra estructura de tipo nodo.

. la matriz de adyacencia es: 124 .sig Fin-Mientras Si (q = A) *grafo [i].18).sig = nuevo Fin-Si Fin El algoritmo Recorrer_grafo ejecuta la operación de Visita a cada nodo adjunto de todos los vértices de un grafo. Para el mismo grafo (figura 7.q =p p = *p. j ]. y un 1 en caso contrario.2 Matriz De Adyacencia En este caso a cada elemento M[ i . nv) Inicio i =1 Mientras (i<= nv) p =grafo [i] Visite_Vertice (p) q =*grafo [i]. Recorrer_grafo (grafo.sig Fin-Mientras i=i +1 Fin-Mientras Fin 7. se le asigna un 0 si el vértice i no es adjunto al vértice j.sig = nuevo Sino *q.sig Mientras (q =A) Visite_Vertice (q) q =*q.2.

2. En la matriz de incidencia cada fila representa a cada uno de los nodos del grafo.j ]. Leer_grafo (grafo) Inicio nv =Leer_Numero_de_Vertices(grafo) lniciar_grafo(grafo.j] tiene un valor de 0 si el nodo ( vértice ) j es adjunto al nodo i. j] =1 j =Leer_adjunto(grafo[j]) Fin-Mientras i =i + 1 Fin-Mientras Fin 7. cuando el nodo i es final. en la casilla M [i .2.1 Almacenamiento en memoria. 7. En la siguiente figura aparece un dígrafo y su correspondiente matriz de incidencia: Figura 7.nv) i =1 Mientras (i <= nv) j =Leer_adjunto(grafo[i]) Mientras (j ) matriz [i. Cada elemento matriz[i.20 Matriz de adyacencia para el grafo de la figura 7. El orden de la matriz es nv * nv. y un -1.18 Como se puede observar la matriz de adyacencia es simétrica. aparecerá un 1 cuando el nodo de la fila i es inicial.21 Matriz de incidencia 125 . Se tiene una matriz bidimensional denominada grafo.3 Matriz De Incidencia Esta estructura es aplicable para los dígrafos.Figura 7. y las columnas los posibles arcos de dicho grafo.2. donde nv es el número de vértices en el grafo.

j] = 1 j =Leer_nodo_de_salida(grafo[j]) Fin-Mientras j =Leer nodo de entrada(grafo[i]) Mientras ( j <= nv ) Haga grafo[i.3. Leer_grafo (grafo) Inicio nv =Lea numero de vértices(grafo) Iniciar_grafo(grafo.nv) i =1 Mientras (i <= nv) Haga j =Leer_nodo_de_salida(grafo[i]) Mientras (j ) Haga grafo [i. pero ahora el elemento grafo[i.1 Almacenamiento en memoria.7. En este campo se han desarrollado técnicas como son Cálculo del Flujo Máximo y Cálculo del Costo Mínimo. en ambos casos se trata de optimización en redes. Tendrá un valor de cero si los dos nodos. Para el Flujo máximo existen 3 algoritmos conocidos: • • • METODO DE CORTES METODO DE GRAFICO AUXILIAR METODO DE FORD . y será igual a -1 si es el nodo final. el nodo i y el nodo j no están conectados directamente.2. j] será igual a 1 si el nodo i es inicial. Para este caso también se maneja una matriz bidimensional denominada grafo. j] = -1 j =Leer_nodo_de_entrada(grafo[j]) Fin-Mientras i =i + 1 Fin-Mientras Fin 7.FULKERSON Para el Costo Mínimo existen 2 algoritmos conocidos: • • METODO DE GRAFICOS DIRIGIDOS METODO DE DIJKSTRA 126 .3 APLICACIONES. Dentro de las aplicaciones clásicas y fundamentales se encuentra el estudio de redes.

Dw + dwm] para todo j M Sí el último término es el mínimo. y sus rutas desde el origen habran sido determinadas. Actualizar las rutas con el costo mínimo: Dn = min[Dn. Dn = dsn para n >s // Los costos de las rutas iniciales hacia los nodos vecinos son simplemente los costos del enlace. 2. dij= Costo del enlace desde el nodo i al nodo j. El algoritmo tiene tres pasos. Cada iteración de los pasos 2 y 3 coloca un nuevo nodo en M y define la ruta con costo mínimo desde s hasta ese nodo. 3. Se encarga de determinar las rutas con el menor costo.3. desde un nodo origen hacia todos los otros nodos de un grafo. En el estado K + 1. Es decir tales pasos son repetidos hasta que las rutas finales han sido asignadas a todos los nodos de la red: 1. los pasos 2 y 3 son repetidos hasta que M = N. En el estado K. El algoritmo puede ser formalmente descrito como sigue: N = número de nodos en el grafo( red ). la ruta de s a n es ahora la uta desde s a w concatenada con el enlace que va de w a n. dij>= 0 si los dos nodos están directamente conectados. un nodo que no está en M y que tiene la ruta más corta desde el nodo origen es incluido en M. desde el nodo s al nodo n.7. Encontrar el nodo vecino que no está en M y que tiene el enlace con menor costo desde el nodo s. 127 . Esa ruta solo pasa a través de nodos que están en M. El nodo encontrado se incorpora a M. El algoritmo va pasando por diferentes estados. Al final todos los nodos estaran en M. Dn= costo de la ruta con el menor costo. dii = 0 y dij = si los dos nodos no están directamente conectados. s = nodo fuente M = grupo de nodos que han sido incorporados por el algoritmo. Encontrar w M tal que Dw = min { Dj } para j M Insertar w a M. es el más implementado en ciertos dispositivos de Hardware. las rutas más cortas a los K nodos más cercanos han sido determinadas y estos nodos están dentro de un grupo denominado M.1 Algoritmo De Dijkstra Este algoritmo usado para determinar el costo mínimo. Inicializar: M = {s} // Al grupo de nodos M solo se incorpora el nodo origen.

22.Figura 7. La siguiente figura muestra el resultado de cada iteración: 128 .22 Dígrafo La siguiente tabla muestra el resultado de aplicar el algoritmo sobre el grafo de la figura 7. usando s =1 como nodo de origen.

Figura 7.23 Algoritmo de Dijkstra 129 .

Sign up to vote on this title
UsefulNot useful