UNIDAD 2. ESTRUCTURAS DE DATOS SECUENCIALES. 1. Pilas (Stacks)

Transcripción

1 UNIDAD 2. ESTRUCTURAS DE DATOS SECUENCIALES 1. Pilas (Stacks) Una pila es una coleccion de elementos en la que sólo se pueden insertar y eliminar datos por uno de los extremos de la lista. Al igual que toda estructura de datos, se consideran algunas operaciones básicas como la inserción y el borrado, que se denominan comúnmente como operación "push" y "pop" respectivamente. Los elementos de una pila se eliminan en orden inverso al que fueron insertados. Es decir, el último elemento que entra a la pila es el primer elemento que se saca. Esta estructura se le conoce como estructura LIFO (Last-In, First-Out / último en entrar - primero en salir). Existen numerosos casos prácticos en los que se utiliza el concepto pila: pila de platos (cuando se necesita un plato limpio siempre se toma el primero de la pila), pila de monedas, pila de latas, etc. Las pilas se pueden representar con arreglos y con listas. En el caso de los arreglos es necesario definir el tamaño máximo, y una variable auxiliar que indique el tope de la pila, en el caso de las listas se manejan espacios dinámicos denominados nodos. Representación de una pila Las pilas se pueden representar en un lenguaje de programación por medio de listas enlazadas o con arreglos, para los cuales se debe definir el tamaño máximo de la pila y una variable auxiliar que debe servir como apuntador al último elemento de la pila llamado Tope. Representación en Memoria Las pilas no son estructuras de datos fundamentales, es decir, no están definidas como tales en los lenguajes de programación, ya que tienen que ser implementadas. Las pilas pueden representarse e implementarse mediante el uso de: Arreglos. Listas enlazadas. 1

2 A las Pilas que se implementan con arreglos se les denominan Pilas Estáticas, debido a que su tamaño difícilmente será modificado, a no ser que así se implemente. Por lo tanto es importante definir el tamaño máximo de la pila antes de su uso, además es necesario considerar un apuntador al último elemento insertado en la pila (tope) el cual denominaremos Sp (Stak pointer). La representación gráfica de una pila es la siguiente: Como utilizamos arreglos para implementar pilas, tenemos la limitante de espacio de memoria reservada. Una vez establecido un máximo de capacidad para la pila, ya no es posible insertar más elementos. Una posible solución a este problema es el uso de espacios compartidos de memoria. Supóngase que se necesitan dos pilas, cada una con un tamaño máximo de n elementos. En este caso se definirá un solo arreglo de 2*n elementos, en lugar que dos arreglos de n elementos. En este caso utilizaremos dos apuntadores: SP1 para apuntar al último elemento insertado en la pila 1 y SP2 para apuntar al último elemento insertado en la pila 2. Cada una de las pilas insertará sus elementos por los extremos opuestos, es decir, la pila 1 iniciará a partir de la localidad 1 del arreglo y la pila 2 iniciará en la localidad 2n. De este modo si la pila 1 necesita más de n espacios (hay que recordar que a cada pila se le asignaron n localidades) y la pila 2 no tiene ocupados sus n lugares, entonces se podrán seguir insertando elementos en la pila 1 sin caer en un error de desbordamiento Operaciones con pilas Las operaciones principales son poner y quitar elementos: ALGORITMO INSERTAR ELEMENTOS (PUSH) Este algoritmo pone el DATO en PILA. Actualiza el valor de TOPE. MAX es una variable que indica el máximo de elementos que puede almacenar la pila. SI TOPE < MAX TOPE = TOPE + 1 PILA[TOPE] = DATO SI NO LA PILA ESTA LLENA FIN SI 2

3 ALGORITMO ELIMINAR ELEMENTOS (POP) Este algoritmo saca el último elemento de la PILA. El elemento lo guarda en la variable DATO. Actualiza el valor de TOPE. SI TIPE > 0 DATO = PILA[TOPE] TOPE = TOPE 1 SI NO PILA VACIA Aplicaciones con pilas (postfix, prefix, infix) Las pilas son útiles en el tratamiento de recursividad, en llamadas a subprogramas, ordenación y en el manejo de expresiones aritméticas. En este último caso se utilizan para convertir expresiones en notación infija a su equivalente en postfijo o prefijo: Dada la expresión A+B, se dice que esta en notación infija y su nombre se debe a que el operador + se encuentra entre los operandos A y B. Dada la expresión AB+, se dice que esta en notación postfija y su nombre se debe a que el operador + se encuentra después de los operandos A y B. Dada la expresión +AB, se dice que esta en notación prefija y su nombre se debe a que el operador + se encuentra antes de los operandos A y B. La transformación de expresiones de infijo a postfijo y prefijo sigue las mismas reglas de precedencia para los signos de operación, es decir la potencia ($) tiene la mayor precedencia, después el producto y la división, y al final la suma y la resta. Además es importante recordar que las expresiones encerradas entre paréntesis, deberán ser resueltas anticipadamente. Recuerde que las operaciones como la suma, resta, división y producto son asociativas por la izquierda, a diferencia de la potencia que es asociativa por la derecha. A continuación observamos una tabla con ejemplos de conversión de operaciones infijo a postfijo/prefijo: Infijo Postfijo Prefijo A+B AB+ +AB A+B-C AB+C- -+ABC (A+B)*(C-D) AB+CD-* *+AB-CD A$B*C-D+E/F/(G+H) AB$C*D-EF/GH+/+ +-*$ABCD//EF+GH ((A+B)*C-(D-E))$(F+G) AB+C*DE--FG+$ $-*+ABC-DE+FG A-B/(C*D$E) ABCDE$*/- -A/B*C$DE Tome en cuenta que la forma prefija de una expresión compleja no es la imagen espejo de la forma postfija, como puede ser visto en el segundo ejemplo de la tabla. La ventaja de utilizar expresiones en notación polaca postfija y prefija radica en que no son necesarios los paréntesis para indicar el orden de operación, ya que este queda establecido por la ubicación de los operadores con respecto a los operando. 3

