Solución práctico 6 Tipos Abstractos de Datos Lista, Pila y Cola

Transcripción

1 Objetivos Trabajar sobre el Tipo Abstracto de Datos Lista, reforzando el desacople entre especificación e implementación. Retomar las implementaciones vistas, como ser Listas Doblemente Encadenadas, Listas Circulares y Listas Indizadas, estudiando las ventajas y desventajas de cada una de ellas. Trabajar con tipos abstractos de datos que son variantes de listas, tales como Pilas y Colas, que restringen las políticas de inserción, supresión y obtención de elementos. Desarrollar y analizar implementaciones de Pilas y Colas que sean eficientes. Resolver problemas complejos usando Listas, Pilas y Colas. Aplicar el concepto de Orden de ejecución visto en el práctico 5, implementando soluciones que satisfagan restricciones dadas. Primera parte: TAD Lista - especificaciones e implementaciones. Ejercicio 1 Considere el siguiente conjunto de operaciones que especifican al TAD Lista no ordenada de naturales. /* Crea la lista vacia. */ LNat null (); /* Inserta el natural x al principio de la lista. */ LNat cons ( unsigned int x, LNat l); /* Verifica si la lista esta vacia. */ bool isempty ( LNat l); /* Devuelve el primer elemento de una lista. Pre :! isempty (l) */ unsigned int head ( LNat l); /* Devuelve el resto de una lista. Pre :! isempty (l) */ LNat tail ( LNat l); (a) Utilizando sólo las operaciones presentadas implemente las siguientes operaciones: 1

2 i. LNat change(unsigned int x, unsigned int y, LNat l); /* Retorna la lista resultado de cambiar el valor x (cada vez que aparece) por el valor y en la lista l. */ ii. LNat take(unsigned int i, LNat l); /* Retorna la lista resultado de tomar los primeros i elementos. Si la lista l tiene menos de i elementos devuelve todos los elementos de l. */ iii. LNat drop(unsigned int i, LNat l); /* Retorna la lista resultado de no tomar los primeros i elementos. Si la lista l tiene i o menos de i elementos devuelve la lista vacía. */ iv. LNat append(lnat l, LNat p); /* Agrega la lista p al final de la lista l. */ v. unsigned int ith(lnat l, unsigned int i); /* Devuelve el elemento en la posición i-ésima de l. Precondición: la lista l tiene al menos i elementos. */ vi. LNat snoc(unsigned int x, LNat l); /* Inserta un elemento al final de la lista. */ (b) Qué precauciones debe tomar al implementar las operaciones de la parte (a) para que éstas no tengan efectos secundarios sobre las estructuras pasadas por parámetro? (c) Dé una implementación para el TAD de la parte (a) que garantice la ejecución de las operaciones cons y snoc en O(1). Implemente el TAD completo (tipo y operaciones). (d) Qué cambios realizaría en la especificación si se pidiera especificar el TAD Lista ordenada? Ejercicio 2 Considere ahora el siguiente conjunto de operaciones que especifican al TAD Lista indizada de naturales con manejo explícito de posiciones. /* Crea la lista vacia. */ LNat null (); /* Verifica si la lista esta vacia. */ bool isempty ( LNat l); /* Dado un natural p, retorna TRUE si, y solamente si, la lista esta definida en la posicion p, considerando a las posiciones a partir de 0. */ bool isdefined ( unsigned int p, LNat l); /* Inserta un elemento x en la posicion p de la lista, considerando a las posiciones a partir de 0. Si la lista tiene longitud m, con m -1 menor a p, lo inserta en la posicion m. Si la lista tiene longitud m, con m -1 mayor o igual a p, inserta x en la posicion p y desplaza en una posicion los elementos que estuvieran en las posiciones siguientes. */ LNat insert ( unsigned int x, unsigned int p, LNat l); /* Retorna el elemento en la posicion p de l, si p esta definida en l. */ unsigned int element ( unsigned int p, LNat l); /* Dado un entero p, elimina de la lista el elemento en la posicion p. Si la posicion no esta definida, la operacion no tiene efecto. Si la posicion esta definida, elimina el elemento en dicha posicion y desplaza en una posicion los elementos que estuvieran en las posiciones siguientes ( contrae la lista ). */ LNat delete ( unsigned int p, LNat l); (a) Utilizando sólo las operaciones presentadas implemente las siguientes operaciones: i. LNat change(unsigned int x, unsigned int y, LNat l); /* Retorna la lista resultado de cambiar el valor x (cada vez que aparece) por el valor y en la lista l. */ Instituto de Computación - Facultad de Ingeniería - UdelaR Página 2 de 10

