Estructuras de Datos y Algoritmos (ITIS)

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
Estructuras de Datos y Algoritmos (ITIS)
Ingeniería Técnica en Informática de Sistemas, Curso 2º
PRÁCTICA 2
TAD LINEALES
SIMULACIÓN DE UN CENTRO DE INFORMACIÓN
Las colas pueden utilizarse para modelar líneas de espera (colas de espera). De hecho, la teoría de
colas es un área tan importante en informática, investigación operativa y matemática aplicada que
existe una extensa bibliografía dedicada a ella. Por ejemplo, en un contexto de sistemas operativos, las
colas de espera se forman cuando más de un proceso necesita un recurso (impresora, disco, CPU, etc.).
Cuando los procesos piden un recurso, se colocan en una cola esperando ser atendidos por dicho
recurso. También, las colas se pueden utilizar para planificar las tareas mientras van pasando por
diferentes estados en el scheduler del sistema operativo. Es preciso destacar que en los schedulers
actuales la cola de procesos listos no es simplemente una cola FIFO, sino que se utiliza una
planificación más sofisticada donde los procesos tienen asignada una prioridad (que puede cambiar
dinámicamente), y que pare ello se suelen utilizar colas de prioridad.
La mayoría de las líneas de espera son dinámicas, es decir, sus longitudes cambian en el tiempo,
creciendo cuando llegan nuevos elementos y se añaden a las colas, y disminuyendo cuando se eliminan
elementos de las colas y son atendidos. El término simulación se refiere al modelado de este proceso
dinámico y la utilización de este modelo para estudiar el comportamiento de un proceso determinado.
El comportamiento de algunos procesos deterministas puede ser modelado con una ecuación o un
conjunto de ecuaciones. Por ejemplo, los procesos que tienen un crecimiento o decrecimiento
exponencial se modelan comúnmente mediante una ecuación de la forma A(t) = A 0 e kt , donde A(t) es la
cantidad de algún elemento A presente en el instante de tiempo t, A 0 es la cantidad inicial de este
elemento y k es una constante.
Sin embargo, en muchos problemas, el proceso en estudio tiene cierta aleatoriedad; por ejemplo, la
llegada de aviones a un aeropuerto, el número de piezas defectuosas manufacturadas por una máquina,
una fila de personas esperando para pagar en un determinado establecimiento (supermercado,
gasolinera, peaje, etc.), etc. Por ejemplo, las colas utilizan para modelar filas de espera que se producen
en una determinada operación de un sistema informático. Los programas que simulan tales procesos
utilizan un generador de números aleatorios para introducir aleatoriedad en los valores generados
durante la ejecución. Ésta es una función que genera un número seleccionado aleatoriamente de entre
un rango fijo, de tal manera que una secuencia de estos números se distribuye uniformemente en el
rango dado. Aunque los números realmente aleatorios se generan con procesos aleatorios físicos,
algunas fórmulas matemáticas generan secuencias de números pseudoaleatorios que son adecuados en
la mayoría de las situaciones.
Página 1

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
El comportamiento de una cola también conlleva cierta aleatoriedad, porque generalmente no se
conoce de antemano cuándo llegará exactamente un nuevo elemento o cuánto tiempo se necesitará para
servir a un elemento especificado. Como caso de estudio e implementación en esta práctica,
consideramos el funcionamiento de un centro de información y reservas que atiende llamadas gratuitas
hechas por clientes, como las proporcionadas por compañías aéreas o de alquiler de coches. Cuando
llega una llamada a este centro, se coloca en una cola de llamadas entrantes; cuando un agente se
encuentra libre, atiende la llamada al comienzo de la cola.
Análisis y especificación del problema
La simulación debería proceder de la siguiente manera. Un cronómetro descendente simulado se
inicializa con los minutos en los que se aceptarán llamadas y repetidamente se va decrementando de
uno en uno hasta que llegue a cero. En cada tic del reloj se comprueba si ya se ha terminado el servicio
de la llamada actual, y si es así, se elimina de la cola de llamadas entrantes y se comienza el servicio
simulado de la siguiente llamada en la cola (si hay alguna). También se comprueba si ha llegado una
nueva llamada. Si es así, se almacena su tiempo de llegada, se genera un tiempo de servicio aleatorio y
se almacena, y la llamada se coloca en la cola para que sea procesada de la forma primero-en-llegarprimero-en-ser-servido
(FIFO, First-In-First-Out) cuando un agente se libera. Cuando el contador llega
a cero, no se aceptan nuevas llamadas, pero el servicio continúa hasta que todas las llamadas de la cola
sean procesadas.
Como hemos indicado anteriormente, la simulación se realiza para un periodo de tiempo
especificado, por lo que un dato de entrada será un tiempo límite. Ya que hay que simular la llegada y
el servicio de llamadas, también se necesita información sobre la tasa de llegadas y los tiempos de
servicio. Por tanto, la entrada tendrá el siguiente formato:
Entrada:
Tiempo límite
Tasa de llegada de llamadas
Distribución de los tiempos de servicio
Cuando se complete la simulación, deben ofrecerse estadísticas que midan el rendimiento del centro de
información. Aquí mostraremos sólo dos de dichas estadísticas:
Salida:
Número de llamadas procesadas
Tiempo medio de espera por llamada
Construcción de una clase CSimulacion
Atributos. Los tres datos de entrada y los dos de salida son los valores básicos involucrados en la
simulación. Un objeto de la clase CSimulacion almacenará estos cinco valores en sus atributos.
El primer atributo, miLongitudSimulacion, almacena el tiempo límite de la simulación. El valor
del segundo atributo, miTasaLlegadas, es la probabilidad de que llegue una llamada en un minuto
dado. Por ejemplo, si el tiempo medio entre llamadas es de cinco minutos, entonces la tasa de llegadas
es 1/5 = 0,2 llamadas por minuto. El tercer atributo es un vector miPorcentajeServicios, que
almacena información sobre el tiempo necesario para atender una llamada:
miPorcentajeServicios [0] = porcentaje de llamadas atendidas en 1 minuto o menos
Página 2

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
miPorcentaj eServicios [1] = porcentaje de llamadas atendidas en 2 minutos o menos
miPorcentajeServicios[2] = porcentaje de llamadas atendidas en 3 minutos o menos
En nuestra clase CSimulacion, utilizaremos NUM_CATEGORIAS = 5 categorías de tiempos necesarios
para atender una llamada entrante. El usuario introduce los porcentajes de llamadas que requieren 1, 2,
3, 4 o 5 minutos, y éstos son acumulados para obtener los valores de miPorcentajeServicios. Por
ejemplo, si el usuario introduce 50, 25, 15, 7 y 3, los valores almacenados en el vector
miPorcentajeServicios son 50, 75 (= 50 + 25), 90 (= 50 + 25 + 15), 97 (= 50 + 25 + 15 + 7) y 100
(la suma de todos los porcentajes):
[0] [1] [2] [3] [4]
miPorcentajeServicios 50 75 90 97 100
Otros atributos necesarios serán un cronómetro descendente miCrono de tipo CReloj, una clase que
describiremos más adelante, y una cola misLlamadasEntrantes de llamadas entrantes. Utilizaremos el
TAD genérico queue de la STL de C++ para implementar la cola de llamadas, y su tipo de elementos
será CLlamada, una clase para modelar llamadas que describiremos más adelante. La declaración de la
cola será de la siguiente manera: queue misLlamadasEntrantes;
A continuación mostraremos la estructura de la clase CSimulacion con estos atributos y operaciones
básicas en el archivo cabecera. Las operaciones básicas necesarias para realizar la simulación son:
constructor: construye un objeto de la clase CSimulacion, ejecutar(): lleva a cabo la simulación
(ejecutar la simulación), comprobarLlamadasNuevas(): comprueba si ha llegado una llamada nueva
(requerirá comprobar si han llegado llamadas nuevas), atender(): atiende una llamada entrante
(servicio de llamadas entrantes), y mostrar(): muestra los resultados de la simulación (mostrará los
resultados cuando termine la simulación).
La clase CSimulacion:
// CSimulacion.h
#include // istream, ostream, >>,

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
int miLongitudSimulacion;
double miTasaLlegadas;
int miPorcentajeServicios[NUM_CATEGORIAS];
int misLlamadasRecibidas;
double miTiempoTotalEspera;
CReloj miReloj;
};
queue misLlamadasEntrantes;
#endif
Constructor. El constructor de la clase CSimulacion inicializa los atributos necesarios para realizar la
simulación y generar los resultados. Los tres atributos de entrada se inicializan en el constructor
utilizando valores introducidos durante la ejecución. Los dos atributos de salida,
misLlamadasRecibidas y miTiempoEsperaTotal, almacenan los valores necesarios cuando se
produce la salida de los resultados y se inicializan a 0. Los otros dos atributos, miReloj y
misLlamadasEntrantes, son objetos de tipo CReloj y queue, respectivamente, y son inicializados por
sus constructores. El constructor también inicializa el generador de números aleatorios rand()
proporcionado por la librería , utilizando srand() de la misma librería y la hora del reloj
obtenida desde .
El método ejecutar(). El método ejecutar() de la clase CSimulacion es la operación que inicia y
controla la simulación. Implementa el siguiente algoritmo:
Algoritmo para ejecutar la simulación
1. Inicializa tiempoEsperaRestante a 0, haciendo el servicio disponible para la primera llamada
entrante. Esta variable indica en cada momento de la simulación, cuánto tiempo tiene que pasar
hasta que se atienda una nueva llamada.
2. Mientras miReloj no haya terminado:
a. Continuar el servicio de la llamada anterior o comenzar el servicio de la siguiente
llamada en la cola misLlamadasEntrantes (si hay alguna).
b. Comprobar si ha llegado una nueva llamada y, si es así, añadirla a la cola
misLlamadasEntrantes.
c. Hacer que miReloj avance una unidad de tiempo.
3. Mientras queden llamadas pendientes en la cola,
a. Atender la llamada al frente de la cola.
b. Hacer que miReloj avance una unidad de tiempo.
4. Mostrar los resultados.
Los pasos 2a y 3a los realiza el método atender(); el paso 2b comprobarLlamadasNuevas(); los
pasos 2c y 3b se consiguen enviando un mensaje a miReloj utilizando su método tic(); y el paso 4
mostrar().
El método atender(). El método atender() de la clase CSimulacion atiende cada llamada al llegar
al frente de la cola misLlamadasEntrantes. Implementa el siguiente algoritmo:
Página 4

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
Algoritmo para atender una llamada
Comprobar si tiempoEsperaRestante > 0. Si es así, esto significa que se está atendiendo una
llamada actualmente, por lo que sólo se decrementa tiempoEsperaRestante en 1 para indicar
que la llamada ha sido atendida durante otro minuto.
En otro caso, hacer lo siguiente:
Si la cola misLlamadasEntrantes no está vacía:
a. Obtener y eliminar siguienteLlamada del frente de misLlamadasEntrantes.
b. Hacer tiempoEsperaRestante = el tiempo de servicio de siguienteLlamada para
indicar que el servicio de esta llamada comienza.
c. Actualizar miTiempoEsperaTotal, el tiempo de espera total para todas las
llamadas de la cola misLlamadasEntrantes, sumándole (tiempo de llegada de
siguienteLlamada) - (tiempo restante de miReloj).
El método comprobarLlamadasNuevas(). A continuación mostramos el algoritmo que debe
implementarse para este método:
Algoritmo para comprobar la llegada de una nueva llamada
1. Generar un entero aleatorio x en el rango de 0 a 100.
2. Si x < 100 * miTasaLlegadas
// Esto se interpreta como la llegada de una nueva llamada:
Llega una
llamada
No llegan
llamadas
t
0 20 100
a. Generar un nuevo número aleatorio r en el rango de 0 a 100. Se utilizará para determinar
el tiempo de servicio de la llamada.
b. Determinar la categoría de servicios correspondiente, encontrando el menor índice i para
el cual r

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
intervalo (0, 100); el subintervalo en el que cae (0,50], (50, 75], (75, 90], (90, 97] o (97, 100] determina
el tiempo de servicio de la llamada:
Tiempo de
servicio
1
2 3 4 5
t
0 50 75 90 97 100
El método mostrar(). Al finalizar la simulación, se muestran el número total de llamadas procesadas
o atendidas y el tiempo medio de espera por llamada. El número de llamadas se almacena en el atributo
misLlamadasRecibidas, y la espera media puede calcularse dividiendo miTiempoEsperaTotal por
misLlamadasRecibidas.
Las clases CReloj y CLlamada
Otro objeto de la simulación es el cronómetro descendente, modelado por la clase CReloj cuyas
operaciones básicas son las siguientes:
constructor: construye un objeto CReloj con un tiempo inicial especificado (por defecto 0
minutos)
encender(): modificador para encender/apagar el reloj
tic(): decrementa el cronómetro en una unidad de tiempo
tiempoRestante(): determina cuánto tiempo falta
Sólo tiene un atributo (misMinutos).
//* CReloj.h
#ifndef CRELOJ_H
#define CRELOJ_H
class CReloj
{
public:
CReloj (int tiempoInicial = 0);
void encender(int minutos);
void tic();
int tiempoRestante() const;
private:
int misMinutos;
};
#endif
Otro objeto es una llamada al centro de información, modelada por la clase CLlamada con las
siguientes operaciones básicas:
constructor: construye un objeto CLlamada inicializado con un tiempo de llegada y de servio
determinados aleatoriamente (por defecto 0)
obtenerTiempoLlegada(): operación observadora para obtener el tiempo de llegada
obtenerTiempoServicio(): obtiene el tiempo necesario para atender la llamada
mostrar(): muestra la información de la llamada
Página 6

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
Ejercicios prácticos relacionados con TAD Lineales.
1. Ejercicio con pilas. Evaluación de expresiones postfijas (RPN, Reverse Polish Notation, Notación
Polaca Invertida). La mayoría de los lenguajes de programación, las expresiones aritméticas se escriben
en notación infija (por ejemplo, a * b + c – d), en la que los símbolos de las operaciones binarias se
colocan entre los operandos. Muchos compiladores transforman primero estas expresiones infijas en
notación postfija, en la que el operador sigue a los operandos, y a continuación generan instrucciones
máquina para evaluar estas expresiones postfijas. Se utiliza este proceso de dos pasos porque la
transformación de notación infija a postfija es inmediata y las expresiones postfijas, en general, son
más sencillas de evaluar que las expresiones infijas. Además, para las expresiones en notación infija, a
menudo se necesitan paréntesis para señalar el orden de las operaciones (teniendo en cuenta las reglas
de precedencia habituales). Para la notación postfija los paréntesis no son necesarios. Por ejemplos, la
expresión infija 2*(3+4) se puede escribir en notación postfija como 234+*.
Como ejemplo de cómo se evalúan las expresiones postfijas, veámoslo con un ejemplo. 15+841--*
(equivalente a (1+5)*(8 – (4 – 1)) en infija). Dicha expresión se lee de izquierda a derecha hasta que se
encuentra a un operador. En este momento, se combinan los dos operandos anteriores utilizando dicho
operador. 15+841--* ⇔ 6841--* ⇔ 683-* ⇔ 683-* ⇔ 65* ⇔ 30.
Este método de evaluación de una expresión postfija requiere que los operandos se almacenen hasta
que se encuentre un operador durante la lectura de izquierda a derecha. En este momento, se recuperan
los dos últimos operandos y se combinan utilizando el operador. Lo que sugiere el uso de una pila para
guardar los operandos. Cada vez que se encuentra un operando, se apila. Y cuando se encuentra un
operador los dos valores superiores se desapilan; la operación se aplica sobre ellos y el resultado se
vuelve a apilar. El siguiente algoritmo resume este procedimiento:
// Escribir una expresión postfija (en un string) y devolver su valor a menos que ocurra un error
// Utilizar una pila para almacenar los operandos
1. Crear una pila vacía
2. Repetir lo siguiente hasta que se encuentre el final de la expresión
2.1. Obtener el siguiente elemento (constante, variable, operador aritmético) de la expresión
postfija
2.2. Si el elemento es un operando, apilarlo en la pila. Si es un operador, hacer lo siguiente
2.2.1. Desapilar dos valores de la pila (si la pila no contiene dos valores, se tiene un
error debido a que la expresión postfija estaba mal formada y se termina la evaluación
2.2.2. Aplicar el operador a estos dos valores
2.2.3. Apilar el resultado
3. Cuando se llegue al final de la expresión, su valore se encontrará en la cima de la pila. En
realidad, debe ser el último valor en la pila, y si no lo es, se ha producido un error debido a que la
expresión postfija estaba mal formada
Se pide: implementar en C++ el anterior algoritmo para evaluar expresiones postfijas en decimal (los
operadores permitidos serán: +, -, *. /), haciendo uso de los TAD de la STL de C++ que considere
necesarios (por ejemplo, stack). Para probarlo, muestre el seguimiento (la traza de ejecución) del
algoritmo y de las estructuras de datos más representativas para la siguiente expresión postfija:
24*95+-
Página 8

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
2. Ejercicio con colas. Problema de entrenamiento. Se desea diseñar un programa que proporcione
ejercicios de entrenamiento sobre aritmética básica. Más concretamente, cada ejercicio requiere de la
ejecución de una operación aritmética básica (+, -, *, /) entre dos número decimales generados
aleatoriamente. Si la persona que está realizando la prueba (test) responde correctamente, se genera otra
operación; pero si contesta de manera incorrecta, la operación se almacena de tal forma que pueda ser
planteada de nuevo al final de la prueba. El siguiente algoritmo muestra los pasos que debe seguir el
programa de entrenamiento:
1. Leer numOperaciones y el número decimal máximo (maxRango)
2. Generar numOperaciones operaciones y añadirlos a la cola colaOperaciones
3. Para intento = 1 hasta MAX_INTENTOS hacer // Realización de la prueba (test)
3.1. Inicializar numFallos = 0
3.2. Para contador = 1 hasta numOperaciones hacer
3.2.1. Mostrar una operación y recoger respuestaUsuario
3.2.2. Si respuestaUsuario == respuestaOperacion
Mostrar mensaje “correcto”
Si no
a. Mostrar mensaje “incorrecto”
b. Añadir la operación a la cola colaOperaciones
c. Incrementar numFallos en 1
3.3. Si numFallos == 0
Mostrar un mensaje de felicitación y salir del bucle
Si no
a. Mostrar un mensaje sobre un nuevo intento
b. Hacer numOperaciones = numFallos
4. Si numFallos == 0
Mostrar un mensaje de finalización del entrenamiento
Si no
a. Mostrar un mensaje apropiado de “demasiados intentos”
b. Mientras la colaOperaciones no esté vacía
b.1. Sacar un problema del principio de la cola colaOperaciones
b.2. Mostrarlos junto con su respuesta
c. Mostrar el mensaje de “necesita mejorar”
Se pide: implementar en C++ el anterior algoritmo para realizar un entrenamiento aritmético, haciendo
uso de los TAD de la STL de C++ que considere necesarios (por ejemplo, queue).
3. Ejercicio con listas. Las direcciones IP identifican unívocamente los ordenadores en Internet. Por
ejemplo, la máquina filabres.ual.es tiene la dirección IP 150.214.156.2. Estas direcciones están
formadas por cuatro campos que representan partes específicas de Internet, red.subred.subred.máquina,
que el ordenador traducirá en una única dirección IP. Esta dirección es un valor de 32 bits, pero
normalmente se representa en notación decimal separando los 34 bits en cuatro grupos de 8 bits cada
uno, expresando cada campo como un entero decimal (0..255) y separando los campos por un punto.
En el ejemplo anterior: filabres.ual.es ⇔ 150.214.156.2. Supongamos que se establecen conexiones
desde una red a través de una puerta de acceso a otra red, y cada vez que se establece una conexión la
dirección IP del ordenador del usuario se almacena en un archivo. Estas direcciones se pueden
recuperar periódicamente para controlar quiénes han utilizado la puerta de acceso y cuántas veces lo
han hecho.
Página 9

Estructuras de Datos y Algoritmos (ITIS). TAD Lineales
Se pide: implementar un programa en C++ que lea estas direcciones IP del archivo y las almacene en
una lista (list de la STL de C++) enlazada de objetos que almacenen una dirección IP y el número de
veces que dicha dirección aparece en el archivo. Según se lee cada dirección IP del archivo, el
programa debe comprobar si ya está en la lista. Si lo está, su contador se incrementa en 1; en caso
contrario, se inserta al final de la lista. Una vez que todas las direcciones del archivo han sido leídas, se
mostrará como resultado, en un archivo de salida, las distintas direcciones y sus contadores.
Página 10