Ficha de datos Créditos Institucionales: 8 créditos.

Presentación del tema: "Ficha de datos Créditos Institucionales: 8 créditos."— Transcripción de la presentación:

1 Ficha de datos Créditos Institucionales: 8 créditos.
Titulo de la guía para la Unidad de Aprendizaje: “Introducción a Pilas y Colas”. Nombre del programa educativo: Licenciatura en Ingeniería en Computación. Unidad de Aprendizaje: Estructura de Datos Espacio Académico : Centro Universitario UAEM Valle de Teotihuacán. Nombre del Responsable: M. en S.C. Jaqueline Sánchez Espinoza

2 Índice TDA Pila TDA Cola Definición y operaciones básicas
Operaciones e implementación Aplicaciones TDA Cola

3 TDA PILA Definición Def: una pila es una lista ordenada de elementos en la que todas las inserciones y supresiones se realizan por un mismo extremo denominado tope o cima de la pila. Estructura LIFO (Last In First Out): “último en entrar primero en salir”

4 Operaciones básicas PUSH: apilar, meter POP: desapilar, sacar
TDA PILA Operaciones básicas PUSH: apilar, meter POP: desapilar, sacar TOP: cima, tope

5 Operaciones TDA PILA Crear_pila(P: pila, ok: lógico)
Borrar_pila(P: pila, ok: lógico) Vacía?(P: pila, resp: lógico) Llena?(P: pila, resp: lógico) Push(P: pila, X: elemento, resp: lógico) Pop(P: pila, X: elemento, resp: lógico) Top(P: pila, X: elemento, resp: lógico)

6 Implementación Listas enlazadas Vectores TDA PILA Variables dinámicas
No riesgo de overflow Limitadas por memoria disponible Cada elemento necesita más memoria (guardar dirección siguiente) Uso eficiente de memoria Vectores Variables estáticas Tamaño máximo fijo Peligro de desbordamiento (overflow) Uso ineficiente de memoria Problema común: underflow o subdesbordamiento

7 Implementación con vectores
TDA PILA Implementación con vectores Definición de tipos ELEMENTO = T; PILA = registro de tope: numérico; arreglo: vector[1..MAX] de ELEMENTO; finregistro; Operación Push Algoritmo PUSH (P: Pila, X: ELEMENTO, ok: lógico) es resp: lógico; INICIO Llena?(P,resp); si resp entonces ok:= falso; sino P.tope:= P.tope + 1; P.arreglo[P.tope]:= X; ok:= cierto; finsi; FIN

8 Implementación con vectores
TDA PILA Implementación con vectores Operación Top Algoritmo TOP (P: PILA, X: ELEMENTO, ok:lógico) es resp: lógico; INICIO Vacia?(P, resp); si resp entonces ok:= falso; {pila vacía} sino ok:= cierto; X:= P.arreglo[P.tope]; finsi; FIN Operación Pop Algoritmo POP (P: PILA, X: ELEMENTO, ok: lógico) es INICIO Vacia(P, resp); si resp entonces ok:= falso; {no hay elementos q sacar} sino X:= P.arreglo[P.tope]; P.tope:= P.tope -1; ok:= cierto; finsi; FIN

9 Implementación con listas enlazadas
TDA PILA Implementación con listas enlazadas Definición de tipos ELEMENTO = T; NODO = registro de info: ELEMENTO; sgte: puntero a NODO; finregistro; POSICION = puntero a NODO; PILA = registro de longitud: numerico; prim: POSICIÓN; finregistro;

10 Implementación con listas enlazadas
TDA PILA Implementación con listas enlazadas Operación Push Algoritmo PUSH (P: PILA, X: ELEMENTO, ok: logico) es resp: logico; temp: POSICION; INICIO Llena?(P,resp); {resp=falso si no se puede reservar más memoria} si resp entonces ok := falso; Escribir “Pila llena”; sino Obtener(temp); temp.info := X; temp.sgte := P.prim; {será nil si la pila estaba vacía} P.prim := temp; P.longitud := P.longitud +1; ok := cierto; finsi FIN

11 Implementación con listas enlazadas
TDA PILA Implementación con listas enlazadas Operación Pop Algoritmo POP (P: PILA, X: ELEMENTO, ok: logico) es resp: lógico; temp: POSICION; INICIO Vacia?(P, resp); si resp entonces ok := falso; {la pila está vacía} sino {procedemos a sacar el último elemento insertado} temp := P.prim; P.prim := temp.sgte; {que será nil si sólo hay un elemento en la pila} X := temp.info; Liberar(temp); ok := cierto; finsi; FIN

12 Implementación con listas enlazadas
TDA PILA Implementación con listas enlazadas Operación Top Algoritmo TOP(P: PILA, X: ELEMENTO, ok: lógico) es resp: lógico; INICIO Vacia?( P, resp); si resp entonces ok:= falso; {Pila vacia} sino X := P.prim.info; ok:= cierto; finsi; FIN

