CI 2126 Guía de Teoría 6 pdf

Texto completo

(1)CAPITULO 6 PILAS Y COLAS 6.1 PILA Una Pila es un conjunto ordenado de elementos en el cual se pueden agregar y eliminar elementos en un extremo, que es llamado el tope de la pila. Es un objeto dinámico en continuo cambio. Veamos ahora la definición del TAD PILA. 6.1.1 Conceptualización de la estructura Una pila es una colección de elementos (e 1,...en) donde e1 es el tope de la pila. Las características de esta estructura son: Tope. e d c b a. Figura 6.1. Estructura del LIFO. 1. Un solo extremo de pila se designa como tope. 2. Solo puede agregarse nuevos elementos en el tope. 3. Cuando se agrega un elemento, el nuevo tope es este elemento (sube el tope). 4. Solo puede quitarse el primer elemento (tope) de la pila, en este caso, en el tope baja. 5. Se denomina a esta estructura LIFO, por su comportamiento (last in first out), ver figura 6.1. 6. En cada momento solo es visible y accesible el tope de la pila, por lo que el resto de ella (tanto elementos como su numero) no importa, en dicho momento.. 6.1.2 Operaciones primitivas El TAD PILA contiene las primitivas que permiten hacer los dos cambios fundamentales en la estructura, es decir, agregar y/o eliminar elementos del tope, Así como también el constructor y el destructor del TAD. Veamos las primitivas del TAD PILA. 6.1.2.1 El constructor: P_Crear: void → PILA /* PRE: ninguna POST: Devuelve una pila vacía */ El prototipo de esta operación es PILA P_Crear(); 6.1.2.2 El Destructor: P_Destruir: PILA → void /* PRE: dada una pila creada POST: Libera el espacio de memoria ocupado por la pila */ 1.

(2) El prototipo de esta operación es void P_Destruir (PILA P); 6.1.2.3 Los modificadores: P_Pop: PILA → PILA /* PRE: dada una una pila creada no vacía POST: remueve el tope de la pila */ El prototipo de esta operación es PILA P_Pop(PILA P); P_Push: PILA x ELEM → PILA /* PRE: dada una una pila creada y un elemento POST: coloca el elemento como el nuevo tope de la pila */ El prototipo de esta operación es PILA P_Push(PILA P, ELEM e); 6.1.2.4 Los observadores: P_Top: PILA → ELEM /* PRE: dada una una pila creada y no vacía POST: devuelve el elemento del tope */ El prototipo de esta operación es ELEM P_Top(PILA P); P_Empty: PILA → bool /* PRE: dada una una pila creada POST: dice si la pila está vacía */ El prototipo de esta operación es bool P_Empty(PILA P);. 6.1.3. Implementación de la pila usando lista enlazada. La pila es una estructura dinámica que crece y decrece constantemente. Aunque puede ser implementada en algunos casos de manera estática a través de un arreglo, su comportamiento dinámico nos obliga a considerar implementarla como una estructura dinámica de memoria. Es decir, usando listas enlazadas. En la figura 6.2. se presenta un diagrama de lista enlazada equivamente a una pila. Note que cada elemento de la pila aparece en un nodo diferente. El tope de la pila se coloca en el inicio de la lista enlazada. Esto permite que las dos operaciones de modificación de la estructura de la pila sean realizadas por el comienzo de la lista enlazada. Esto hará que dichas operaciones sean muy sencillas de implementar. 2.

(3) Pila Tope. c b a. c. b. a. Figura 6.2. Esquema de lista enlazada. Veamos como quedaría la estructura de datos: typedef struct s_nodo { ELEM info; struct s_nodo *sig; } NODO; typedef NODO *PILA; Note que la estructura principal es el nodo y que la pila simplemente es un apuntador a nodo. 6.1.4 Implementación de las Operaciones Primitivas En el caso del constructor no hay que crear ningún encabezado por lo que el constructor realmente no hace nada. PILA P_Crear () /* PRE: ninguna POST: Devuelve una pila vacía. */ { return(NULL); } void P_Destruir (PILA P) /* PRE: dada una pila creada POST: Libera el espacio de memoria ocupado por la pila */ { while !(P_Empty(P)) P=P_Pop(P); } PILA P_Pop(PILA P) 3.

(4) /* PRE: dada una una pila creada no vacía POST: remueve el tope de la pila */ { NODO *aux; aux=P; P=P–>sig; free(aux); return(P); } PILA P_Push(PILA P,ELEM e) /* PRE: dada una una pila creada y un elemento POST: coloca el elemento como el nuevo tope de la pila */ { NODO *aux; if ((aux=(NODO *)malloc(sizeof(NODO))) != NULL) { aux->info = e; aux->sig = P; P = aux; } return(P); } ELEM P_Top(PILA P) /* PRE: dada una una pila creada y no vacía POST: devuelve el elemento del tope */ { return (P->info); } bool P_Empty(PILA P) /* PRE: dada una una pila creada POST: dice si la pila está vacía */ { return ((P == NULL)); }. 6.2 COLA Una Cola es un conjunto ordenado de elementos donde siempre se eliminan elementos de un extremo (parte delantera) y se insertan elementos en el otro extremo (parte posterior). En la figura 6.3 se puede observar dicho comportamiento para una cola. 4.

