ELO320 Estructuras de Datos y Algoritmos. Stacks y Colas. Tomás Arredondo Vidal

Transcripción

1 ELO320 Estructuras de Datos y Algoritmos Stacks y Colas Tomás Arredondo Vidal Este material está basado en: Robert Sedgewick, "Algorithms in C", (third edition), Addison-Wesley, ISBN material del curso ELO320 del Prof. Leopoldo Silva material en el sitio 6: Stacks 1

2 6-Stacks y Colas 6.1 Stacks: definiciones y operaciones 6.2 Stacks: implementación 6.3 Colas: definiciones y operaciones 6.4 Colas: implementación 6: Stacks 2

3 Definiciones y operaciones Un stack (o pila) es una lista restringida, en cuanto a operaciones, ya que sólo permite inserciones y descartes en un extremo (el tope del stack). Tiene gran utilidad al ser usado para implementar variables automáticas, implementar funciones recursivas, para evaluar balance de paréntesis entre otras. Operaciones posibles sobre stacks incluyen: Empujar en el stack o Push Sacar del stack o Pop Leer el primer elemento del stack o Read 6: Stacks 3

4 6-Stacks y Colas 6.1 Stacks: definiciones y operaciones 6.2 Stacks: implementación 6.3 Colas: definiciones y operaciones 6.4 Colas: implementación 6: Stacks 4

5 Stacks: Implementación En general la implementación de las operaciones de inserción y descarte usando arreglos son costosas, en comparación con nodos enlazados vía punteros, porque es necesario desplazar el resto de las componentes después de una inserción o descarte Otro beneficio de usar punteros es que el stack puede crecer dinámicamente 6: Stacks 5

6 Stacks: Implementación usando arreglos #ifndef STACK_H #define STACK_H typedef int Item; // Item almacenado es un int void StackInit(int); int StackEmpty(void); int StackFull(void); void StackPush(Item); Item StackPop(void); void StackDestroy(void); #endif /* STACK_H */ 6: Stacks 6

7 Stacks: Implementación usando arreglos (cont) #include stack.h static Item * stack; // puntero al inicio de la zona del stack static int NumItems; // numero items en el stack static int MAXN; // Máxima capacidad del stack void StackInit(int max) { stack = malloc(max*sizeof(item) ); //se solicita arreglo. if (stack == NULL) exit(1); NumItems = 0; MAXN=max; 6: Stacks 7