13 Aplicaciones de las pilas
TDA PILA Aplicaciones de las pilas Gran uso en compiladores y SO’s. Entornos donde haya que recuperar el último valor que se almacenó (backtracking) Algunas aplicaciones: Equilibrado de símbolos Llamadas a subprogramas Eliminación de recursividad Tratamiento de expresiones aritméticas Evaluación de expresiones postfijas Conversión infija a postfija Borrado de caracteres en un editor de textos

14 Equilibrado de símbolos
Aplicaciones de las pilas TDA PILA Equilibrado de símbolos Se van leyendo los caracteres. Cuando se encuentra un elemento clave (paréntesis, corchete…) se trata según su tipo: Si es de apertura: se mete en la pila. Si es de cierre: Si la pila está vacía error. Si la pila no está vacía: Si la cima es el correspondiente símbolo de apertura se extrae. Si no lo es error. Si al final la pila no está vacía error

15 Llamadas a subprogramas
Aplicaciones de las pilas TDA PILA Llamadas a subprogramas Al llamar a un subprograma se necesita guardar: Estado de las variables locales del programa que llama Dirección del programa en la que se hizo la llamada Al hacer la llamada esta información se mete en la cima de una pila. Al terminar el subprograma, se saca la cima y se recupera el estado del momento de la llamada vuelve al punto de ejecución donde se hizo la llamada. El subprograma puede llamar a otros subprogramas y así sucesivamente. Permite implementar la recursión. Registro de activación Peligro: rebasamiento de la pila

16 Eliminación de recursividad
Aplicaciones de las pilas TDA PILA Eliminación de recursividad La recursión consume muchos recursos (memoria). Recursión de cola: la llamada recursiva está en la última línea. Para eliminarla: Se necesita: argumentos del algoritmo pasados por valor o referencia si son los mismos argumentos los que se pasan a la llamada recursiva. Se asignan a los argumentos los valores que se van a pasar en la llamada recursiva. Salto (goto) al principio de la rutina. Para transformar algoritmo recursivo en iterativo: Se guarda en pilas el estado del problema en el momento de la llamada recursiva. Se vuelve al principio de la rutina mediante una estructura iterativa. La vuelta atrás de la recursión se consigue sacando los valores de las pilas

17 Tratamiento de expresiones aritméticas
Aplicaciones de las pilas TDA PILA Tratamiento de expresiones aritméticas Notación infija: a + b Notación prefija: + a b Notación postfija: a b + Problema: distinción de prioridades en notación infija. Ej: evaluar a + b * c Soluciones: Empleo de paréntesis. Conversión a notación prefija o postfija. Ventajas de la notación postfija: No hace falta conocer reglas de prioridad. No hace falta emplear paréntesis.

18 Aplicaciones de las pilas
TDA PILA Tratamiento de expresiones aritméticas: Evaluación de expresiones postfijas Se lee la expresión elemento a elemento. Si es un operando se mete en una pila Si es un operador, se extraen los dos últimos elementos introducidos en la pila, se aplica el operador sobre ellos y el resultado se guarda en la pila. Ejemplo: * +

19 Tratamiento de expresiones aritméticas: Conversión infija a postfija
Aplicaciones de las pilas TDA PILA Tratamiento de expresiones aritméticas: Conversión infija a postfija Operandos: se colocan directamente en la salida. Operadores: si la pila está vacía, lo metemos en la pila. Si no: Si en la cima se encuentra un operador de menor prioridad: push() Si no: pop() hasta que en la cima haya uno de menor prioridad, un paréntesis de apertura o la pila esté vacía. Entonces se hace un push(). Paréntesis: de apertura ‘(‘ : se mete en la pila. de clausura ’)’ : se van llevando los operadores de la pila a la salida hasta que se encuentra uno de apertura, que se saca de la pila. Para finalizar, si en la pila aún queda algún operador, se lleva a la salida.

20 Borrado de caracteres en un editor de texto
Aplicaciones de las pilas TDA PILA Borrado de caracteres en un editor de texto Se van leyendo los caracteres de uno en uno. Si el carácter no es de borrado ni de eliminación de línea, se mete en la pila. Si el carácter es de borrado, se hace un pop(), para sacar el elemento cima de la pila. Si el carácter es de eliminación de línea se vacía toda la pila. Ejemplo: si # es el carácter de borrado, i n p # f o r o n # # m á t i z # c a informática

21 TDA COLA Definición Def: una cola es una lista ordenada de elementos en la que todas las inserciones se realizan por un extremo (frente o principio) y las supresiones se realizan por el otro (final). Estructura FIFO (First In First Out): “primero en entrar primero en salir”

22 Operaciones básicas QUEUE: encolar, meter DEQUEUE: desencolar, sacar
TDA COLA Operaciones básicas QUEUE: encolar, meter DEQUEUE: desencolar, sacar

