P. 1
TEMAS SIS2204(2)

TEMAS SIS2204(2)

|Views: 2.196|Likes:

More info:

Published by: Marcelo Quiroz Alcocer on Jan 12, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less

04/24/2013

pdf

text

original

Sections

  • INTRODUCCION
  • 1.1 ESTRUCTURA DE DATOS
  • 1.2 OPERACIONES SOBRE ESTRUCTURAS DE DATOS
  • PILAS Y COLAS
  • 2.1 PILAS
  • 2.2 COLAS
  • 2.3 COLAS CIRCULARES
  • ELIMINAR EL NODO DELANTERO DE LA COLA
  • 2.4 APLICACIONES DE LISTAS RESTRINGIDAS
  • ARCHIVOS, REGISTROS Y CAMPOS
  • 3.1 ARCHIVOS
  • 3.2 TIPOS DE ARCHIVOS
  • 3.3 REGISTROS Y CAMPOS
  • TRATAMIENTO DE ARCHIVOS
  • 4.1 INTRODUCCION
  • 4.2 OPERACIONES SOBRE ARCHIVOS
  • ADICION DE DATOS
  • ELIMINAR DATOS
  • CONSULTAS DE DATOS
  • BUSQUEDA DE DATOS
  • 4.3 PARTICION DE ARCHIVOS
  • PARTICION POR CONTENIDO
  • PARTICION POR UNA SECUENCIA " P " DADA
  • PARTICIÓN DE ARCHIVOS POR TRAMOS ORDENADOS
  • 4.4 MEZCLAS DE ARCHIVOS
  • MEZCLA POR CONTENIDO TOTAL
  • MEZCLA POR SECUENCIAS " P "
  • MEZCLA POR TRAMOS ORDENADAS
  • 4.5 ORDENACIÓN EXTERNA
  • ORDENACIÓN POR MEZCLA DIRECTA
  • ORDENACIÓN POR VON NEWMAN
  • ORDENACIÓN POR MEZCLA EQUILIBRADA
  • ORDENACIÓN POR DIGITOS
  • LISTAS ENCADENADAS
  • 5.1 LISTAS ENCADENADAS
  • TIPOS DE LISTAS
  • 5.2 LISTAS SIMPLEMENTE ENLAZADAS
  • OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS
  • RECORRIDO
  • BUSQUEDA
  • INSERCION DE DATOS
  • 5.3 LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES
  • OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES
  • 5.4 LISTAS DOBLEMENTE ENLAZADAS
  • OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS
  • 5.5 LISTAS CIRCULARES DOBLEMENTE ENLAZADAS
  • OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS CIRCULARES
  • ÁRBOLES
  • 6.1 DEFINICION
  • REPRESENTACIÓN
  • Estructura dinámica pura
  • MATRIZ DE ADYACENCIA
  • LISTA DE ADYACENCIA
  • ESTRUCTURA DINÁMICA PURA
  • 6.2 CONCEPTOS ASOCIADOS
  • 6.3 ARBOL BINARIO
  • DEFINICION
  • OPERACIONES BASICAS
  • INSERCIÓN DE DATOS
  • ELIMINAR UN DATO
  • BÚSQUEDA DE DATOS
  • 6.4 ÁRBOLES BINARIOS DE EXPRESIONES
  • CONSTRUCCIÓN A PARTIR DE UNA EXPRESIÓN EN NOTACIÓN CONVENCIONAL
  • 6.5 ÁRBOLES EQUILIBRADOS O AVL
  • DEFINICIÓN
  • INSERCIÓN EN AVL
  • IMPLEMENTACIÓN DE LA INSERCIÓN
  • BORRADO EN AVL
  • IMPLEMENTACIÓN DE LA ELIMINACIÓN
  • ÁRBOLES BINARIOS DE EXPRESIONES
  • GRAFOS
  • 7.1 DEFINICIONES
  • 7.2 ALMACENAMIENTO DE UN GRAFO EN MEMORIA
  • 7.3 APLICACIONES

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

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

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

