- [18.2.4. Sintaxis para la declaración (Definición de un TAD de tipo pila, cola o lista)](#1824-sintaxis-para-la-declaración-definición-de-un-tad-de-tipo-pila-cola-o-lista)
- [19. Navegación de TAD](#19-navegación-de-tad)
- [19.1. Ejemplos sobre el TAD pila](#191-ejemplos-sobre-el-tad-pila)
Vamos a ver los tipos abstractos de datos (TAD) y cómo se pueden implementar para representar secuencias de elementos como Listas, Colas y Pilas. Estos TADs emulan conceptos que encontramos fuera del mundo de la programación.
Unos ejemplos son:
- De listas: una lista de la compra, una lista de tareas pendientes, una lista de reproducción de música.
- De colas: una cola de espera en un supermercado, una cola de espera en una llamada telefónica.
- De pilas: una pila de platos, una pila de libros, una pila de cartas.
Todos los TADs tienen una serie de operaciones que se pueden realizar sobre ellos. Por ejemplo, una pila tiene operaciones como `push` y `pop`, una cola tiene operaciones como `enqueue` y `dequeue`, y una lista tiene operaciones como `insert` y `delete`.
Un TAD consiste en un conjunto de valores (dominio) y el conjunto de operaciones que se pueden aplicar a este conjunto de valores.
El concepto de TAD ya existe en los lenguajes de programación bajo la forma de tipos predefinidos como `int`, `float`, `char`, `string`, etc. Pero también podemos definir nuestros propios TADs. Por ejemplo, en C, el tipo de datos `int` tiene como dominio todos los enteros en el rango `[MININT, MAXINT]` y las operaciones que se pueden aplicar: suma, resta, producto, cociente y módulo.
Implementar una TAD significa elegir una representación para el conjunto de valores del tipo de datos, así como codificar sus operaciones utilizando esa representación en un lenguaje de programación. Es posible tener varias implementaciones para un mismo TAD, pero dada la definición de un TAD, el comportamiento ha de ser siempre el mismo para cualquier implementación.
La utilidad de definir un TAD surge al diseñar nuevos tipos de datos. La idea es que el nuevo TAD solo puede ser manipulado a través de sus operaciones.
El conjunto de valores que engloba este TAD son todos los números enteros mayores o iguales a 0. Las operaciones que definiremos para aplicar a este conjunto son la `suma` y la `división`.
En esta definición no se han excluído los números negativos. La responsabilidad del correcto comportamiento del tipo yace en la definición de las operaciones.
El conjunto de valores que engloba este TAD son todos los números en su representación binaria, es decir, expresados en base 2. Las operaciones que definiremos para aplicar a este conjunto son `desplazamientoIzq` y `complemento`.
Una secuencia lineal es un conjunto de tamaño arbitrario de elementos del mismo tipo. Exceptuando el primero y el último, cada elemento tiene un único predecesor y un único sucesor.
¿Dónde insertar un elemento? ¿Qué elemento eliminar? ¿Qué elemento se puede consultar? ¿Cuántos elementos hay? Las respuestas a las anteriores preguntas son las que definen el comportamiento de las operaciones y, por lo tanto, el tipo de secuencia.
| **Estructura de Datos** | Implementada típicamente con un arreglo estático o una lista enlazada. | Puede ser implementada con un arreglo estático o una lista enlazada. | Generalmente implementada con una lista enlazada o estructura dinámica. |
| **Principio de Acceso** | LIFO (Last In, First Out): Último en entrar, primero en salir. | FIFO (First In, First Out): Primero en entrar, primero en salir. | Acceso Aleatorio: Acceso directo a cualquier elemento. |
| **Operaciones Básicas** | `initStack()`: Inicializa la pila vacía <br>`push(elemento)`: Añade un elemento al tope de la pila. <br>`pop()`: Elimina y retorna el elemento del tope de la pila. <br>`isEmptyStack()`: Verifica si la pila está vacía. <br>`isFullStack()`: Verifica si la pila está llena (en caso de implementación estática). <br>`heightStack()`: Devuelve número de elementos. | `initQueue()`: Inicializa cola <br>`enqueue(elemento)`: Añade un elemento al final de la cola. <br>`dequeue()`: Elimina y retorna el elemento al frente de la cola. <br>`head()`: Devuelve el elemento situado en el inicio. <br>`isEmptyQueue()`: Verifica si la cola está vacía. <br>`isFullQueue()`: Verifica si la cola está llena (en caso de implementación estática). <br>`lengthQueue`: Devuelve el número de elementos. | `initList()`: Inicia la lista vacía. <br>`insert(elemento)`: Inserta un elemento en la lista en una posición específica o al final. <br>`delete(elemento)`: Elimina un elemento de la lista. <br>`get(posición)`: Busca un elemento específico en una posición. <br>`isEnd(posición)`: Devuelve verdadero si la posición dada es posterior a la última. <br>`isEmptyList`: Verifica si la lista está vacía. <br>`isFullList`: Verifica si la lista está llena. <br>`lengthList`: Devuelve el número de elementos. |
| **Implementación Común en C** | Puede ser implementada usando un arreglo estático con un índice que indica el tope, o con una lista enlazada donde cada nodo contiene el dato y un puntero al siguiente nodo. | Similar a la pila, puede usar un arreglo estático o una lista enlazada. En la implementación de arreglo, se usa un índice para controlar el frente y el final de la cola. | Implementada típicamente usando una lista enlazada donde cada nodo contiene el dato y un puntero al siguiente nodo, permitiendo inserciones y eliminaciones eficientes en cualquier posición. |
| **Eficiencia** | - Operaciones de `push()` y `pop()` son O(1) en una implementación con arreglo o lista enlazada. <br> - Espacio requerido puede ser menos flexible que una lista enlazada si se usa un arreglo estático. | - Operaciones de `enqueue()` y `dequeue()` son O(1) en una implementación con arreglo o lista enlazada. <br> - Requiere más espacio que una pila debido al almacenamiento de referencias de frente y final. | - Inserciones y eliminaciones pueden ser O(1) o O(n), dependiendo de si se inserta o elimina al principio o final de la lista. <br> - Búsqueda es O(n) en una lista simple enlazada sin optimizaciones adicionales. |
| **Uso Típico** | - Manejo de historial de llamadas (undo/redo). <br> - Evaluación de expresiones matemáticas (notación polaca inversa). | - Gestión de tareas en una cola (por ejemplo, impresión en una impresora). <br> - Algoritmos de búsqueda en grafos (BFS utiliza una cola para gestionar los nodos a visitar). | - Almacenamiento de datos que requieren acceso y modificación frecuente, pero no necesariamente en orden específico. <br> - Implementación de estructuras de datos más complejas como listas enlazadas dobles o listas circulares. |
| `top` | Devuelve copia del valor del elemento en la cima de la pila. |
| `isEmptyStack` | Consulta si la pila está vacía (true). |
| `isFullStack` | Consulta si la pila está llena (true). |
| `heightStack` | Consulta el número de elementos de la pila. |
##### 18.2.1.2. Implementación
Vamos a crear una implementación en un vector, donde tenemos un número máximo de elementos (MAX). Para conocer el espacio disponible de la pila en cada momento se necesita un atributo que indique el número total de elementos y que llamaremos nelem.
Implementación del tipo:
```alg
type
tStack = record
A: vector[MAX] of elem; {elem represents the type of the elements in th tStack}
nelem: integer;
end record
end type
typedef struct {
elem A[MAX];
int nelem;
} tStack;
```
Implementación de las operaciones del tipo:
Tanto la operación de apilar `push` como la de desapilar `pop`, la manipulación de elementos se realiza por el extremo final de la secuencia que es el tope de la pila.
```alg
action initStack(out s: tStack)
s.nelem:= 0;
end action
action push(inout s: tStack, in e: elem)
if s.nelem = MAX then
{error full tStack}
else
s.nelem:= s.nelem + 1;
s.A[s.nelem]:= e;
end if
end action
action pop(inout s: tStack)
if s.nelem = 0 then
{error empty tStack}
else
s.nelem:= s.nelem - 1;
end if
end action
action top(in s: tStack, out e: elem)
if s.nelem = 0 then
{error empty tStack}
else
e:= s.A[s.nelem];
end if
end action
function isEmptyStack(s: tStack): boolean
return s.nelem = 0;
end function
function isFullStack(s: tStack): boolean
return s.nelem = MAX;
end function
function heightStack(s: tStack): integer
return s.nelem;
end function
```
```c
#include <stdio.h>
#include <stdbool.h>
void initStack(tStack *s) {
s->nelem = 0;
}
void push(tStack *s, elem e) {
if (s->nelem == MAX) {
printf("\n Full Stack \n");
} else {
s->A[s->nelem] = e; /* First position in C is 0 */
s->nelem++;
}
}
void pop(tStack *s) {
if (s->nelem == 0) {
printf("\n Empty Stack \n");
} else {
s->nelem--;
}
}
void top(tStack s, elem *e) {
if (s.nelem == 0) {
printf("\n Empty Stack \n");
} else {
*e = s.A[s.nelem-1];
}
}
bool isEmptyStack(tStack s) {
return s.nelem == 0;
}
bool isFullStack(tStack s) {
return s.nelem == MAX;
}
int heightStack(tStack s) {
return (s.nelem);
}
```
##### 18.2.1.3. Ejemplo de uso
Vamos a suponer un ejemplo de una pila de libros. Cada libro dispone de un código identificador y un nombre. Definimos las estructuras de datos necesarias para modelar el ejemplo:
```alg
type
tBook = record
name: string;
id: integer;
end record
tBox = record
A: vector[MAX] of tBook;
nelem: integer;
end record
end type
```
```c
#include <stdio.h>
#define MAX_NAME_LEN = 25
typedef struct {
char[MAX_NAME_LEN] name;
int id;
} tBook;
typedef struct {
tBook A[MAX];
int nelem;
} tBox;
```
Ok. Ahora vamos a implementar una acción que dada una pila de libros y el código de un libro, encuentre este libro en la pila. En caso de encontrarlo, lo retiramos de la pila; en caso contrario, dejamos la pila como estaba.
| `head` | Devuelve copia del valor del elemento en la cabeza de la cola. |
| `isEmptyQueue` | Consulta si la cola está vacía (true). |
| `isFullQueue` | Consulta si la cola está llena (true). |
| `lengthQueue` | Consulta el número de elementos de la cola. |
##### 18.2.2.2. Implementación
Vamos a crear una implementación en un vector, donde tenemos un número máximo de elementos (MAX). Para conocer el espacio disponible de la cola en cada momento se necesita un atributo que indique el número total de elementos y que llamaremos nelem.
Implementación del tipo:
```alg
type
tQueue = record
A: vector[MAX] of elem;
nelem: integer;
end record
end type
```
```c
typedef struct {
elem A[MAX];
int nelem;
} tQueue;
```
Implementación de las operaciones:
Los elementos se encolan por el final de la cola y se desencolan por el principio. Tened en cuenta que cada vez que se elemina un elemento se han de desplazar todos los elementos de la cola una posición a la izquierda.
```alg
action initQueue(out q: tQueue)
q.nelem:= 0;
end action
action enqueue(inout q: tQueue, in e: elem)
if q.nelem = MAX then
{error full tQueue}
else
q.nelem:= q.nelem + 1;
q.A[q.nelem]:= e;
end if
end action
action dequeue(inout q: tQueue)
var
i: integer;
end var
if q.nelem = 0 then
{error empty tQueue}
else
for i:= 1 to q.nelem-1 do
q.A[i]:= q.A[i+1];
end for
q.nelem:= q.nelem - 1;
end if
end action
action head(in q: tQueue, out e: elem)
if q.nelem = 0 then
{error empty tQueue}
else
e:= q.A[1];
end if
end action
function isEmptyQueue(q: tQueue): boolean
return q.nelem = 0;
end function
function isFullQueue(q: tQueue): boolean
return q.nelem = MAX;
end function
function lengthQueue(q: tQueue): integer
return q.nelem;
end function
```
```c
#include <stdio.h>
#include <stdbool.h>
void initQueue(tQueue *q) {
q->nelem = 0;
}
void enqueue(tQueue *q, elem e) {
if (q->nelem == MAX) {
printf("\n Full Queue \n");
} else {
q->A[q->nelem] = e; /* first position in C is 0 */
q->nelem++;
}
}
void dequeue(tQueue *q) {
int i;
if (q->nelem == 0) {
printf("\n Empty Queue \n");
} else {
for (i = 0; i <q->nelem-1; i++) {
q->A[i] = q->A[i+1];
}
q->nelem--;
}
}
void head(tQueue q, elem *e) {
if (q.nelem == 0) {
printf("\n Empty Queue \n");
} else {
*e = q.A[0];
}
}
bool isEmptyQueue(tQueue q) {
return (q.nelem == 0);
}
bool isFullQueue(tQueue q) {
return (q.nelem == MAX);
}
int lengthQueue(tQueue q) {
return (q.nelem);
}
```
##### 18.2.2.3. Ejemplo de uso
Siguiendo el ejemplo de la cola de una taquilla. Cada cliente de la cola tiene asociado el ordinal en la cola desde que abrió la taquilla y la cantidad de entradas que desea adquirir. Definimos las estructuras de datos necesarias para modelar el ejemplo:
```alg
type
tClient = record
num: integer;
quantity: integer;
end record
tTicketOffice = record
A: vector[MAX] of tClient;
nelem: integer;
end record
end type
```
```c
typedef struct {
int num;
int quantity;
} tClient;
typedef struct {
tClient A[MAX];
int nelem;
} tTicketOffice;
```
Ahora necesitamos implementar una acción que atienda el primer cliente de la cola en la taquilla. La acción recibe como parámetros la cola `q` de clientes y un número `available` que indica la disponibilidad de entradas. En caso de haber suficientes entradas disponibles, se actualiza la cantidad de entradas disponibles y se devuelve el valor verdadero en el parámetro sold. Una vez el cliente es atendido, se elimina de la cola.
```alg
action serverCliente(inout q: tTicketOffice, in available: integer, out sold: boolean)
var
c: tClient;
end var
sold:= false;
if not isEmptyQueue(q) then
head(q, c);
if c.quantity <= available then
dequeue(q);
available:= available - c.quantity;
sold:= true;
end if
dequeue(q);
end if
end action
```
```c
#include <stdio.h>
#include <stdbool.h>
void serverClient(tTicketOffice *q, int *available, bool *sold) {
| `get` | Devuelve copia del valor del elemento en la posición `i`. |
| `isEnd` | Consulta si la posición `i` es el final de la lista (true). |
| `isEmptyList` | Consulta si la lista está vacía (true). |
| `isFullList` | Consulta si la lista está llena (true). |
| `lengthList` | Consulta el número de elementos de la lista. |
##### 18.2.3.2. Implementación
Vamos a crear una implementación en un vector, donde tenemos un número máximo de elementos (MAX). Para conocer el espacio disponible de la lista en cada momento se necesita un atributo que indique el número total de elementos y que llamaremos nelem.
Implementación del tipo:
```alg
type
tList = record
A: vector[MAX] of elem;
nelem: integer;
end record
end type
```
```c
typedef struct {
elem A[MAX];
int nelem;
} tList;
```
Implementación de las operaciones:
Los elementos se insertan en cualquier posición de la lista y se eliminan de la misma forma.
Cada vez que se inserta un elemento en una posición `i`, se han de desplazar todos los elementos de la lista una posición a la derecha. Cada vez que se elimina un elemento de una posición `i`, se han de desplazar todos los elementos de la lista una posición a la izquierda.
```alg
action initList(out l: tList)
l.nelem:= 0;
end action
action insert(inout l: tList, in e: elem, in index: integer)
var
i: integer;
end var
if l.nelem = MAX then
{error full tList}
else
for i:= l.nelem to index step -1 do
l.A[i+1]:= l.A[i];
end for
l.nelem:= l.nelem + 1;
l.A[index]:= e;
end if
end action
action delete(inout l: tList, in index: integer)
var
i: integer;
end var
if l.nelem = 0 then
{error empty tList}
else
for i:= index to l.nelem-1 do
l.A[i]:= l.A[i+1];
end for
l.nelem:= l.nelem - 1;
end if
end action
action get(in l: tList, in index: integer, out e: elem)
if l.nelem = 0 then
{error empty tList}
else
e:= l.A[index];
end if
end action
function isEnd(l: tList, pos: integer): boolean
return pos = l.nelem;
end function
function isEmptyList(l: tList): boolean
return l.nelem = 0;
end function
function isFullList(l: tList): boolean
return l.nelem = MAX;
end function
function lengthList(l: tList): integer
return l.nelem;
end function
```
```c
#include <stdio.h>
#include <stdbool.h>
void initList(tList *l) {
l->nelem = 0;
}
void insert(tList *l, elem e, int index) {
int i;
if (l->nelem == MAX) {
printf("\n Full List \n");
} else {
for (i = l->nelem; i >= index; i--) {
l->A[i+1] = l->A[i];
}
l->nelem++;
l->A[index] = e;
}
}
void delete(tList *l, int index) {
int i;
if (l->nelem == 0) {
printf("\n Empty List \n");
} else {
for (i = index; i <l->nelem-1; i++) {
l->A[i] = l->A[i+1];
}
l->nelem--;
}
}
void get(tList l, int index, elem *e) {
if (l.nelem == 0) {
printf("\n Empty List \n");
} else {
*e = l.A[index];
}
}
bool isEnd(tList l, int pos) {
return pos == l.nelem;
}
bool isEmptyList(tList l) {
return l.nelem == 0;
}
bool isFullList(tList l) {
return l.nelem == MAX;
}
int lengthList(tList l) {
return l.nelem;
}
```
##### 18.2.3.3. Ejemplo de uso
Siguiendo el ejemplo de la lista de la compra del supermercado. Cada artículo tiene asociado un nombre, el tipo de artículo clasificado según sea de panadería, frescos, bebidas, congelados, belleza o desayuno, y la cantidad de este artículo. Definimos las estructuras de datos necesarias para modelar el ejemplo:
Necesitamos implementar una acción que elimine de la lista de la compra `l`, todos los artículos de un tipo dado (filter) que se recibe como parámetro.
```alg
action filterArticleType(inout l: tBuyList, in filter: tArticleType)
Para declarar un tipo pila dentro de un algoritmo, acción o función, se utiliza la siguiente sintaxis:
```alg
nombreTipoPila = tStack(tipoElemento)
```
por ejemplo, `tBinaryStack = tStack(tBit)` permite declarar el tipo tBinaryStack como un tipo de pila de elementos de tipo tBit. A partir de aquí, se le pueden aplicar todas las operaciones que se han definido para las pilas.
Como véis, en lenguaje algorítmico, la declaración queda como un tipo abstracto (su implementación es "oculta") pero en cambio, en lenguaje C, sí que se "ve" su implementación interna:
```c
typedef struct{
tBit A[MAXBITS];
int nelem;
} tBinaryStack;
```
A partir de aquí, solo se debe utilizar con las funciones y acciones predefinidas para este tipo. De este modo, realmente lo estamos utilizando como un tipo abstracto pila.
De forma similar se puede declarar una cola o una lista:
Se pide el diseño de una acción que muestre la representación binaria de un número recibido como parámetro. Se debe usar una pila que almacene los resultados de las divisiones parciales por la base (que es 2). Por ejemplo, si la entrada es 77, la salida debe ser 1001101.
```alg
type
tBinaryStack = tStack(tBit)
end type
action dev2bin(in n: integer)
var
b:tBinaryStack;
res, bit: integer;
end var
initStack(b);
res := n;
while res ≠ 0 do
bit := res mod 2;
res := res / 2;
push(b, bit);
end while
while not isEmptyStack(b) do
top(b, bit);
write(bit);
pop(b);
end while
end action
```
```c
#include <stdio.h>
typedef struct {
tBit A[MAXBITS];
int nelem;
} tBinaryStack;
void dev2bin(int n) {
tBinaryStack b;
int res, bit;
initStack(&b);
res = n;
while (res != 0) {
bit = res % 2;
res = res / 2;
push(&b, bit);
}
printf("\n");
while (!isEmptyStack(b)) {
top(b, &bit);
printf("%d", bit);
pop(&b);
}
printf("\n");
}
```
#### 19.1.2 Ejemplo 2
Se modela el historial de accesos a un conjunto de páginas web. La última página accedida está en la cima de la pila y si nos movemos hacia atrás en el historial iremos accediendo en orden desde el acceso más reciente al más antiguo.
En el historial cada página tiene la siguiente info:
- Identificador único de tipo entero.
- Una dirección de memoria donde se encuentra el código de la página
- La fecha de último acceso en formato aaaammdd.
Se pide una acción `clearRecentHistory` que elimina todas las páginas web del historial que tienen último acceso posterior a una fecha dada.
```alg
type
tWebPage = record
id: integer;
address: integer;
lastAccess: integer;
end record
tHistory = tStack(tWebPage);
end type
action clearRecentHistory(inout s: tHistory, in date: integer)
var
end: boolean;
p: tWebPage;
end var
end:= false;
while not isEmptyStack(s) and not end do
top(s, p);
if p.lastAccess > date then
pop(s);
else
end:= true;
end if
end while
end action
```
```c
#include <stdio.h>
#include <stdbool.h>
typedef struct {
int id;
int address;
int lastAccess;
} tWebPage;
typedef struct {
tWebPage A[MAX];
int nelem;
} tHistory;
void clearRecentHistory(tHistory *s, int date) {
bool end;
tWebPage p;
end = false;
while (!isEmptyStack(*s) && !end) {
top(*s, &p);
if (p.lastAccess > date) {
pop(s);
} else {
end = true;
}
}
}
```
#### 19.1.3 Ejemplo 3
Continuando con el ejercicio anterior del historial de accesos de páginas web, ahora vamos a diseñar una acción `pushupWebPage` que recarga el acceso a una página dada. Esto significa que sube su posición en la pila hasta la cima, para pasar a ser la de acceso más reciente.
```alg
action pushupWebPage(inout s: tHistory, in id: integer);
Se modela la cola de trabajos de una impresora. Los trabajos nuevos se insertan al final de la secuencia de trabajos y el primer trabajo de la secuencia es el primero en enviarse a imprimir.
Cada trabajo tiene la siguiente información:
- Un identificador único de tipo entero.
- La dirección donde se encuentra almacenado el trabajo a imprimir.
- el tamaño en bytes.
- El tipo de impresión (a doble o a simple cara)
Se debe diseñar una función `countBig` que devuelva el número de trabajos de la cola de impresión cuyo tamaño es superior a un límite dado en bytes.
```alg
type
tWork = record
id: integer;
address: integer;
size: integer;
doubleSide: boolean;
end record
tPrintQueue = tQueue(tWork);
end type
function countBig(q: tPrintQueue, limit: integer): integer
var
w: tWork;
ini, count: integer;
end: boolean;
end var
count := 0;
if not is EmptyQueue(q) then
head(q, w);
ini := w.id;
if w.size > limit then
count := count + 1;
end if
dequeue(q);
enqueue(q, w);
end:= false;
while not end do
head(q, w);
if w.id = ini then
end:= true;
else
if w.size > limit then
count := count + 1;
end if
dequeue(q);
enqueue(q, w);
end if
end while
end if
return count;
end function
```
```c
#include <stdio.h>
#include <stdbool.h>
// Define la estructura de un trabajo de impresión
typedef struct {
int id; // Identificador del trabajo
int address; // Dirección del trabajo
int size; // Tamaño del trabajo
bool doubleSide; // Indica si el trabajo es a doble cara
} tWork;
// Define la estructura de una cola de impresión
typedef struct {
tWork A[MAX]; // Array de trabajos
int nelem; // Número de elementos en la cola
} tPrintQueue;
typedef tWork elem;
typedef tPrintQueue tQueue;
// Función para contar cuántos trabajos en la cola son más grandes que un cierto límite
int countBig(tQueue q, int limit){
elem w; // Elemento actual
int ini; // Identificador del primer elemento
int count; // Contador de trabajos grandes
bool end; // Indicador de fin de la cola
count=0;
// Si la cola no está vacía
if(!isEmptyQueue(q)){
head(q, &w); // Obtiene el primer elemento
ini=w.id; // Guarda el identificador del primer elemento
// Si el tamaño del trabajo es mayor que el límite
if(w.size>limit){
count++; // Incrementa el contador
}
dequeue(&q); // Elimina el primer elemento de la cola
enqueue(&q, w); // Añade el primer elemento al final de la cola
end=false;
// Mientras no se haya vuelto al primer elemento
while(!end){
head(q, &w); // Obtiene el primer elemento
// Si se ha vuelto al primer elemento
if(w.id==ini){
end=true; // Indica el fin de la cola
}else{
// Si el tamaño del trabajo es mayor que el límite
if(w.size>limit){
count++; // Incrementa el contador
}
dequeue(&q); // Elimina el primer elemento de la cola
enqueue(&q, w); // Añade el primer elemento al final de la cola
}
}
}
return count; // Devuelve el contador
}
```
#### 19.2.2 Ejemplo 2
Siguiendo con el ejercicio anterior. Se debe diseñar una acción `concatQueues` que, dadas dos colas de trabajos, concatena la segunda cola con la primer y vacía la segunda cola de trabajos. Si la primera cola de trabajos está llena, los trabajos que no se hayan concatenado se quedarán en la segunda cola y el parámetro de salida `completed` será falso. Si se puede realizar la concatenación, el parámetro de salida `completed` será verdadero.
```alg
action concatQueues(inout q1, q2: tPrintQueue, out completed: boolean)
var
w: tWork;
end var
while not isEmptyQueue(q2) and not isFullQueue(q1) do
enqueue(q1, w); // Añade el primer elemento a la cola 1
dequeue(q2); // Elimina el primer elemento de la cola 2
}
*completed = isEmptyQueue(*q2); // Indica si se han añadido todos los elementos
}
```
#### 19.2.3 Ejemplo 3
Siguiendo con el ejercicio anterior. Se debe diseñar una acción `serveDoubleSide`, que envía a imprimir todos los trabajos cuyo tipo de impresión es doble cara. Se devuelve en el parámetro qsingle, una cola creada con todos los trabajos no enviados a imprimir, es decir, los que son de tipo simple cara.
Para enviar un trabajo a imprimir se dispone de la acción `printWork`, que recibe el parámetro el trabajo a imprimir con todos sus datos (identificador, dirección, tamaño y tipo de impresión).
Se modela la lista de asientos disponibles de un vuelo concreto mediante una lista de asientos. Cada asiento tiene la siguiente información:
- Número entero que identifica
- Tipo de asiento:
- Regular
- Puerta de emergencia - No se asignan a menores de 12 años.
De cada pasajero se conoce:
- Identificador de tipo entero
- Número de maletas que ha facturado
- Edad
Se debe diseñar una acción `seatAssign` que, dada una lista de asientos disponibles y la información de un pasajero, devuelve el asiento que se le ha asignado y el parámetro `found` con valor verdadero. Si no ha sido posible asignarle un asiento, el parámetro `found` será falso.
Se modela un conjunto de facturas de una empresa mediante una lista. Las facturas no siguen un orden especial en el alta del conjunto y es posible dar de baja cualquier factura del conjunto.
De cada factura se conoce:
- Un identificador de tipo entero
- Cantidad de dinero de tipo real
- Fecha de la factura en formato aaaammdd
Se debe diseñar una función `countSmallAmounts` que devuelva el número de facturas con cantidad de dinero menor a una cantidad dada.
```alg
type
tInvoice = record
id: integer;
amount: real;
date: integer;
end record
tInvoiceList = tList(tInvoice);
end type
function countSmallAmounts(l: tInvoiceList, a: real): integer
var
inv: tInvoice;
total: integer;
pos: integer;
end var
pos := 1;
total := 0;
while pos ≤ lengthList(l) do
get(l, pos, inv);
if inv.amount <athen
total := total + 1;
end if
pos := pos + 1;
end while
return total
end function
```
```c
#include <stdio.h>
typedef struct {
int id;
float amount;
int date; /* aaaammdd */
} tInvoice;
typedef struct {
tInvoice A[MAX];
int nelem;
} tInvoiceList;
typedef tInvoice elem;
typedef tInvoiceList tList;
int countSmallAmounts(tList l, float a){
tInvoce inv;
int total;
int pos;
pos = 0;
total = 0;
while (pos <lengthList(l)){
get(l, pos, &inv);
if (inv.amount <a){
total++;
}
pos++;
}
return total;
}
```
#### 19.3.3 Ejemplo 3
Siguiendo el ejercicio anterior, vamos a diseñar la acción `findInvoice` que, dado el identificador de una factura, devuelve el parámetro `found` verdadero si la factura está en el conjunto de facturas así como su posición en la lista. En caso contrario, la acción devuelve el parámetro found con valor falso.
```alg
action findInvoice(in l: tInvoice, in d: integer, out found: boolean, out pos:integer)
var
inv: tInvoice;
end var
found := false;
pos := 1;
while pos ≤ lengthList(l) and not found do
get(l, pos, inv);
if inv.id = d then
found := true;
else
pos := pos + 1;
end if
end while
end action
```
```c
#include <stdio.h>
#include <stdbool.h>
void findInvoice(tInvoices l, int id, bool *found, int *pos){