23 Operaciones TDA COLA Crear_cola(C: cola, ok: lógico)
Borrar_cola(C: cola, ok: lógico) Vacía?(C: cola, resp: lógico) Llena?(C: cola, resp: lógico) Queue(C: cola, X: elemento, resp: lógico) Dequeue(C: cola, X: elemento, resp: lógico) Tamaño(C: cola, N: numérico)

24 Implementación con listas enlazadas
TDA COLA Implementación con listas enlazadas Definición de tipos ELEMENTO = T; NODO = registro de info: ELEMENTO; sgte: puntero a NODO; fin registro; POSICION = puntero a NODO; COLA = registro de tam: numerico; prim, ult: POSICIÓN; fin registro;

25 Implementación con listas enlazadas
TDA COLA Implementación con listas enlazadas Operación QUEUE Algoritmo QUEUE(C: cola, X: ELEMENTO, resp: lógico) es temp: POSICION; INICIO Llena?(C,resp); si resp = cierto entonces Escribir “Cola llena”; resp := falso; sino {la cola no está llena, por lo que procedemos a añadir el elemento} Obtener(temp); temp .info := X; temp.sgte := nil; {porque va a ser el último} Vacía?(C,resp); si resp = cierto entonces {será el primero} C.prim := temp; sino C.ult.sgte := temp; {será el siguiente al último} finsi; C.ult := temp; {porque es el nuevo último elemento} C.longitud := C.longitud + 1; {pues ahora hay un elemento más en la cola} FIN

26 Implementación con listas enlazadas
TDA COLA Implementación con listas enlazadas Operación DEQUEUE Algoritmo DEQUEUE(C: cola, X: ELEMENTO, resp: lógico) es temp: POSICION; tam: numérico; INICIO Vacía?(C,resp); si resp = cierto entonces Escribir “Cola vacía”; resp := falso; sino temp := C.prim; E := temp.info; Tamaño(C,tam); si tam = 1 entonces C.ult := nil; finsi; C.prim := temp.sgte; {si sólo había un elemento, será nil} Liberar(temp); C.longitud := C.longitud -1; FIN

27 Implementación con vectores
TDA COLA Implementación con vectores Si el principio de la cola es fijo en la primera posición del vector y el final es variante para eliminar un elemento de la cola hay que desplazar todos los demás una posición (Dequeue() es ineficiente). Si principio y final de la cola son variantes, no hacen falta desplazamientos. Problema: la cola puede desbordarse teniendo celdas libres.

28 Implementación con vectores
TDA COLA Implementación con vectores Solución: VECTOR CIRCULAR cuando algún índice llega al final, vuelve al comienzo del vector Definición de tipos ELEMENTO = T; COLA = registro de prim, ult, tam: numérico; arreglo: vector[1..MAX] de ELEMENTO; finregistro; Para saber si la cola está llena o vacía, su tamaño se controla con el campo tam del registro

29 Implementación con vectores
TDA COLA Implementación con vectores Operación QUEUE Algoritmo QUEUE(C: COLA, X: ELEMENTO, resp: lógico) es INICIO Llena?(C,resp); si resp = cierto entonces {la cola está llena} Escribir “Cola llena”; resp := falso; sino {la cola no está llena, por lo que procedemos a añadir el elemento} C.ult := (C.ult + 1) mod MAX; {hacemos que ult avance de forma circular} C.arreglo[C.ult] := X; C.tam := C.tam +1; {pues ahora hay un elemento más en la cola} finsi; FIN

30 Implementación con vectores
TDA COLA Implementación con vectores Operación Dequeue Algoritmo DEQUEUE(C: COLA, X: ELEMENTO, resp: lógico) es INICIO Vacía?(C,resp); si resp = cierto entonces {la cola está vacía} Escribir “Cola vacía”; resp := falso; sino {hay al menos un elemento} X := C.arreglo[C.prim]; C.prim := (C.prim + 1) mod MAX; C.longitud := C.longitud -1; finsi; FIN

31 Aplicaciones de las colas
TDA COLA Aplicaciones de las colas Principalmente: gestión de recursos Sistemas de tiempo compartido: los recursos (CPU, memoria, …) se asignan a los procesos que están en cola de espera en el orden en el que fueron introducidos. Colas de impresión: al intentar imprimir varios documentos a la vez o la impresora está ocupada, los trabajos se almacenan en una cola según el orden de llegada. Simulación por computadora de situaciones reales: una cola de clientes en un supermercado o el tiempo de espera para ser atendidos por un operador de una línea telefónica.

32 Bibliografía Michael T. Goodrich, Roberto Tamassia, Data structures and algorithms in Java. John Wiley & Sons, 2006. Aho A.V., Hopcroft J.E., Ullman J.D., Estructuras de datos y algoritmos. Addison-Wesley, 1988. Weiss, Mark Allen, Data Structures and Algorithm Analysis in Java. Pearson Education, 2007. Weiss, Mark Allen, Estructuras de datos y algoritmos. Addison-Wesley Iberoamericana, 1995. Sahni, Sartaj, Data structures, algorithms, and applications in Java. McGraw Hill, 2000 The Java Tutorials: Collections