4 Las pilas son estructuras de datos muy usadas para la solución de diversos tipos de problemas. Pero tal vez el principal uso de estas estructuras es el tratamiento de expresiones matemáticas representadas en prefijo y postfijo, que es la manera en como las computadoras pueden interpretar las mismas. Los procesos para la conversión de expresiones de infijos a postfijo y prefijo pueden ser fácilmente mecanizados a través de algoritmos computacionales. Conversión de Expresiones en Infijo a Postfijo Considere dos expresiones A+B*C y (A+B)*C, y sus respectivas expresiones postfijas ABC*+ y AB+C*. En cada caso existe un orden especifico en el cual se respetan las precedencias de las operaciones que se tienen que realizar, resulta obvio observar que la precedencia de los operadores es un aspecto muy importante a considerar en el proceso de conversión, por ello asumiremos la existencia hipotética de una función precede( op1, op2 ), donde op1 y op2 son los caracteres que representan los operadores. Esta función regresa un valor verdadero si op1 tiene precedencia sobre op2, y falso para el caso contrario. Por lo que precede( *, + ) regresa verdadero, precede( +, + ) regresa verdadero y precede( +, * ) regresa falso. Además asumiremos las siguientes reglas de precedencia para los paréntesis, ya que las operaciones encerradas entre estos deberán ser realizadas previamente al resto de las operaciones, ya que su precedencia es mayor: precede( (, op ) = falso // para cualquier operador op precede( op, ( ) = falso // para cualquier operador op menos ) precede( op, ) ) = verdadero // para cualquier operador op menos ( precede( ), op ) = error // para cualquier operador op, se considera error A continuación mostraremos el algoritmo correspondiente para convertir expresiones en infijo a postfijo: stackop = una pila vacía while ( no sea fin de cadena de entrada infija ) simbolo = siguiente carácter de entrada if ( simbolo es un operando ) agregar simbolo a la cadena postfija else while (!vacia(stackop) && precede(tope(stackop),simbolo) ) topesimbolo = extrae(stackop) agregar topesimbolo a la cadena postfija if ( vacia(stackop) simbolo!= ')' ) inserta(stackop, simbolo) else topesimbolo = extrae(stackop) while (!vacia(stackop) ) topesimbolo = extrae(stackop) agregar topesimbolo a la cadena postfija Consideremos ahora la evaluación de las dos expresiones mencionadas al principio. 4

5 Ejemplo 1: cadena infija A + B * C símbolo Cadena postfija stackop 1 A A 2 + A + 3 B A B + 4 * A B + * 5 C A B C + * 6 A B C * + 7 A B C * + Las líneas 1,3 y 5 corresponden al deletreo de los operándoos por lo que símbolo es inmediatamente colocado en la cadena postfija. En la línea 2 un operador es deletreado y colocado en la pila que esta vacío. En la línea 4 la precedencia del símbolo * es mayor que la del símbolo colocado al tope de la pila (+); por lo que el nuevo símbolo es colocado en la pila. En la línea 6 y 7 la cadena de entrada es vacía, y la pila es vaciada extrayendo su contenido y colocándolo en la cadena postfija. La colocación de los elementos en la pila stackop es en dirección derecha izquierda, por lo que los elementos van siendo incrustados del lado derecho. Ejemplo 2: cadena infija (A + B) * C símbolo Cadena postfija stackop 1 ( ( 2 A A ( 3 + A ( + 4 B A B ( + 5 ) A B + 6 * A B + * 7 C A B + C * 8 A B + C * En este ejemplo, cuando el paréntesis del lado derecho es encontrado los elementos de la pila son extraídos hasta que el paréntesis izquierdo es encontrado, en este punto ambos paréntesis son descartados. De esta manera los paréntesis forzan a un orden de precedencia diferente. Evaluación de Expresiones en Postfijo Cada operador en una cadena postfija se refiere a los dos operados previos en la cadena. Suponga que cada vez que leemos un operando colocamos a éste en la pila. Cuando alcanzamos un operador, sus operándoos estarán al tope de la pila. Nosotros podemos extraer estos dos elementos, realizar la operación indicada en ellos y colocar el resultado en la pila de manera que quede disponible para ser usado como operando en la siguiente operación. A continuación presentamos un algoritmo que es capaz de evaluar expresiones postfijas: stackop = una pila vacía while ( no sea fin de cadena de entrada postfija ) simbolo = siguiente carácter de entrada if ( simbolo es un operando ) 5

6 inserta(stackop, simbolo) else // el simbolo es un operador op1 = extrae(stackop) op2 = extrae(stackop) valor = el resultado de aplicar símbolo a op1 y op2 inserta(stackop, valor) return extrae(stackop) Suponga que queremos evaluar la siguiente expresión en postfijo: / + *. La siguiente tabla muestra los valores que se van generando en la evaluación de cada elemento de la cadena. Cada operando es colocado en una pila de operándoos. De tal manera que el numero máximo de elementos de la pila que es el numero de operándoos que aparecen en la entrada de la expresión. Sin embargo el máximo de de elementos en la pila es menor al numero teóricamente necesario, ya que el operador los remueve de la pila. En el ejemplo veremos que la pila nunca contiene mas de cuatro elementos, a pesar de que aparecen seis operándoos en el ejemplo. Tome en cuenta que el ejemplo supone la entrada de la cadena del tipo postfijo. Símbolo op1 op2 valor stackop , 2 3 6, 2, , , , 3, , 3, 8, 2 / , 3, , 7 * Colas Una cola es una lista de elementos en la que éstos se introducen por un extremo y se eliminan por otro. Los elementos se eliminan en el mismo orden en el que insertaron. El primer elemento que entra en la cola, es el primer elemento en salir. Las colas también reciben el nombre de estructuras FIFO (First-In, First-Out) Ejemplos, una cola de personas esperando usar el teléfono público, comprar tortillas, una fila de autos en un auto lavado, etc. Las colas son una estructura con muy pocas operaciones disponibles ya que solo permiten añadir y leer elementos y al igual que las pilas, se pueden representar con arreglos y listas. En el caso de los arreglos es necesario definir el tamaño máximo para la cola y dos variables auxiliares; una de ellas para que guarde la posición del primer elemento de la cola (Frente) y otra para que guarde la posición del ultimo elemento (Final) Máximo Frente Final 6

7 ALGORITMO INSERTAR ELEMENTOS Este algoritmo inserta el elemento Dato al Final de la cola. Frente y Final son variables que indican el inicio y fin de la cola, respectivamente. MAX es el máximo de elementos que puede almacenar la cola. Frente y Final inician en 0. if ( Final < MAX ) Final = Final + 1 Cola [ Final ] = Dato if ( Final igual a 1 ) Frente = 1 else Cola llena ALGORITMO ELIMINAR ELEMENTOS Este algoritmo elimina el primer elemento de la cola y lo guarda en la variable Dato. if ( Frente no es igual a 0 ) Dato = Cola [ Frente ] if ( Frente igual a Final ) Frente = 0 Final = 0 else Frente = Frente + 1 else COLA VACIA Colas circulares Para hacer uso mas eficiente de la posiciones disponible se trata a las colas como una estructura circular. Para ello es necesario realizar varios cambios al esquema inicial, en primer lugar los valores para Frente y Final deberán iniciar ambos en la posición máxima de la cola, debido a que el ultimo elemento de la cola precede inmediatamente al primero al primero dentro de la cola bajo esta representación. En segundo lugar es necesario sacrificar un elemento de la cola para no tener casos absurdos en el que Final y Frente sean la misma posición aún cuando la cola este casi vacía. El algoritmo de inserción deberá contemplar un caso especial donde el Frente es incrementado en una unidad y paso seguido se verifica que Final es igual Frente, en ese caso el valor de Final ya fue incrementado y como se verifico que la cola esta llena, es necesario manipular el valor de Final para que sea reubicado en su posición anterior próxima. 7

8 ALGORITMO INSERTAR ELEMENTOS Este algoritmo inserta el elemento Dato al final de la cola. Frente y Final son variables que indican el inicio y fin de la cola. MAX es el máximo de elementos que puede almacenar la cola. if ( Final igual a MAX ) Final = 1 else Final = Final + 1 if ( Final igual a Frente ) Cola llena else Cola [ Final ] = Dato ALGORITMO ELIMINAR ELEMENTOS Este algoritmo elimina el primer elemento de la cola y lo guarda en la variable DATO. if ( Frente = Final ) COLA VACIA else if ( Frente igual a MAX ) Frente = 1 else Frente = Frente + 1 Dato = Cola [ Frente ] 8