<=. Entero y Booleano.2 Operaciones Sobre Estructuras de Datos 1.Elección de la implementación Tipos de datos básicos TDA Entero: tiene como tipo el conjunto de números enteros. Una estructura de datos es la implementación física de un tipo de datos abstracto.Análisis de datos y operaciones 2.1 Estructura de Datos 1. >=.1 ESTRUCTURA DE DATOS. y como operaciones la suma. Se denominan tipos de datos ordinales a aquellos en los que cada valor tiene un predecesor (excepto el primero). NOT) TDA Carácter: tiene como tipo el conjunto de caracteres definido por un alfabeto dado y como operaciones todos los operadores relacionales (<. Entero. CONTENIDO 1. >. Los lenguajes de alto nivel suelen presentar tres funciones adicionales asociadas a los tipos de datos ordinales: posición (Ord). =. 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. resta. False y como operaciones las definidas en el álgebra de Boole (AND.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. resta multiplicación y división TDA Booleano: tiene como tipo el conjunto de valores booleanos True.. y un único sucesor (excepto el último): Carácter.Elección del Tipo de Datos Abstracto 3. 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.. el diseño deberá realizarse siguiendo tres pasos fundamentales: 1. OR.. <>) 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. predecesor (Pred) y sucesor (Suc) de un elemento. Real y Booleano. 6 .

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. Los TDA básicos son los utilizados con mayor frecuencia. Ahora bien. Por ejemplo. y que indican la posición de la componente dentro de la colección. Los TDA compuestos básicos: TDA Conjunto: colección de elementos tratados con las operaciones unión. Estructura Es un conjunto de elementos entrelazados regidos por una serie de leyes. Una de ellas es mediante arreglos. Estructura de Datos Una estructura de datos es una colección organizada de elementos de datos bajo las leyes de la informática. pero además cada problema puede requerir la definición de varios TDA propios. 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. 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. Así. que serán de tipo ordinal. ordenados según su posición en ella. las estructuras que nos presenta el mundo real están regidas por las leyes físicas. intersección y diferencia de conjuntos. En general. o ladrillos. la lista. aumentará al insertar y se reducirá al suprimir.Otro tipo de datos son los denominados compuestos. Las operaciones asociadas a los tipos compuestos o estructurados son las de almacenar y recuperar sus componentes individuales. que es dinámica independientemente de su implementación. con los cuales se forman las estructuras de datos que incluyen los diferentes lenguajes: 7 . 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. La lista es una estructura dinámica ya que su longitud dependerá del número de elementos que tenga. Estos elementos. la lista puede implementarse de formas muy diferentes. Los registros pueden tener como campos tipos de datos simples o arreglos o incluso otros registros. 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. 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. El TDA Conjunto no es estructurado ya que no está organizado mediante el modo de acceso a sus componentes individuales. son los tipos de datos. mientras que el Arreglo y el Registro si lo son. se realiza mediante una implementación estática. dado que son divisibles en componentes que pueden ser accedidas individualmente.

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

2 OPERACIONES SOBRE ESTRUCTURAS DE DATOS. Función Constructora Son los algoritmos y mecanismos que permiten construir una estructura. char apellido_1[10]. }. int modelo[2]. Función Destructora Son los algoritmos y mecanismos que desasignan memoria y liberan recursos del sistema. 9 . struct PROPIETARIO { char direccion[50]. char apellido_2[10]. Estas funciones son los mecanismos o procesos. struct NOMBRE { char nombre[10]. Asigna memoria en forma dinámica o espacios en medios magnéticos. }. 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.}. se determina la posición del elemento de dato en la estructura. y una vez establecidas se definen como funciones. struct NOMBRE nomb. struct CARACTERISTICAS { char marca[20]. Función Inversa Las funciones de acceso proveen un nombre o valor. char color[10]. en que dado un valor o un nombre. Función de Eliminación Permite la exclusión de un elemento de una estructura. Función de Inserción Permite la inclusión de un elemento en una estructura. Son varias las operaciones que se efectúan sobre las estructuras de datos. }. 1.

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

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

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. en caso contrario DATO queda indefinido.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. 12 . ACCE_PILA(DATO.I) Inicio I = Verdadero Si (TOPE>=M) Entonces I = Falso Sino TOPE = TOPE + 1 PILA[TOPE] = DATO Fin-Si Fin Figura 2. 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. o rechazar la inserción e informar al sistema operacional para una terminación anormal de la tarea. hacer la inserción. en primer lugar. o no. Precondición: Pila válida. Precondición: TOPE < M Poscondición: I verdadero indica que se hizo la inserción de DATO y el índice TOPE apunta a DATO. tratar de manejar dicha condición para superarla.Acceder al Elemento Tope de la Pila: Con esta operación se lee el último elemento de la pila y se lleva a DATO. INSER_PILA(DATO. Poscondición: En DATO queda una copia del elemento que apunta el índice TOPE si hay elementos en la pila. La política común es.

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

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

y en Dato queda copia del elemento indicado por el tope de la pila IP.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.IP.I) Inicio I = V 2PILASVAC(IP. Poscondición: Inserción de DATO en una de las dos pilas o la imposibilidad de hacerlo. I=FALSO. ACC2PILAS(DATO. I es falso.1 PILA[TOPE2] = DATO Fin-Si Sino I = V Fin-Si Fin 15 . no hay saturación mientras ( TOPE1+1) < TOPE2.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. Poscondición: Si hay datos en la pila IP. ALGORITMO INSER2PILAS(DATO. Precondición: IP es 1 o 2.IP. sino I es verdadero.I) Incio I = F Si ((TOPE1+1) < TOPE2) Entonces Si (IP=1) Entonces TOPE1 = TOPE1 + 1 PILA[TOPE1] = DATO Sino TOPE2 = TOPE2 .

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

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

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

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

cuando U = M. INSER-COL-CIR(DATO. para enviarlo a 0. Poscondición: D apunta al nuevo nodo. Los algoritmos de iniciación. prueba.Figura 2. Figura 2. se debe considerar.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 . Precondición:Que haya cola. Los de inserción y eliminación varía por la condición inicial: U=0 U=D. sino. hay saturación.6 Si se presenta una inserción. si hay espacio. acceso y destrucción de la cola son similares a los del caso anterior. También se debe tener en cuenta la nueva condición de saturación. I =falso.5 Después de que U = M se U = 1. 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 elementos. sino. ALGORITMO ELIM-COLA-CIR(DATO.7 (a) Condición inicial crítica (b) Condición final una vez se ha eliminado el nodo delantero Precondición: Que haya 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 .Figura 2. Poscondición: U apunta al último elemento de la cola. queda la cola en condición de cola vacía.

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

No se espera la entrada de constantes ni de referencia a funciones 4.2. Poscondición: Comience CREA_PILA D = 0 TOPE = 0 INSER-PILA( . Los operandos consisten de una sola letra 3.1 Fin-Mientras TOPE = TOPE .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 . No deben aparecer funciones unarias.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 . 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.

G G G PILA = =( 24 . Conversión a Posfija.. que hace que se ejecute esa operación entre los dos nodos operandos que se tengan en los nodos superiores de la pila.. puede ser una letra o un operador (<= .N. J=1. X .. -. 1 2 3 COLA . Cada X(J).. *. +. El resultado se guarda en el tope de la pila. 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. ). Los operandos se van guardando en una pila hasta cuando se encuentra un operador. /.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.

C=5. D=64 . E=2. Evaluación de la notación Posfija. donde A=4.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. 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 . B=1.

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

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

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

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

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

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

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

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

Inicio Fin Leer Clave Abrir (F. Ejemplo: Realizar la búsqueda del registro..Lectura) Leer (F..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 .. Ejemplo: Mientras no eof (F) y reg <= clave hacer Leer (F... donde Dato='MARIA'. 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.reg) Fin mientras Si reg=clave Entonces Mostrar " Existe el dato" Si no Mostrar "No existe el dato" Fin si Cerrar (F) 34 . FIN SI Fin mientras BUSQUEDA DE DATOS Existen dos formas de búsqueda de datos: 1.reg) Mientras no eof (F) y reg <= clave hacer Leer (F.

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. Partición por secuencias ordenadas. Ejemplo: Realizar la búsqueda del registro. Partición por el contenido 2. 35 .reg) Fin mientras Si reg=clave Entonces Mostrar " Existe el dato" Si no Mostrar "No existe el dato" Fin si Cerrar (F) Fin 4. ALGORITMO Inicio Leer Dato Abrir (F.reg) Mientras no eof (F) y reg <> clave hacer Leer (F. 3. Partición por una secuencia ' P ' dada. donde Dato='MARIA'.Lectura) Leer (F.

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. para determinar que registros de F1 se destinan al archivo F2. utilizando la secuencia de partición (P = 2). luego los siguientes 'P' registros de Arch a Arch2.PARTICION POR CONTENIDO Se debe establecer un criterio de partición. 36 . 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) Si Reg = Clave Entonces Grabar (Carrera. Donde el archivo F1 es solo lectura y el archivo F2 para escritura. ALGORITMO Inicio Leer Clave Abrir FNI (Lectura) Abrir Carrera (Escritura) Mientras no eof (FNI) Hacer Leer (FNI. Ejemplo: Crear un archivo llamado CARRERA seleccionando Clave = 'SIS' del Archivo FNI. Se copia 'P' registros de Arch a Arch1.

B ) 37 . Arch1. ALGORITMO Inicio Abrir A (Lectura) Abrir B (Lectura) Abrir C (Escritura) Mientras no eof (C) Hacer Copiar_Tramo (C. A ) Si no eof (C) Entonces Copiar_Tramo (C. 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. Reg) Grabar (y. y : Archivo.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) Si no eof (Arch) Entonces Copiar_Secuencia(Arch. 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. P) Fin si Fin Mientras Cerrar (Arch) Cerrar (Arch1) Cerrar (Arch2) Fin Copiar_Secuencia (Var x. Arch2.

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

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

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

MEZCLA POR TRAMOS ORDENADAS Se realiza la mezcla los archivos A y B en el archivo C. PosB) Si Reg1 < Reg2 Entonces Copiar_Dato (A. 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. 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. C) Si Fin_Tramo Entonces Copiar_Tramo (B. C) Fin Mientras Cerrar (A) Cerrar (B) Cerrar (C) Fin Mezclar_Tramo Inicio Repetir PosA = FilePos (A) Leer (A. utilizando las secuencias ordenadas. C) Fin Si Hacer 41 . tomando tramos ordenados. RegA) Seek (A. Ejemplo: Realizar la mezcla A y B en un tercer archivo C.

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

3. 2. Seek (C.. 0) Mezclar 43 . Donde: n = 0. y la otra mitad en el archivo B. ALGORITMO Inicio Sec = 1 Abrir C (Lectura) Repetir Abrir B (Escritura) Abrir A (Escritura) Seek (C.. 0).C Archivo a ordenar A. Partir el archivo C en la mitad.B Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1. 0).2. copiar la primera mitad del archivo C en el archivo A. Mezclar los archivos auxiliares A y B por secuencias de 2n.1. 0) Particionar Seek (A. 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.3. Seek (B.

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). Partir el archivo C en secuencias ordenadas.B Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1. C. 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. C. y luego en el archivo B. copiar intercaladamente las secuencias ordenadas del archivo C. Ejemplo: Ordenar los siguientes datos. 3. Mezclar los archivos auxiliares A y B por secuencias ordenadas. Sec-SecB). hace el uso de los siguientes archivos: C Archivo a ordenar A. 2. Reg SecA =SecA + 1 Si SecA = Sec Entonces Copiar_SecP (B.Hasta Fin Si RegA < RegB Entonces Leer A. 47 . Reg Grabar C. Repetir los pasos 1 y 2 hasta que la mezcla de secuencias sea igual a uno (n_tramos=1). primeramente en el archivo A. SecB = Sec Fin si Si no SecB = SecB + 1 Si SecB = Sec Entonces Copiar_SecP (A.

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

C) Num_Tramos = Num_Tramos + 1 Fin Mientras Fin Mezclar_Tramo Inicio Repetir PosA = File Pos (A).etc. A1. Seek (B. 49 . 3. Seek (A.Mientras no ef (A) Hacer Copiar_Tramo (A.A9 en orden. decena. Se debe empezar inspeccionando por la posicion de la unidad. PosB) Si RegA < RegB Entonces Copiar_Dato (A. Leer (B. centena. A9 Archivos auxiliares Se deben seguir los siguientes pasos para ordenar: 1. 2. 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. C) Num_Tramos = Num_Tramos + 1 Fin Mientras Mientras no ef (B) Hacer Copiar_Tramo (B. centenas. Mezclar los 10 archivos auxiliares A0. ejemplo si el digito inspeccionado es 1 este dato debe copiarse al archivo A1... C) Fin Si Si no Copiar_Dato (B. C) Si Fin_Tramo Entonces Copiar_Tramo (B. RegA). C) Si Fin_Tramo Entonces Copiar_Tramo (A.. Partir el archivo C de acuerdo al digito inspeccionado. RegB). Leer (A. hace el uso de los siguientes archivos: C Archivo a ordenar A0. es decir unidades.. etc. Repetir los pasos 1 y 2 hasta que se haya inspeccionado todos los dígitos. PosA) PosB = File Pos (B).. empezando del archivo A0 y finalizando en el archivo A10. decenas..

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

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

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

Un campo enlace (o puntero) que indica la posición del siguiente elemento de la lista. 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. NODO 53 .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.

con la cual se visita toda la lista. es necesario el uso de un puntero auxiliar ACT.sig 54 . OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS Como cualquier estructura de datos. struct Nodo *sig. info : Integer. empezando por la RAIZ y finalizando cuando el puntero ACT apunta a NIL. ALGORITMO: Recorrido(Dato:Integer) Inicio Actual = Raíz Mientras(Actual <> Nil) hacer Actual =Actual^. 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.Existe una marca para fin de lista. Declaración de un nodo usando el lenguaje C: struct Nodo { int info. también representada por una barra inclinada o el signo eléctrico de tierra. Sig :pnodo. que es la constante NIL. Declaración de un nodo usando el lenguaje Pascal: Type pnodo = ^nodo nodo = record End. }.

INSERCION DE DATOS Existen distintas formas de adición de nodos a una lista simple. con la cual se busca empezando por la RAIZ y finalizando cuando el puntero ACT apunta al elemento buscado o a NIL. 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 .Mostar Actual^.inf = Dato entonces Mostar "El Dato Esta en la Lista" Sino Mostrar "No Existe el Dato" Fin si Fin. de acuerdo a los propósitos de uso de estos.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^.sig Fin Mientras Si Actual^. BUSQUEDA Para realizar la búsqueda en una lista simple.inf<>Dato) hacer Actual =Actual^.

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

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

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

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

sig Mostarc Actual^. empezando por la RAIZ y finalizando cuando el puntero ACT apunta a NIL.inf 60 . OPERACIONES EN LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES Como cualquier estructura de datos. de tal modo que solo se usaremos las listas enlazadas con nodo cabecera.• Listas simples circulares sin nodo cabecera • Listas simples circulares con nodo cabecera El manejo de la primera es complejo. es necesario el uso de un puntero auxiliar ACT. con la cual se visita toda la lista. 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. debido a su fácil manejo. ALGORITMO: Recorrido(Dato:Integer) Inicio Actual = Raíz^.sig Mientras(Actual <> Raiz) hacer Actual =Actual^.

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

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

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.Anterior = Actual Actual = Actual^. ELIMINAR DATOS Para eliminar un dato de una lista simple circular.sig Fin Mientras Nuevo^.sig = Nuevo Fin si Fin. • • • Dispose(ant) Dispose(act) Raiz = nil (1) ELIMINAR UN ELEMENTO DISTINTO DEL ULTIMO Dada la siguiente lista: 63 . es necesario buscarlo en la lista primeramente. el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento. si el dato se encuentra en la lista.sig = Actual Anterior^. es necesario liberar la memoria de los nodos que apuntan a ANT y ACT. La búsqueda se realiza con dos punteros auxiliares ANT y ACT.

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

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

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.inf Actual = Actual^.    Inserción Eliminación Recorrido Búsqueda RECORRIDO En una lista doble circular es posible realizar dos tipos de recorridos.inf 66 .   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. ALGORITMO: Inicio Actual = Fin} Mientras Actual <> Nil Hacer Mostrar Actual^. ALGORITMO: Inicio Actual = Inicio Mientras Actual <> NIL hacer Mostrar Actual^. esto debido a que en estas listas existen enlaces en ambas direcciones.sig Fin Mientras Fin.

inf= 5 Inicio = nuevo (1) Fin = nuevo (2) Nuevo^.ant= nil (3) Nuevo^.Actual = Actual^.ant Fin Mientras Fin. INSERTAR CUANDO LISTA ESTA VACIA: Dada la siguiente lista: Insertar(5) • • • • • • New(Nuevo) Nuevo^. 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. de acuerdo a los propósitos de uso de estos.sig= nil (4) INSERTAR AL PRINCIPIO Dada la siguiente lista: Insertar(3) 67 . 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.

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

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

La búsqueda se realiza con dos punteros auxiliares ANT y ACT. Inicio^.sig 2. 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.ant = Nil Dispose(act) ELIMINACIÓN AL MEDIO: Dada la siguiente lista: Eliminar(8) 70 . si el dato se encuentra en la lista. Inicio = Inicio^. el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento.

sig^.sig = nil 2.Ant = Anterior Si no Final = Anterior 71 .sig Inicio^.sig Fin Mientras Si Actual^. Ant^.sig <> Nil Entonces Inicio = Inicio^.sig <> Nil entonces Actual^.sig = Act^.sig = Act^.ant = Ant Dispose(act) ELIMINACIÓN AL FINAL: Dada la siguiente lista: Eliminar (9) 1. Final = Ant Dispose(act) ALGORITMO: Eliminar (Valor: Entero) Inicio Anterior = Inicio Actual = Inicio Mientras (Actual <> Nil) y (Actual^.inf <> Valor) hacer Anterior = Actual Actual =Actual^.sig 2. Ant^. Act^.sig^.1.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^.

Fin si Anterior^. Una lista doble circular es aquella en la cual el puntero siguiente del último elemento apunta hacia el primer elemento.sig = Actual^. de tal modo que solo se usaremos las listas enlazadas con nodo cabecera. 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. Esta lista presenta la gran ventaja de que cada nodo en una lista doble circular es accesible desde cualquier nodo. 72 . Tiene el inconveniente de que requiere un diseño cuidadoso para evitar caer en un bucle infinito.sig Fin Fin si Fin. si 5.5 LISTAS CIRCULARES DOBLEMENTE ENLAZADAS. En estas listas no existe ni primero ni último elemento. aunque se debe elegir obligatoriamente un puntero para referenciar la lista. debido a su fácil manejo.

ALGORITMO: Inicio Actual = Raiz^. esto debido a que en estas listas existen enlaces en ambas direcciones.OPERACIONES EN LISTAS DOBLEMENTE ENLAZADAS CIRCULARES.inf Actual = Actual^.   Recorrido en forma ascendente Recorrido en forma descendente RECORRIDO EN FORMA ASCENDENTE Este recorrido se inicia cuando el puntero apunta a Raiz^.ant y se recorre de nodo a nodo con el puntero ANT hasta llegar al nodo Raiz. 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.sig y se recorre de nodo a nodo con el puntero SIG hasta llegar al nodo Raiz. 73 .sig Fin Mientras Fin.sig Mientras Actual <> Raiz hacer Mostrar Actual^. RECORRIDO EN FORMA DECENDENTE Este recorrido se inicia cuando el puntero apunta a Raiz^.

ant Fin Mientras Fin.ant Mientras Actual <> Raiz Hacer Mostrar Actual^.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^.inf Actual = Actual^.ALGORITMO: Inicio Actual = Raiz^.ant = Nuevo (4) Nuevo^.sig = Cab (3) Cab^.inf=9 Raiz = Cab (1) Cab^.

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

ELIMINAR DATOS Para eliminar un dato de una lista doble circular. el puntero ACT apunta a ella y el puntero ANT apunta al anterior elemento. si el dato se encuentra en la lista. La búsqueda se realiza con dos punteros auxiliares ANT y ACT. es necesario buscarlo en la lista primeramente. 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 .

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

CONTENIDO 6. 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. igual contenido en ellos y.1 Introducción 6.2 Conceptos Asociados 6. Un árbol es una estructura dinámica y homogénea. a las que llamaremos subárboles. por tanto está compuesto de elementos del mismo tipo base T. ninguno o varios elementos del mismo tipo. y entre sí son disjuntos. 78 . Dos árboles son iguales cuando tengan igual número de nodos.TEMA 6 ÁRBOLES OBJETIVOS Desarrollar aplicaciones con estructuras ramificadas que optimizan las operaciones básicas. Encontrar nuevas formas de organización de datos en forma ramificada de acuerdo a las características de la aplicación. Lista de adyacencia. además.4 Árboles Equilibrados o AVL 6.3 Árbol Binario de Búsqueda 6. Un árbol puede ser representado. 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.1 DEFINICION. Un árbol es una lista en la que cada uno de sus elementos apunta a uno. en tres formas diferentes:   Matriz de adyacencia.

Enlace1.n. siendo n el número de nodos. Estructura dinámica pura. Ejemplo: ESTRUCTURA DINÁMICA PURA En ella.. Vamos a tener un tipo como: PNodo=^Nodo. Esto es normal hacerlo en lenguajes en que no pueden crearse componentes dinámicamente. END.1. 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.. 79 . Nodo=RECORD Info:Tinfo. EnlaceN: PNodo..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. y referenciales por medio de punteros. se representan por punteros explícitos. MATRIZ DE ADYACENCIA Es un array [1. Ejemplo: LISTA DE ADYACENCIA Es una tabla de 1 a n. todos los componentes o nodos....

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

3 ARBOL BINARIO Los árboles de grado 2 tienen una especial importancia. llamados subárbol izquierdo y derecho de la raíz. 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). Longitud de camino interno de un arbol: Es la suma de las longitudes de camino de todos sus nodos. 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. es decir. Nodo interno: Es aquel que no es hoja.Nodo terminal u hoja: Es aquel que tiene grado cero. 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. 81 . Se les conoce con el nombre de árboles binarios. que no tiene ningún descendiente.

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

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

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

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

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

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

dato:entero) Inicio Si raiz = nil entonces New(raiz) Raiz^. Insertar(Var raiz:pnodo. Mientras ptr <> nil y no salir hacer Si prt > 0 entonces Mostrar prt^.inf entonces Insertar (raiz^.dato) Fin_si Fin_si Fin.der = nil Sino Si dato > raiz^. si el dato es mayor que la raíz es insertada en el subárbol derecho. se realiza de acuerdo al valor que se debe insertar.der.inf = dato Raiz^.Fin.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.dato) Sino Insertar(raiz^. 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^.izq. si el dato es menor que la raíz es insertada en el subárbol izquierdo.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.- 114 ..- 5.2.

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

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

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

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

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

11 Grafos Regulares Un grafo se dice que es regular . Por ejemplo: Figura 7. 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. Figura 7.1. Para la figura anterior.• GRADO DE SALIDA Los grados de entrada de un vértice en un dígrafo.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. si todos los vértices tienen el mismo grado.14 Grafo Regular 120 .

7. 4.12 Arco Cíclico Un arco es cíclico si parte de un vértice y llega al mismo vértice.1. 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. si no tiene arcos cíclicos y existe un solo arco entre dos vértices.17 Grafos completos de 2. 3.1. donde n es el número de vértices que componen el grafo. 7.1.15 Grafo con arcos cíclicos (AA y BB) En la anterior figura se tienen dos arcos cíclicos. Ejemplo: Figura 7. 121 .13 Grafos Simples Un grafo es simple. 7. 5 y 6 vértices. Por ejemplo los siguientes grafos son completos: Figura 7.

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

1 Almacenamiento en memoria. ad) sig [i] =nuevo q =A p =*grafo [i]. i. ad) Inicio ASIGNA_NODO (nuevo. como también colocar el valor NULO para el campo siguiente. 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. El segundo es el campo siguiente que es un apuntador a otra estructura de tipo nodo. El primero es el campo indice que es el identificador de un nodo. 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. dentro del arreglo grafo. donde nv es el número de vértices del grafo.2. INS_GRAFO (grafo. Grafo es un arreglo de estructuras de tipo nodo. Aquí la estructura nodo está conformada por dos campos. 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.7. La rutina Iniciar_grafo se encarga de colocar un cero en el campo de indice de cada elemento de la estructura grafo.sig Mientras (p=A) Haga 123 .1. i.

sig Mientras (q =A) Visite_Vertice (q) q =*q.sig = nuevo Sino *q. j ]. y un 1 en caso contrario.18).sig Fin-Mientras Si (q = A) *grafo [i]. la matriz de adyacencia es: 124 .2.2 Matriz De Adyacencia En este caso a cada elemento M[ i . se le asigna un 0 si el vértice i no es adjunto al vértice j. Para el mismo grafo (figura 7. nv) Inicio i =1 Mientras (i<= nv) p =grafo [i] Visite_Vertice (p) q =*grafo [i].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.q =p p = *p. Recorrer_grafo (grafo..sig Fin-Mientras i=i +1 Fin-Mientras Fin 7.

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

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

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

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

Figura 7.23 Algoritmo de Dijkstra 129 .

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->