3 ii. LNat take(unsigned int i, LNat l); /* Retorna la lista resultado de tomar los primeros i elementos. Si la lista l tiene menos de i elementos devuelve todos los elementos de l. */ iii. LNat drop(unsigned int i, LNat l); /* Retorna la lista resultado de no tomar los primeros i elementos. Si la lista l tiene i o menos de i elementos devuelve la lista vacía. */ iv. LNat append(lnat l, LNat p); /* Agrega la lista p al final de la lista l. */ v. unsigned int ith(lnat l, unsigned int i); /* Devuelve el elemento en la posición i-ésima de l. Pre: la lista l tiene al menos i elementos. */ (b) Compare sus soluciones con las de la parte (a) del ejercicio 1. i. Es necesario tener las mismas precauciones que en el ejercicio 1 para evitar efectos secundarios? Por qué? ii. La implementación de la función ith y sus precondiciones es más sencilla? Por qué? (c) Qué implementación elegiría que garantice la ejecución de la operación isdefined en O(1)? Solución propuesta Parte a 1 LNat change ( unsigned int x, unsigned int y, LNat l) { 2 /* Retorna la lista resultado de cambiar el valor x ( cada vez que aparece ) 3 por el valor y en la lista l. */ 4 { 5 LNat result = null (); 6 if (! isempty (l)) { 7 int i = 0; 8 while isdefined (i, l) { 9 if ( element (i, l) == x) { 10 result = insert (y, i, result ); 11 } else { 12 result = insert ( element (i, l), i, result ); 13 } 14 i ++; 15 } 16 } 17 return result ; 18 } 1 /* Retorna la lista resultado de tomar los primeros i elementos. Si la lista l tiene 2 menos de i elementos devuelve todos los elementos de l. */ 3 LNat take ( unsigned int i, LNat l) { 4 LNat result = null (); 5 if (! isempty (l)) { 6 int j = 0; 7 while ((j < i) && isdefined (j, l)) { 8 /* la posicion inicial es 0 */ 9 /* toma todos los elementos entre 0 e i -1 */ 10 result = insert ( element (j, l), j, result ); 11 j ++; 12 } 13 } 14 return result ; 15 } Instituto de Computación - Facultad de Ingeniería - UdelaR Página 3 de 10

4 1 /* Retorna la lista resultado de no tomar los primeros i elementos. Si la lista l 2 tiene i o menos de i elementos devuelve la lista vac \ ia. */ 3 LNat drop ( unsigned int i, LNat l) { 4 5 LNat result = null (); 6 unsigned int j = 0; 7 unsigned int k = i; 8 /* ignora las posiciones entre 0 e i -1 */ 9 while isdefined (k, l) { 10 result = insert ( element (k, l), j, result ); 11 j ++; 12 k ++; 13 }; return result ; 16 } 1 /* Agrega la lista p al final de la lista l. */ 2 LNat append ( LNat l, LNat p) { 3 LNat result = null (); 4 unsigned int i = 0; 5 while isdefined (i, l) { 6 result = insert ( element (i, l), i, result ); 7 i ++; 8 }; 9 unsigned int j = 0; 10 while isdefined (j, p) { 11 result = insert ( element (j, p), i, result ); 12 i ++; 13 j ++; 14 }; 15 return result ; 16 } 1 /* Devuelve el elemento en la posicion i- esima de l. 2 Pre : la lista l tiene al menos i elementos. */ 3 unsigned int ith ( LNat l, unsigned int i) { 4 return element (i, l); 5 } Parte b I No es necesario tener las mismas precauciones, porque se tiene una posición que permite acceder al elemento buscado sin posibilidad de menoscabar la estructura recorrida. Parte b II La implementación es más sencilla en este caso porque puedo acceder directamente a la posición i con una de las operaciones definidas. Sin embargo la precondición es la misma para ambos casos porque la posición i siempre debe estar definida. Parte c Se debería elegir una implementación donde la representación de lista tenga un cabezal que tenga la cantidad de elementos insertados. De esta forma solo se debe consultar el cabezal y no recorrer la lista para saber si una posición está definida. Segunda parte: TAD Pila y Cola - especificaciones e implementaciones. Instituto de Computación - Facultad de Ingeniería - UdelaR Página 4 de 10

5 Ejercicio 3 (a) Escribir un módulo de especificación para el TAD Pila (Stack) no acotada de naturales, conteniendo un conjunto mínimo de constructores, selectores, predicados y destructores. Desarrolle una especificación funcional (compuesta por funciones, no procedural). (b) Desarrolle una implementación completa de tal manera que todas las operaciones, excepto aquella que oficia de destructora, tengan O(1) de tiempo de ejecución en el peor caso. (c) Qué modificaría en la especificación para el TAD Pila (Stack) acotada de naturales? (d) Desarrolle una implementación completa usando una estructura de memoria estática y otra usando una estructura de memoria dinámica, de tal manera que todas las operaciones tengan O(1) de tiempo de ejecución en el peor caso. Analice las eventuales ventajas y desventajas de ambas implementaciones. Solución propuesta Parte a Es conveniente recordar que las operaciones pueden clasificarse de la siguiente forma: Constructoras: permiten construir los elementos del TAD. Selectoras: permiten obtener partes de elementos del TAD, por ejemplo, el primer elemento de una lista. Predicados: permiten saber si un cierto elemento del TAD cumple con cierta propiedad, por ejemplo, si un árbol es vacío. Destructoras: permiten destruir los elementos del TAD. 1 /* CONSTRUCTORAS */ 2 StackNat NullStack (); 3 /* Crea la pila vacia. */ 4 5 StackNat Push ( unsigned int x; s: StackNat ); 6 /* Inserta un elemento al principio ( tope ) de la pila. */ /* SELECTORAS */ 10 unsigned int Top ( s: StackNat ); 11 /* Devuelve el primer elemento de la pila. 12 Pre :! IsEmptyStack (s) */ StackNat Pop ( s: StackNat ); 15 /* Devuelve la pila sin su primer elemento. 16 Pre :! IsEmptyStack (s) */ /* PREDICADO */ 20 bool IsEmptyStack ( s: StackNat ); 21 /* Verifica si la pila esta vacia. */ Instituto de Computación - Facultad de Ingeniería - UdelaR Página 5 de 10

6 Parte b struct nodo { 4 unsigned int elem ; 5 nodo * sig ; 6 }; typedef nodo * StackNat ; 11 /* CONSTRUCTORAS */ 12 StackNat NullStack () { 13 return NULL ; 14 } StackNat Push ( unsigned int x; StackNat s) { 18 StackNat nuevo = new nodo ; 19 nuevo - > elem = x; 20 nuevo -> sig = s; return nuevo ; 23 } /* SELECTORAS */ 27 unsigned int Top ( StackNat s) { 28 return s -> elem ; 29 } StackNat Pop ( StackNat s) { 32 StackNat borrar = s; 33 StackNat res = s -> sig ; 34 delete borrar ; return res ; 37 } /* PREDICADO */ 41 bool IsEmptyStack ( StackNat s) { 42 return s == NULL ; 43 } Notar que si bien la operacion Pop tiene O(1), en caso de querer implementar un procedimiento DestruirPila que libere todos los elementos, este tendra O(n) con n la cantidad de elementos de la pila. Este procedimiento se puede implementar usando la operación Pop. Instituto de Computación - Facultad de Ingeniería - UdelaR Página 6 de 10

7 Parte c Como en la pila se puede almacenar solo un número acotado de elementos, se debe agregar un predicado que permita verificar si una pila está llena (IsFullStack). Además se debe agregar a la operación de Push la precondición de que la pila no esté llena. 1 /* CONSTRUCTORAS */ 2 StackNat NullStack ( unsigned int capacidad ); 3 /* Crea la pila vacia que puede almacenar hasta capacidad elementos. */ 4 5 StackNat Push ( unsigned int x, StackNat s); 6 /* Inserta un elemento al principio ( tope ) de la pila. 7 Pre :! IsFullStack (c) */ /* SELECTORAS */ 11 unsigned int Top ( StackNat s); 12 /* Devuelve el primer elemento de la pila. 13 Pre :! IsEmptyStack (s) */ void Pop ( StackNat s); 16 /* Devuelve la pila sin su primer elemento. 17 Pre :! IsEmptyStack (s) */ /* PREDICADO */ 21 bool IsEmptyStack ( StackNat s); 22 /* Verifica si la pila esta vacia. */ bool IsFullStack ( StackNat s); 25 /* Verifica si la pila esta llena. */ Instituto de Computación - Facultad de Ingeniería - UdelaR Página 7 de 10

8 Parte d Se hará la implementacion de una pila con una estructura de memoria estática. La implementación con estructura dinámica sigue como ejercicio para el lector. Respecto a la pregunta, la ventaja de hacerlo con una estructura dinámica es la usual, el mejor aprovechamiento de la memoria. La ventaja de la estructura estática es la mayor rapidez en las operaciones, salvo en la de crear la pila. 1 2 struct StackNodos { 3 unsigned int * elems ; 4 unsigned int capacidad ; 5 unsigned int tope ; 6 }; 7 8 typedef StackNodos * StackNat ; /* CONSTRUCTORAS */ 12 StackNat NullStack ( unsigned int capacidad ) { 13 StackNat pila = new StackNodos ; 14 pila - > capacidad = capacidad ; 15 pila -> tope = 0; 16 pila - > elems = new unsigned int [ tamanio ]; return pila ; 19 } StackNat Push ( unsigned int x, StackNat s) { 22 (s- > cantidad )++; 23 s- > elems [s- > cantidad - 1] = x; 24 } /* SELECTORAS */ 28 unsigned int Top ( StackNat s) { 29 return s- > elems [s- > cantidad - 1]; 30 } void Pop ( s: StackNat ) { 33 (s-> cantidad )--; 34 } /* PREDICADOS */ 38 bool IsEmptyStack ( StackNat s) { 39 return (s- > cantidad == 0); 40 } bool IsFullStack ( StackNat s) { 43 return (s- > cantidad == s- > tamanio ); 44 } Instituto de Computación - Facultad de Ingeniería - UdelaR Página 8 de 10

9 Tercera parte: Aplicaciones. Ejercicio 4 Dada una expresión en notación infija, compuesta de operadores binarios + y *, números naturales y paréntesis, se pide: (a) Escribir un procedimiento que transforme la expresión a su representación en notación posfija. Para realizar esta operación use una Pila de caracteres en donde ir colocando los operadores (según su orden de precedencia). La expresión de entrada es una lista de caracteres. La expresión de salida será una lista de operadores y operandos representando la expresión posfija. Asuma que las expresiones de entrada son sintácticamente correctas. Ejemplos: Expresión infija de entrada: 10 * Expresión posfija equivalente: 10 5 * 3 + Expresión infija de entrada: 10 * ( ) Expresión posfija equivalente: * Expresión infija de entrada: * 3 Expresión posfija equivalente: * + Expresión infija de entrada: ( ) * 3 Expresión posfija equivalente: * Expresión infija de entrada: ( * ) * 3 Expresión posfija equivalente: * * (b) Evaluar la expresión en notación posfija. Para realizar esta operación use una Pila donde ir colocando los operandos. Escribir a tales efectos un procedimiento que reciba la expresión a evaluar (lista de operadores y operandos) y retorne un número natural. Análisis Tenga presente que en la notación posfija, no se usan paréntesis por no ser necesarios, por lo que la lista solución no tendrá paréntesis. Para implementar la solución necesitaremos dos estructuras, una pila para guardar los operadores y una lista de caracteres, que es la lista resultado. Como entrada hay una lista con la expresión leída de izquierda a derecha. A continuación se dará un conjunto de reglas para cada caso, que ameritan reflexión y la realización de varios ejemplos para ver por qué funcionan: Si el elemento de la lista procesado es un operando, es sencillo, se debe insertar al final de la lista resultado. Cuando se lee un operador (+, *, ( o )) hay que atender varias situaciones, ya que la inserción o no en la pila y en la lista resultado depende del contenido de la pila y de la precedencia que tienen los operadores entre si, partiendo de que + tiene menor precedencia que *. Cuando se lee un operador y en el tope de la pila hay un operador de menor precedencia el operador leido se agrega a la pila. Salvo para el caso de ) que nunca se agrega a la pila, sino que se avanza en el resultado hasta sacar un ( de la pila. Avanzar en el resultado significa ir sacando elementos del tope de la pila y agregarlos al final de la lista resultado. Leer el operador ( también es un caso especial, en el sentido que siempre se agrega a la pila. Instituto de Computación - Facultad de Ingeniería - UdelaR Página 9 de 10

10 Cuando el elemento del tope de la pila tiene mayor o igual precedencia que el elemento procesado, se va avanzando en el resultado hasta encontrar un elemento de menor precedencia en la pila o un (, que se dejará en la pila y se apilará el operador leido. Si la pila es vacía se apila el operador leído. Y finalmente si ya se terminó de leer la entrada y quedan elementos en la pila, se avanza en la resultado hasta que la pila quede vacía. Tenga en cuenta que si se quieren agregar los operadores / y -, al / se le debe asignar igual precedencia que a * y al - igual precedencia que al +. En resumen en pseudocódigo sería: 1 Entrada : lstent // la lista de entrada 2 Salida : lstsol // la lista resultado 3 lstsol = vacia 4 pila_aux = vacia 5 mientras ( no_vacia ( lstent )) { 6 c = primero ( lstent ); 7 lstent = resto ( lstent ) 8 si esoperando ( c) { 9 agregar_al_final (c, lstsol ); 10 } sino { // es operador 11 si esvacia ( pila_aux ) { 12 push (c, pila_aux ); 13 } sino si es ")" { 14 // avanzar en el resultado hasta quitar un ( de la pila 15 } sino si es "(" { 16 push (c, lstsol ); 17 } sino si esmenorprecedencia ( tope ( pila_aux ), c) { 18 push (c, pila_aux ); 19 } sino { // la precedencia es igual o mayor 20 // avanzar en la pila hasta encontrar un elemento de menor precedencia que c, 21 // sea vacia, o encuntrar un "(". Todos los elementos removidos se van 22 // colocando al final de la lista push (c, pila_aux ); // finalmente colocar el elemento leido en la pila 25 } 26 } 27 } 28 retornar lstsol También notar que tiene O(n) de ejecución con n la cantidad de elementos de la entrada y solo es necesario hacer una pasada por la lista. Parte b Para evaluar una expresión solo se precisa una pila como estructura auxiliar. La idea general es leer la expresión de izquierda a derecha, ir guardando los operadores en la pila, y cada vez que se lee un operando, se lo aplica a dos operandos de la pila y se hace push del resultado en la pila. Para más información ver: Data Structures and Algoritm Analysis in C, Mark Allen Weiss, p. 72 (Postfix Expressions). Instituto de Computación - Facultad de Ingeniería - UdelaR Página 10 de 10