8 Stacks: Implementación usando arreglos (cont) int StackEmpty(void) { return(numitems == 0) ; //Retorna True o 1 si stack vacío int StackFull(void) { return(numitems == MAXN) ; //Ret. True si stack lleno //se puede empujar algo al stack si no está lleno. void StackPush(Item item) { if (!StackFull() ) stack[numitems ++] = item; 6: Stacks 8

9 Stacks: Implementación usando arreglos (cont) Item StackPop(void) { if( StackEmpty() ) { printf("error. Extracción de stack vacio\n"); exit(1); else return ( stack[--numitems] ) ; void StackDestroy(void) { free(stack); 6: Stacks 9

10 Ejemplo: Balance de Parentesis Es útil poder detectar si es que los paréntesis en un archivo fuente están o no correctamente balanceados Ejemplo: a + (b + c) * [(d + e])/f Seudo-código usando un stack: Crear el stack. Mientras no se ha llegado al final del archivo de entrada: Descartar símbolos que no necesiten ser balanceados. Si es un paréntesis de apertura: empujar al stack. Si es un paréntesis de cierre, efectuar un pop y comparar. Si son de igual tipo continuar Si son de diferente tipo: avisar el error. Si se llega al fin de archivo, y el stack no esta vacío: avisar error. Destruir el stack. 6: Stacks 10

11 Ejemplo: Expresiones en notacion Polaca Inversa Las expresiones aritméticas que generalmente escribimos están en notación in situ o fija. En esta notación los operadores se presentan entre dos operandos; por ejemplo: * 4. Esta notación no explica el orden de precedencia, esto puede resolver con reglas y con paréntesis: ( ) * 4 La Reverse Polish Notation inventada por Jan Lukasiewicz se usa en calculadoras HP resuelve esto. En notación RPN el operador sigue a los operandos: * que en in situ corresponde a: ( ) * 4 6: Stacks 11

12 Ejemplo: Expresiones en notacion Polaca Inversa (cont) (3 + 5) * (7-2) puede escribirse: * Leyendo la expresión en RPN se realiza con las siguientes operaciones: Push 3 en el stack. Push 5 en el stack. El 5 está en el tope, es el último en entrar: (3, 5) Se aplica la operación + la cual saca los dos números del tope del stack, los suma y coloca el resultado en el tope: (8) Push 7 en el stack: (8, 7) Push 2 en el stack: (8, 7, 2) Se efectúa la operación con los dos números en el tope. Éste contiene ahora (8, 5) Se efectúa la operación *el stack contiene ahora (40). 6: Stacks 12

13 Ejemplo: Expresiones en notacion Polaca Inversa (cont) Seudo-código While ( no se haya leído el símbolo fin de archivo EOF) { leer un símbolo; Si es número: empujar el valor del símbolo en el stack Si es un operador: { Efectuar dos pop en el stack; Ejecutar operación sobre los números; Empujar el resultado en el stack; Retornar contenido del tope del stack como resultado; 6: Stacks 13

14 Ejemplo: Conversión de in situ a Polaca Inversa Es útil poder convertir las expresiones infijas a RPN para poder evaluarlas en un stack. Para especificar el algoritmo es preciso establecer las reglas de precedencia de operadores: La más alta prioridad está asociada a los paréntesis, los cuales se tratan como símbolos Prioridad media tienen la operaciones de multiplicación y división La más baja la suma y resta. Se asume solamente la presencia de paréntesis redondos en expresiones. Como la notación polaca inversa no requiere de paréntesis, éstos no se sacarán hacia la salida. 6: Stacks 14

15 Ej: While ( no se haya leído el símbolo fin de archivo EOF) { leer un símbolo; Si es número: enviar hacia la salida; Si es el símbolo ) : no sacar del stack hacia la salida, hasta encontrar (, el cual debe copiarse hacia la salida. Si es operador o el símbolo ( : Si la prioridad del recién leído es menor o igual que la prioridad del operado ubicado en el tope del stack: salida sea { if( tope== ( ) empujar el operador recién leído; else { efectuar pop del operador y sacarlo hacia la hasta que la prioridad del operador recién leído mayor que la prioridad del operador del tope. Empujar el recién leído en el tope del stack. else empujar recién leído al tope del stack; Si se llega a fin de archivo: vaciar el stack, hacia la salida. 6: Stacks 15

16 6-Stacks y Colas 6.1 Stacks: definiciones y operaciones 6.2 Stacks: implementación 6.3 Colas: definiciones y operaciones 6.4 Colas: implementación 6: Stacks 16

17 Definiciones y operaciones Una cola es una lista con restricciones. En ésta las inserciones ocurren en un extremo y los descartes en el otro (e.g. una cola en el banco) Si se conoce el máximo número de componentes que tendrán que esperar en la cola, se suele implementar en base a arreglos. Requiere dos variables o índices: cola que es un índice a donde insertar o encolar cabeza es un índice al elemento a descartar o desencolar 6: Stacks 17

18 Definiciones y operaciones A medida que se consumen o desencolan componentes, van quedando espacios disponibles en las primeras posiciones del arreglo. También a medida que se encolan elementos va disminuyendo el espacio para agregar nuevos elementos. Una mejor utilización del espacio se logra con un buffer circular, en el cual la posición siguiente a la última del arreglo es la primera del arreglo. 6: Stacks 18

19 Buffer circular Este buffer se puede implementar aplicando aritmética modular, si el anillo tiene N posiciones, la operación: cola = (cola + 1) % N, mantiene el valor de la variable cola entre 0 y N-1. Operación similar puede efectuarse para la variable cabeza cuando deba ser incrementada en uno. La variable cola puede variar entre 0 y N-1. Si cola tiene valor N-1, al ser incrementada en uno (módulo N), tomará valor cero. También se agrega una variable N con el numero de elementos encolados para poder distinguir entre la cola vacía y llena. 6: Stacks 19

20 6-Stacks y Colas 6.1 Stacks: definiciones y operaciones 6.2 Stacks: implementación 6.3 Colas: definiciones y operaciones 6.4 Colas: implementación 6: Stacks 20

21 Colas: Implementación usando arreglos circulares typedef int Item; // Item es un entero en este ejemplo static Item *q; // Puntero al arreglo de Items static int N, cabeza, cola, encolados; //Administran el anillo void QUEUEinit(int maxn) //maxn es el valor N-1 de la Fig { q = malloc((maxn+1)*sizeof(item)); // Espacio para N items N = maxn+1; cabeza = 0; cola = 0; encolados=0; /* La detección de cola vacía se logra con */ int QUEUEempty() { return (encolados == 0); 6: Stacks 21

22 Colas: Implementación (cont) /* Si la cola no está vacía se puede consumir un elemento */ Item QUEUEget() { Item consumido= q[cabeza]; cabeza = (cabeza + 1) % N ; encolados--; return (consumido); /* La detección de cola llena se logra con QUEUEfull( )*/ int QUEUEfull() { return( encolados == N); 6: Stacks 22

23 Colas: Implementación (cont) void QUEUEput(Item item) /* Encolar un elemento */ { q[cola] = item; cola = (cola +1) % N; encolados++; void QUEUEdestroy(void) /* Para recuperar el espacio */ { free ( q ); Las funciones cola llena y vacía se podrían implementar con macros para reducir uso del stack. #define QUEUEempty() (encolados == 0) #define QUEUEfull() (encolados == N) 6: Stacks 23