Este documento presenta 12 ejercicios sobre estructuras de datos como pilas, colas, conjuntos y secuencias. Los ejercicios cubren temas como la implementación de operaciones básicas, la especificación de nuevos tipos abstractos de datos, y el diseño de algoritmos utilizando estas estructuras.

1. Ejercicios de
Estructuras de Datos
2012/2013
J. Lázaro

2. Pilas y Colas
Ejercicio 1.- Dar una implementación estática del TAD pila basada en un vector.
Ejercicio 2.- Extender la especificación de pilas vista en clase con las siguientes
operaciones:
• calcular el número de elementos de la pila (profundidad)
• consultar el elemento del fondo de la pila
• obtener la inversa de la pila
• concatenar dos pilas
Recordemos que la especificación de pila era la siguiente:
espec PILA[ELEM]
usa BOOLEANOS, NATURALES {NATURALES es para las operaciones nuevas}
parámetro formal
géneros elemento
fparámetro
géneros pila
operaciones
pvacía: -> pila
parcial cima: pila -> elemento
apilar: pila elemento -> pila
parcial desapilar: pila -> pila
vacía?: pila -> bool
var
x: elemento
p, q: pila
ecuaciones definitud
Def(desapilar(apilar(p,x)))
Def(cima(apilar(p,x)))
ecuaciones
cima(apilar(p,x)) = x
desapilar(apilar(p,x)) = p
vacía?(pvacía) = T
vacía?(apilar(p,x)) = F
fespec

3. En cuanto a las operaciones que se requieren:
operaciones
num_elem: pila -> natural
parcial fondo: pila -> elemento
inversa: pila -> pila
concatenar: pila pila -> pila
var
x,y:elemento; p: pila
ecuaciones
num_elem(pvacía) = 0
num_elem(apilar(p,x)) = suc(num_elem(p))
inversa(p) = inversa_aux(p,pvacía)
inversa_aux(pvacía,p) = p
inversa_aux(apilar(p,x),q) = inversa_aux(p,apilar(q,x))
fondo(p) = cima(inversa(p))
{
otra posibilidad sería tener las ecuaciones siguientes:
fondo(apilar(pvacía,x)) = x
vacía?(p)=F => fondo(apilar(p,x)) = fondo(p)
}
concatenar(pvacía,p) = p
concatenar(apilar(p,x),q) = apilar(concatenar(p,q),x)
fespec
Ejercicio 3.- Utilizando la representación del TAD vista en el ejercicio anterior, dar
la implementación en pseudocódigo de las operaciones:
● copiar, que devuelve una pila con igual contenido a la de entrada pero
utilizando posiciones de memoria diferentes
● anular, que libera de la memoria el espacio usado por la pila pasada como
argumento
Ejercicio 4.- Una secuencia es una estructura lineal con un punto de interés donde
se realizan las modificaciones y las consultas. Especificar el tipo de las secuencias,
representando una secuencia mediante un par de pilas, incluyendo las siguientes
operaciones:
● crear una secuencia vacía
● insertar un elemento delante del punto de interés
● eliminar un elemento en el punto de interés
● consultar un elemento en el punto de interés
● avanzar el punto de interés
● trasladar el punto de interés al comienzo de la secuencia
● determinar si el punto de interés se encuentra al final de la secuencia
● determinar si la secuencia es vacía

4. Ejercicio 5.- Una expresión aritmética construida con los operadores binarios +, -,
*, / y constantes (representadas cada uno por un carácter) se dice postfija si, o
bien es una única constante, o bien,consiste en dos expresiones de forma postfija
una tras otra, seguidas inmediatamente por un operador; por ejemplo, la expresión
(A/(B-C))*(D+E) se escribiría en forma postfija como ABC-/DE+*.
Diseñar un algoritmo que calcule el valor de una expresión dada en forma postfija,
suponiendo
● que la expresión viene dada mediante una secuencia (ver ejercicio 4),
● hay disponible una función valor que asocia a cada constante su valor
numérico,
● hay funciones que calculan el valor correspondiente a cada operador.
Ejercicio 6.- Implementar una función que compruebe si una sucesión de
paréntesis abiertos y cerrados está equilibrada, es decir, si a cada paréntesis
abierto le corresponde uno cerrado y además están bien anidados.
Ejercicio 7.- (Examen del Grado en Ingeniería Informática, Noviembre 2010)
Especificar el TAD colas de caracteres (se puede suponer que se tienen generadoras
constantes para todas las letras del alfabeto y una operación de orden ≤, pero el
resto de las posibles operaciones auxiliares hay que especificarlas), añadiendo
operaciones:
● concatenar dos colas de caracteres,
● mezclar alternativamente los elementos de dos colas de caracteres (no
tienen porqué tener necesariamente la misma longitud),
● quitar la primera mitad (redondeando la cantidad a la baja si es necesario)
de la cola,
● comprobar si la cola está ordenada alfabéticamente,
● ver si la cola representa una palabra, entendiendo por palabra una sucesión
de caracteres que no tiene dos vocales o dos consonantes seguidas.
espec COLA[CARACTERES]+
usa BOOLEANOS
parametro formal
generos caracter
operaciones
{ el enunciado permite suponer las generadoras y ≤ }
vocal?: caracter → bool
ecuaciones
vocal?(x) = (x eq A) ∨ (x eq E) ∨ (x eq I) ∨ (x eq O) ∨ (x eq U)
fparametro
generos cola

