Update PEC6

2024-06-18 20:09:14 +02:00 · 2024-06-18 20:09:14 +02:00 · 7a8e9b99f4
commit 7a8e9b99f4
parent 3333040be4
1 changed files with 842 additions and 30 deletions
--- a/fundamentos-programacion/PEC6/README.md
+++ b/fundamentos-programacion/PEC6/README.md
@ -7,24 +7,21 @@
  - [18. Tipos abstractios de datos](#18-tipos-abstractios-de-datos)
    - [18.1. Tipo abstracto de datos (TAD)](#181-tipo-abstracto-de-datos-tad)
      - [18.1.1. Ejemplos de especificación e implementación](#1811-ejemplos-de-especificación-e-implementación)
-        - [18.1.1.1 Ejemplo con números naturales](#18111-ejemplo-con-números-naturales)
-        - [18.1.1.2 Ejemplo con números binarios](#18112-ejemplo-con-números-binarios)
-    - [18.2 TAD para representar secuencias de elementos](#182-tad-para-representar-secuencias-de-elementos)
+        - [18.1.1.1. Números naturales](#18111-números-naturales)
+        - [18.1.1.2. Números binarios](#18112-números-binarios)
+    - [18.2. TAD para representar secuencias de elementos](#182-tad-para-representar-secuencias-de-elementos)
      - [18.2.1. El TAD Pila (tStack)](#1821-el-tad-pila-tstack)
-        - [18.2.1.1. Definición](#18211-definición)
-        - [18.2.1.2. Operaciones](#18212-operaciones)
-        - [18.2.1.3. Implementación](#18213-implementación)
-        - [18.2.1.4 Ejemplo de uso](#18214-ejemplo-de-uso)
+        - [18.2.1.1. Lista de operaciones sobre tStack](#18211-lista-de-operaciones-sobre-tstack)
+        - [18.2.1.2. Implementación](#18212-implementación)
+        - [18.2.1.3. Ejemplo de uso](#18213-ejemplo-de-uso)
      - [18.2.2. El TAD Cola (tQueue)](#1822-el-tad-cola-tqueue)
-        - [18.2.2.1. Definición](#18221-definición)
-        - [18.2.2.2. Operaciones](#18222-operaciones)
-        - [18.2.2.3. Implementación](#18223-implementación)
-        - [18.2.2.4 Ejemplo de uso](#18224-ejemplo-de-uso)
+        - [18.2.2.1.  Lista de operaciones sobre tQueue](#18221--lista-de-operaciones-sobre-tqueue)
+        - [18.2.2.2. Implementación](#18222-implementación)
+        - [18.2.2.3. Ejemplo de uso](#18223-ejemplo-de-uso)
      - [18.2.3. El TAD Lista (tList)](#1823-el-tad-lista-tlist)
-        - [18.2.3.1. Definición](#18231-definición)
-        - [18.2.3.2. Operaciones](#18232-operaciones)
-        - [18.2.3.3. Implementación](#18233-implementación)
-        - [18.2.3.4 Ejemplo de uso](#18234-ejemplo-de-uso)
+        - [18.2.3.1.  Lista de operaciones sobre tList](#18231--lista-de-operaciones-sobre-tlist)
+        - [18.2.3.2. Implementación](#18232-implementación)
+        - [18.2.3.3. Ejemplo de uso](#18233-ejemplo-de-uso)
      - [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)
@ -34,81 +31,896 @@

 ## 18. Tipos abstractios de datos

+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`.


 ### 18.1. Tipo abstracto de datos (TAD)

+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.


 #### 18.1.1. Ejemplos de especificación e implementación

+##### 18.1.1.1. Números naturales

-##### 18.1.1.1 Ejemplo con números naturales
+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`.
+
+```alg
+type
+  natural = integer;
+end type
+
+function suma(x: natural, y: natural): natural
+  return x + y;
+end function
+
+function division(x: natural, y: natural): natural
+  return x / y;
+end function
+```
+
+```c
+#include <stdio.h>
+
+typedef unsigned int natural;
+
+natural suma(natural x, natural y) {
+  return x + y;
+}
+
+natural division(natural x, natural y) {
+  return x / y;
+}
+```
+
+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.


-##### 18.1.1.2 Ejemplo con números binarios
+##### 18.1.1.2. Números binarios
+
+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`.
+
+```alg
+const
+  MAXBITS: integer:= 64;
+end const
+
+type
+  binario: vector[MAXBITS] of boolean;
+end type
+
+action desplazamientoIzq(inout b:binario, in n integer)
+  var
+    i: integer;
+  end var
+
+  for i:= n+1 to MAXBITS do
+    b[i-n]:= b[i];
+  end for
+
+  for i:= MAXBITS-n to MAXBITS do
+    b[i]:= 0;
+  end for
+end action
+
+action complemento(inout b:binario)
+  var
+    i: integer;
+  end var
+
+  for i:= 1 to MAXBITS do
+    b[i]:= not b[i];
+  end for
+end action
+```
+
+```c
+#include <stdio.h>
+
+#define MAXBITS 64
+
+typedef int binario[MAXBITS];
+
+void desplazamientoIzq(binario b, int n) {
+  int i;
+
+  for (i = n; i < MAXBITS; i++) {
+    b[i-n] = b[i];
+  }
+
+  for (i = MAXBITS-n; i < MAXBITS; i++) {
+    b[i] = 0;
+  }
+}
+
+void complemento(binario b) {
+  int i;
+
+  for (i = 0; i < MAXBITS; i++) {
+    b[i] = !b[i];
+  }
+}
+```


+### 18.2. TAD para representar secuencias de elementos

-### 18.2 TAD para representar secuencias de elementos
+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.
+
+En general, un TAD que representa secuencias de elementos posee las siguientes operaciones:
+- Inicializar la secuencia.
+- Insertar un elemento en la secuencia.
+- Eliminar un elemento de la secuencia.
+- Consultar el valor de un elemento en la secuencia.
+- Consultar el número de elementos de la secuencia.
+
+¿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.


 #### 18.2.1. El TAD Pila (tStack)

+- Una pila es una secuencia lineal de elementos.
+- Los elementos se insertan únicamente por un extremo de la secuencia. Por eso se dice que es una estructura LIFO (Last In, First Out).
+- La manipulación y acceso a los elementos de la pila se permite solo en un extremo de la secuencia.
+
+Se puede pensar en una pila de libros dentro de una caja.


-##### 18.2.1.1. Definición
+##### 18.2.1.1. Lista de operaciones sobre tStack
+
+| Operación      | Descripción                                                  |
+| -------------- | ------------------------------------------------------------ |
+| `initStack`    | Inicializa la pila.                                          |
+| `push`         | Empila un elemento en la pila.                               |
+| `pop`          | Desempila un elemento de la pila.                            |
+| `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. Operaciones
+##### 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. Implementación
+##### 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

-##### 18.2.1.4 Ejemplo de uso
+  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.
+
+```alg
+
+action findBook(inout s: tBox, in id: integer)
+  var
+    b: tBook;
+    aux: tBox;
+    found: boolean;
+  end var
+
+  found:= false;
+  initStack(aux);
+
+  while not isEmptyStack(s) and not found do
+    top(s, b);
+    
+    if b.id = id then
+      push(aux, b);
+    else
+      found:= true;
+    end if
+
+    pop(s);
+
+  end while
+
+  while not isEmptyStack(aux) do
+    top(aux, b);
+    push(s, b);
+    pop(aux);
+  end while
+
+end action
+```
+
+```c
+#include <stdio.h>
+#include <stdbool.h>
+
+void findBook(tBox *s, int id) {
+  tBook b;
+  tBox aux;
+  bool found;
+
+  found = false;
+  initStack(&aux);
+
+  while (!isEmptyStack(*s) && !found) {
+    top(*s, &b);
+
+    if (b.id == id) {
+      push(&aux, b);
+    } else {
+      found = true;
+    }
+
+    pop(s);
+  }
+
+  while (!isEmptyStack(aux)) {
+    top(aux, &b);
+    push(s, b);
+    pop(&aux);
+  }
+}
+```


 #### 18.2.2. El TAD Cola (tQueue)

+- Una cola es una secuencia lineal de elementos.
+- Los elementos se insertan por el final de la cola y se extraen por el principio. Por eso se dice que es una estructura FIFO (First In, First Out).
+- La manipulación y el acceso a los elementos de la cola solo se permite en los extremos.

-##### 18.2.2.1. Definición
+Un ejemplo de una cola es una cola de personas esperando para comprar una entrada en la taquilla de un teatro.
+
+##### 18.2.2.1.  Lista de operaciones sobre tQueue
+
+| Operación      | Descripción                                                    |
+| -------------- | -------------------------------------------------------------- |
+| `initQueue`    | Inicializa la cola.                                            |
+| `enqueue`      | Encola un elemento en la cola.                                 |
+| `dequeue`      | Desencola un elemento de la cola.                              |
+| `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. Operaciones
+##### 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; /* ﬁrst 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. Implementación
+##### 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

-##### 18.2.2.4 Ejemplo de uso
+  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) {
+  tClient c;
+
+  *sold = false;
+
+  if (!isEmptyQueue(*q)) {
+    head(*q, &c);
+
+    if (c.quantity <= *available) {
+      *available -= c.quantity;
+      *sold = true;
+    }
+
+    dequeue(q);
+  }
+}
+```


 #### 18.2.3. El TAD Lista (tList)

+- Una lista es una secuencia lineal de elementos.
+- Los elementos se insertan, se eliminan y se consultan en cualquier posición de la lista.

-##### 18.2.3.1. Definición
+Para entender mejor el concepto de lista, podemos pensar en una lista de la compra del supermercado.
+
+##### 18.2.3.1.  Lista de operaciones sobre tList
+
+| Operación     | Descripción                                                 |
+| ------------- | ----------------------------------------------------------- |
+| `initList`    | Inicializa la lista.                                        |
+| `insert`      | Inserta un elemento en la lista.                            |
+| `delete`      | Elimina un elemento de la lista.                            |
+| `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. Operaciones
+##### 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. Implementación
+##### 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:

+```alg
+type
+  tArticleType = {BAKERY, FRESH, DRINKS, FROZEN, BEAUTY, BREAKFAST}
+  tArticle = record
+    type: tArticleType;
+    quantity: real;
+  end record

-##### 18.2.3.4 Ejemplo de uso
+  tBuyList = record
+    A: vector[MAX] of tArticle;
+    nelem: integer;
+  end record
+end type
+```

+```c
+#include <stdio.h>
+
+typedef enum {BAKERY, FRESH, DRINKS, FROZEN, BEAUTY, BREAKFAST} tArticleType;
+
+typedef struct {
+  tArticleType type;
+  float quantity;
+} tArticle;
+
+typedef struct {
+  tArticle A[MAX];
+  int nelem;
+} tBuyList;
+```
+
+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)
+  var
+    a: tArticle;
+    pos: integer;
+  end var
+
+  pos := 1;
+
+  while not isEnd(l, pos) do
+    get(l, pos, a);
+
+    if a.type = filter then
+      delete(l, pos);
+    else
+      pos := pos + 1;
+    end if
+  end while
+end action
+```
+
+```c
+#include <stdio.h>
+
+void filterArticleType(tBuyList *l, tArticleType filter) {
+  elem a;
+  int pos;
+
+  pos = 0;
+
+  while (!isEnd(*l, pos)) {
+    get(*l, pos, &a);
+
+    if (a.type == filter) {
+      delete(l, pos);
+    } else {
+      pos = pos + 1;
+    }
+  }
+}
+```


 #### 18.2.4. Sintaxis para la declaración (Definición de un TAD de tipo pila, cola o lista)

+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:
+
+```alg
+nombreTipoCola = tQueue(tipoElemento)
+nombreTipoLista = tList(tipolemento)
+```
+

 ## 19. Navegación de TAD