(5) 6.2.1 Conceptualización de la estructura Una cola es una colección de elementos (e 1,...en) donde e1 es el primero de la cola y en es el último de la cola.. b a. b. c. c Se eliminó a. b. c. d. e. Se agregó d y e Figura 6.3. Simulación de cola. El comportamiento de una cola se conoce como FIFO (First in first out), es decir, el primer elemento insertado en una cola es el primero en salir de ella. Existen ejemplos abundantes en el mundo real de este comportamiento: paradas de autobús, fila del banco, automóviles en un peaje, entre otros. 6.2.2 Operaciones primitivas El TAD COLA contiene las primitivas que permiten hacer los dos cambios fundamentales en la estructura, es decir, agregar elementos al final de la cola o eliminar elementos del comienzo de la cola. También aparecen el constructor y el destructor del TAD. Veamos las primitivas del TAD COLA. 6.2.2.1 El constructor: C_Crear: void → COLA /* PRE: ninguna POST: Devuelve una cola vacía */ El prototipo de esta operación es COLA C_Crear(); 6.2.2.2 El Destructor: C_Destruir: COLA → void /* PRE: dada una cola creada POST: Libera el espacio de memoria ocupado por la cola */ El prototipo de esta operación es void C_Destruir (COLA C); 6.2.2.3 Los modificadores: C_Remove: COLA → COLA 5.

(6) /* PRE: dada una una cola creada no vacía POST: remueve el primer elemento de la cola */ El prototipo de esta operación es COLA C_Remove(COLA C); C_Insert: COLA x ELEM → COLA /* PRE: dada una una cola creada y un elemento POST: coloca el elemento al final de la cola */ El prototipo de esta operación es COLA C_Insert(COLA C, ELEM e); 6.2.2.4 Los observadores: C_First: COLA → ELEM /* PRE: dada una cola creada y no vacía POST: devuelve el primer elemento a ser atendido */ El prototipo de esta operación es ELEM C_First(COLA C); C_Empty: COLA → bool /* PRE: dada una cola creada POST: dice si la cola está vacía */ El prototipo de esta operación es bool C_Empty(COLA C); 6.2.3 Implementación de la cola usando listas enlazadas Una cola puede ser implementada utilizando listas enlazadas como se observa en la figura 6.4. En dicha lista se puede observar una estructura de encabezado donde se almacena la dirección del primer elemento de la cola (siguiente elemento a ser atendido) y el último de la cola (donde debe insertarse un nuevo elemento). c. c. b. b. a Figura 6.4. Implementación de la cola con listas enlazadas. Veamos como quedaría la estructura de datos: typedef struct s_nodo { ELEM info; 6. a.

(7) struct s_nodo *sig; } NODO; typedef struct s_enc { NODO *Primero; NODO *Ultimo; } ENCABEZADO; typedef ENCABEZADO *COLA; Note que cada elemento tiene asociado un nodo y que la estructura encabezado almacena las direcciones del primero y último elemento. La cola es un es un apuntador a encabezado. 6.2.4 Implementación de las operaciones primitivas COLA C_Crear () /* PRE: ninguna POST: Devuelve una cola vacía. */ { COLA aux; if ((aux = (COLA) malloc (sizeof (ENCABEZADO))) != NULL) { aux->Primero = NULL; aux->Ultimo = NULL; } return(aux); } void C_Destruir (COLA C) /* PRE: dada una cola creada POST: Libera el espacio de memoria ocupado por la cola */ { while !(C_Empty(C)) C=C_Remove(C); free(C); } COLA C_Remove(COLA C) /* PRE: dada una una cola creada no vacía POST: remueve el primer elemento de la cola */ { 7.

(8) NODO *aux; aux = C->Primero; C->Primero = C->Primero–>sig; free(aux); return(C); } COLA P_Insert(COLA C,ELEM e) /* PRE: dada una cola creada y un elemento POST: coloca el elemento como siguiente al último */ { NODO *aux; if ((aux=(NODO *)malloc(sizeof(NODO))) != NULL) { aux->info = e; aux->sig = NULL; C->Ultimo->sig = aux; C->Ultimo = aux; } return(C); } ELEM C_First(COLA C) /* PRE: dada una cola creada y no vacía POST: devuelve el elemento al comienzo de la cola */ { return (C->Primero->info); } bool C_Empty(COLA C) /* PRE: dada una cola creada POST: dice si la cola está vacía */ { return ((C->Primero == NULL)); }. 8.

(9)