5. operaciones
cvacía: → cola
añadir: cola caracter → cola
parcial primero: cola → caracter
parcial eliminar: cola → cola
vacía?: cola → bool
concatenar: cola cola → cola
mezclar: cola cola → cola
mitad: cola → cola
ordenada?: cola → bool
palabra?: cola → bool
var x,y: caracter; c,c2: cola
ecuaciones de definitud
Def(primero(añadir(c,x)))
Def(eliminar(añadir(c,x)))
ecuaciones
primero(añadir(cvacía,x)) = x
vacía?(c)=F ⇒ primero(añadir(c,x)) = primero(c)
eliminar(añadir(cvacía,x)) = cvacía
vacía?(c)=F ⇒ eliminar(añadir(c,x)) = añadir(eliminar(c),x)
vacía?(cvacía) = T
vacía?(añadir(c,x)) = F
concatenar(c,cvacía) = c
concatenar(c,añadir(c2,x)) = añadir(concatenar(c,c2),x)
mezclar(c,cvacía) = c
vacía(c2)=F => mezclar(cvacía,c2) = c2
{si las dos colas tienen elementos, se coge el primero de cada una
de ellas, se pone en una cola aparte y se concatena con las colas
restantes}
(vacía?(c)=F) ∧ (vacía?(c2)=F) ⇒ mezclar(c, c2) =
concatenar(añadir(añadir(cvacía,primero(c1)),primero(c2)),
mezclar(eliminar(c),eliminar(c2)))
mitad(cvacía) = cvacía
mitad(añadir(c,x)) = añadir(mitad(eliminar(c),x))

6. {otra opción para quitar la mitad de elementos sería usar una
operación auxiliar quitar: cola nat → cola, junto con las
operaciones longitud de colas y división entera de naturales, que
habría que definir aparte, y las siguientes ecuaciones
quitar(c,0) = c
(n>0)=T ⇒ quitar(c,n) = quitar(eliminar(c),n-1)
mitad(c) = quitar(c, longitud(c) div 2)
}
ordenada?(cvacía) = T
ordenada?(añadir(cvacía,x)) = T
(x≤y)=T ⇒ ordenada?(añadir(añadir(c,x),y)) =
ordenada?(añadir(c,x))
(x≤y)=F ⇒ ordenada?(añadir(añadir(c,x),y)) = F
palabra?(cvacía) = T
palabra?(añadir(cvacía,x)) = T
(vocal?(x)=vocal?(y)) ⇒ palabra?(añadir(añadir(c,x),y)) = F
(vocal?(x)≠vocal?(y)) ⇒
palabra?(añadir(añadir(c,x),y)) = palabra?(añadir(c,x))
fespec
Ejercicio 8.- Extender la especificación de cola vista en teoría con las siguientes
operaciones:
● consultar el último elemento de la cola
● obtener la inversa de la cola
● concatenar dos colas, colocando la segunda a continuación de la primera.
Ejercicio 9.- Un sistema operativo recibe mensajes de los dispositivos conectados
al sistema. Dichos mensajes se dividen en dos categorías: críticos y no críticos. El
sistema operativo atiende primero a los mensajes críticos por orden de llegada (si
los hubiera) y, después, a los no críticos también por orden de llegada.
Especificar un TAD que gestione la cola de mensajes que disponga al menos de las
siguientes operaciones:
● crear una cola vacía
● añadir un nuevo elemento
● consultar el primer elemento
● consultar el número de mensajes críticos de la cola
● consultar el número de mensajes no críticos de la cola
● consultar si la cola está vacía
Diseñar una implementación de la cola de mensajes en pseudocódigo (en su
defecto en C++) empleando memoria dinámica.

7. Ejercicio 10.- (Examen del Grado en Ingeniería de Computadores, Noviembre
2011) Suponiendo disponibles las especificaciones COLA[ELEMENTO] y
PILA[ELEMENTO], se quiere crear un tipo nuevo colapila para la gestión de una cola
y una pila a la vez, de manera que todas las inserciones y eliminaciones de
elementos de una colapila se hagan en su parte de cola. Crear un TAD para colapila
con operaciones para
● crear una colapila,
● comprobar si una colapila tiene algún elemento,
● añadir un elemento a una colapila,
● quitar un elemento de una colapila,
● pasar la cola de la colapila a su parte de pila,
● pasar la pila de la colapila a su parte de cola, y
● vaciar completamente una colapila.
Ejercicio 11.- (Examen del Grado en Ingeniería Informática, Noviembre 2011) Dar
la especificación del TAD cola. Ampliar dicha especificación creando un tipo nuevo
doblecola para la gestión de dos colas a la vez, que permita las operaciones
● descomponer : cola → doblecola, que pone los elementos que hay en una
cola repartiéndoles de manera alterna en una doblecola, y
● mezclar : doblecola → cola, que mezcla alternativamente los elementos de
una doblecola en una única cola.
Implementar en pseudo-código tanto los tipos necesarios para la especificación
ampliada como las operaciones nuevas.
Ejercicio 12.- (Examen del Grado en Ingeniería Informática, Noviembre 2011) Se
conoce el TAD conjunto de elemento con las siguientes operaciones:
● Ø: → conjunto
● insertar: conjunto elemento → conjunto
● borrar: conjunto elemento → conjunto
● está?: conjunto elemento → bool
así como la especificación PILAS[CONJUNTO[ELEMENTO]]. Añadir operaciones para:
● comprobar si un elemento está en todos los conjuntos de la pila,
● comprobar si todos los conjuntos de la pila tienen, al menos, los mismos
elementos que el conjunto de la cima,
● quitar un elemento de todos los conjuntos de la pila,
● crear un único conjunto con todos los elementos de los conjuntos de la pila,
● quitar todos los conjuntos vacíos de la pila.