programación iiprogramación ii – tema 3: colas escuela politécnica superior universidad...
TRANSCRIPT
![Page 1: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/1.jpg)
Programación II Tema 3. Colas
Iván Cantador y Rosa Mª Carro Escuela Politécnica Superior
Universidad Autónoma de Madrid
![Page 2: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/2.jpg)
1
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Contenidos
• El TAD Cola
• Estructura de datos y primitivas de Cola
• Estructura de datos de Cola como array circular
• Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Anexo
• Implementación con front y rear de tipo puntero
![Page 3: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/3.jpg)
2
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Contenidos
• El TAD Cola
• Estructura de datos y primitivas de Cola
• Estructura de datos de Cola como array circular
• Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Anexo
• Implementación con front y rear de tipo puntero
![Page 4: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/4.jpg)
3
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Cola (queue en inglés)
• Colección de elementos FIFO - First In, First Out: “el primero que entra, el primero que sale”
El TAD Cola
![Page 5: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/5.jpg)
4
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
El TAD Cola
• Definición de Cola
• Contenedor de elementos que son insertados y extraídos siguiendo el principio de que el primero que fue insertado será el primero en ser extraído (FIFO – First In, First Out)
‐ Los elementos se insertan de uno en uno: insertar
‐ Los elementos se extraen de uno en uno: extraer
‐ La posición de la cola donde se encuentra el siguiente elemento a ser extraído se denomina front (o head, inicio)
‐ La posición de la cola donde se colocará el siguiente elemento que se inserte se denomina rear (o tail, fin)
![Page 6: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/6.jpg)
5
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
El TAD Cola • Cola: contenedor de elementos en el que…
• la inserción se realiza por un único punto: rear / tail / fin
• la extracción se realiza por un único punto: front / head / inicio
1. Cola Vacía
2. Entra Alice (A)
3. Entra Bob (B)
A
A B
4. Sale Alice
5. Entra Charlie (C)
6. Sale Bob
B
B C
C
front
front rear
front rear
rear
rear
front
front
front rear
rear
![Page 7: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/7.jpg)
6
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
El TAD Cola • Diferencias entre los TAD Pila y Cola
• Pila tiene un único punto de entrada y salida; Cola tiene dos
• Pila es LIFO (Last In, First Out); Cola es FIFO (First In, First Out)
![Page 8: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/8.jpg)
7
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
El TAD Cola • Colas en el mundo real: para pagar en comercios, comprar
tickets para un espectáculo, sacar dinero de un cajero, …
• Una cola gestiona un acceso concurrente a un único recurso
• En Informática existen muchos ejemplos de uso de colas • Trabajos enviados a impresoras
‐ El primer trabajo en llegar es el primero que se imprime: First Come, First Served (FCFS)
• Peticiones a servidores
• Uso del procesador
‐ Un sistema operativo realiza planificaciones de procesos de distintos tipos, gestionando el orden de ejecución de los mismos
• ¡OJO! No todos los elementos tienen que tener siempre la misma prioridad para ser procesados
colas de prioridad (tema 6)
![Page 9: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/9.jpg)
8
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Contenidos
• El TAD Cola
• Estructura de datos y primitivas de Cola
• Estructura de datos de Cola como array circular
• Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Anexo
• Implementación con front y rear de tipo puntero
![Page 10: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/10.jpg)
9
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Estructura de datos y primitivas de Cola
• Una cola está formada por: • datos: conjunto de elementos del mismo tipo, ordenados
implícitamente y accesibles desde dos puntos: front y rear
• front: indicador de la posición del próximo elemento a extraer
• rear: indicador de la posición donde colocar el próximo elemento que se inserte
x
x
x
x
datos
0
1
2
3
4
5
6
7
front
1
(en este dibujo se asume que la cola
tiene tamaño máximo de 8, pero no
tiene por qué ser así)
rear
5
![Page 11: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/11.jpg)
10
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Estructura de datos y primitivas de Cola
• Primitivas
Cola cola_crear(): crea, inicializa y devuelve una cola
cola_liberar(Cola s): libera (la memoria ocupada por) la cola
boolean cola_vacia(Cola s): devuelve true si la cola está vacía y false si no
boolean cola_llena(Cola s): devuelve true si la cola está llena y false si no
status cola_insertar(Cola s, Elemento e): inserta un dato en una cola
Elemento cola_extraer(Cola s): extrae el dato que ocupa el front de la cola
![Page 12: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/12.jpg)
11
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Contenidos
• El TAD Cola
• Estructura de datos y primitivas de Cola
• Estructura de datos de Cola como array circular
• Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Anexo
• Implementación con front y rear de tipo puntero
![Page 13: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/13.jpg)
12
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Estructura de datos de Cola como array circular
• Ejemplo de ejecución de operaciones en una cola
1) cola_inicializar(q)
2) cola_insertar(q, 5)
3) cola_insertar(q, 3)
4) cola_extraer(q)
5) cola_extraer(q)
6) cola_insertar(q, 7)
• Problemas
• Limitación del número máximo de elementos
• Desperdicio de espacio
f=r
1)
5
f
2)
r
5 3
f
3)
r
3
f
4)
r
5)
f=r
7 6)
f r?
![Page 14: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/14.jpg)
13
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Estructura de datos de Cola como array circular
• Soluciones al desperdicio de espacio
1) Cada vez que se extrae un elemento, se desplazan todos los datos una posición en el array
• Ineficiente
2) Cuando rear llega al final del array, se desplazan todos los elementos una posición en el array
• (menos) Ineficiente
3) Implementación de la cola como un array circular
• Más eficiente
![Page 15: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/15.jpg)
14
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Estructura de datos de Cola como array circular
• Cola circular
• ¿Cómo implementarla?
• Incrementando front y rear módulo COLA_MAX front = (front+1) % COLA_MAX
rear = (rear+1) % COLA_MAX
• Problema vigente
• Limitación del número máximo de elementos
0 1
2
3
…
… N-1
N-1 0 1 2 3 …
![Page 16: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/16.jpg)
15
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Estructura de datos de Cola como array circular • Ejemplo de ejecución de operaciones
1) cola_inicializar(q)
2) cola_insertar(q, 5)
3) cola_insertar(q, 3)
4) cola_extraer(q, e)
5) cola_extraer(q, e)
6) cola_insertar(q, 7)
7) cola_insertar(q, 2)
8) cola_insertar(q, 1)
• Conflicto cola llena/vacía • front == rear ¿Cola vacía o llena?
• Solución: sacrificar un hueco libre en el array
‐ Prohibir la inserción cuando sólo queda un hueco
‐ 7) es cola llena
‐ Una cola tiene espacio para (COLA_MAX -1) elementos
f=r
1)
5
f
2)
r
5 3
f
3)
r
3
f
4)
r
5)
f=r
7 6)
f r
vacía vacía
2 7 7)
f r
2 1 7 8)
f=r
¿vacía?
¿llena?
llena
![Page 17: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/17.jpg)
16
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Contenidos
• El TAD Cola
• Estructura de datos y primitivas de Cola
• Estructura de datos de Cola como array circular
• Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Anexo
• Implementación con front y rear de tipo puntero
![Page 18: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/18.jpg)
17
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
datos
0
1
2
3
4
5
6
7
Estructura de datos y primitivas de Cola
• EdD en C • datos: en este tema será un array de punteros: Elemento *datos[];
• front, rear: en este tema se declarará de 2 maneras (versiones) distintas
• Como enteros: int front, rear;
• Como punteros a elemento del array: Elemento **front, **rear;
x
x
x
x
front
1
datos
0
1
2
3
4
5
6
7
x
x
x
x
front
Versión 1 Versión 2
rear
5
rear
![Page 19: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/19.jpg)
18
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Se asume la existencia del TAD Elemento
• EdD de Cola mediante un array
// En cola.h
typedef struct _Cola Cola;
// En cola.c
#define COLA_MAX 8
struct _Cola {
Elemento *datos[COLA_MAX];
int front; // Primer elemento
int rear; // Primer hueco tras // el último elemento
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
![Page 20: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/20.jpg)
19
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
int front;
int rear
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
![Page 21: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/21.jpg)
20
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
int front;
int rear
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
![Page 22: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/22.jpg)
21
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
Cola *cola_crear() {
Cola *pq = NULL;
int i;
pq = (Cola *) malloc(sizeof(Cola));
if (pq==NULL) {
return NULL;
}
pq->front = 0;
pq->rear = 0;
return pq;
}
datos
0
1
2
3
4
5
6
7
vacía
pq
0
front
0
rear
![Page 23: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/23.jpg)
22
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
1
front datos
0
1
2
3
4
5
6
7
x
x
x
x
void cola_liberar(Cola *pq) {
int i;
if (pq!=NULL) {
i = pq->front;
while (i!=pq->rear) {
elemento_liberar(pq->datos[i]);
i = (i+1) % PILA_MAX;
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
pq
5
rear
![Page 24: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/24.jpg)
23
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
int i;
if (pq!=NULL) {
i = pq->front;
while (i!=pq->rear) {
elemento_liberar(pq->datos[i]);
i = (i+1) % PILA_MAX;
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
1
datos
0
1
2
3
4
5
6
7
x
x
x
x
pq
5
front
rear
![Page 25: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/25.jpg)
24
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
int i;
if (pq!=NULL) {
i = pq->front;
while (i!=pq->rear) {
elemento_liberar(pq->datos[i]);
i = (i+1) % PILA_MAX;
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
datos
0
1
2
3
4
5
6
7
pq
1
front
5
rear
![Page 26: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/26.jpg)
25
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
int front;
int rear
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
![Page 27: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/27.jpg)
26
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
boolean cola_vacia(const Cola *pq) {
if (pq == NULL) {
return NULL_BOOLEAN;
}
if (pq->rear == pq->front) {
return TRUE;
}
return FALSE;
}
5
front datos
0
1
2
3
4
5
6
7
pq
5
rear
vacía
0
front datos
0
1
2
3
4
5
6
7
pq
0
rear
vacía
![Page 28: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/28.jpg)
27
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
boolean cola_llena(const Cola *pq) {
if (pq == NULL) {
return NULL_BOOLEAN;
}
if ((pq->rear+1)%COLA_MAX == pq->front) {
return TRUE;
}
return FALSE;
}
0
front datos
0
1
2
3
4
5
6
7
pq
7
rear
llena
x
x
x
x
x
x
x
![Page 29: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/29.jpg)
28
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
boolean cola_llena(const Cola *pq) {
if (pq == NULL) {
return NULL_BOOLEAN;
}
if ((pq->rear+1)%COLA_MAX == pq->front) {
return TRUE;
}
return FALSE;
}
2
front datos
0
1
2
3
4
5
6
7
pq
1
rear
llena
x
x
x
x
x
x
x
![Page 30: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/30.jpg)
29
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
int front;
int rear
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
![Page 31: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/31.jpg)
30
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
status cola_insertar(Cola *pq, const Elemento *pe) {
Elemento *aux = NULL;
if (pq == NULL || pe == NULL || cola_llena(pq) == TRUE) {
return ERROR;
}
aux = elemento_copiar(pe);
if (aux == NULL) {
return ERROR;
}
/* Guardamos el dato en el rear */
pq->datos[pq->rear] = aux;
/* Actualizamos el rear */
pq->rear = (pq->rear+1)%COLA_MAX;
return OK;
}
insertar
datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
6
datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
e
e
pe
aux
![Page 32: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/32.jpg)
31
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
status cola_insertar(Cola *pq, const Elemento *pe) {
Elemento *aux = NULL;
if (pq == NULL || pe == NULL || cola_llena(pq) == TRUE) {
return ERROR;
}
aux = elemento_copiar(pe);
if (aux == NULL) {
return ERROR;
}
/* Guardamos el dato en el rear */
pq->datos[pq->rear] = aux;
/* Actualizamos el rear */
pq->rear = (pq->rear+1)%COLA_MAX;
return OK;
}
insertar
datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
6
datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
e
e
pe
aux
![Page 33: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/33.jpg)
32
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
int front;
int rear
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
1
rear
5
![Page 34: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/34.jpg)
33
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
Elemento *cola_extraer(Cola *pq){
Elemento *pe = NULL;
if (pq == NULL || cola_vacia(pq) == TRUE) {
return NULL;
}
/* Recuperamos el dato del front */
pe = pq->datos[pq->front];
/* Actualizamos el front */
pq->front = (pq->front+1) % COLA_MAX;
return pe;
}
extraer
datos
0
1
2
3
4
5
6
7
e
x
x
x
front
1
rear
5
pe datos
0
1
2
3
4
5
6
7
e
x
x
x
front
2
rear
5
![Page 35: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/35.jpg)
34
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo entero
Implementación en C de Cola
Elemento *cola_extraer(Cola *pq){
Elemento *pe = NULL;
if (pq == NULL || cola_vacia(pq) == TRUE) {
return NULL;
}
/* Recuperamos el dato del front */
pe = pq->datos[pq->front];
/* Actualizamos el front */
pq->front = (pq->front+1) % COLA_MAX;
return pe;
}
extraer
pe datos
0
1
2
3
4
5
6
7
e
x
x
x
front
2
rear
5
datos
0
1
2
3
4
5
6
7
e
x
x
x
front
1
rear
5
![Page 36: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/36.jpg)
35
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Contenidos
• El TAD Cola
• Estructura de datos y primitivas de Cola
• Estructura de datos de Cola como array circular
• Implementación en C de Cola
• Implementación con front y rear de tipo entero
• Anexo
• Implementación con front y rear de tipo puntero
![Page 37: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/37.jpg)
36
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo puntero
• Se asume la existencia del TAD Elemento
• EdD de Cola mediante un array
// En cola.h
typedef struct _Cola Cola;
// En cola.c
#define COLA_MAX 8
struct _Cola {
Elemento *datos[COLA_MAX];
Elemento **front; // Primer elemento
Elemento **rear; // Ultimo elemento
};
datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
![Page 38: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/38.jpg)
37
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo puntero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
Elemento **front;
Elemento **rear;
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
![Page 39: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/39.jpg)
38
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo puntero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
Elemento **front;
Elemento **rear;
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
![Page 40: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/40.jpg)
39
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
Cola *cola_crear() {
Cola *pq = NULL;
int i;
pq = (Cola *) malloc(sizeof(Cola));
if (pq==NULL) {
return NULL;
}
pq->rear = &(pq->datos[0]); // pq->rear = pq->datos
pq->front = &(pq->datos[0]); // pq->front = pq->datos
return pq;
}
datos
0
1
2
3
4
5
6
7
vacía
pq
front
rear
![Page 41: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/41.jpg)
40
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq!=NULL) {
while (pq->front!=pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
x
x
x
x
pq
rear
![Page 42: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/42.jpg)
41
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
x
x
x
x
pq
rear
![Page 43: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/43.jpg)
42
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
x
x
x
x
pq
rear
![Page 44: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/44.jpg)
43
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
x
x
x
x
pq
rear
![Page 45: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/45.jpg)
44
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
x
x
x
x
pq
rear
![Page 46: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/46.jpg)
45
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
pq
rear
![Page 47: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/47.jpg)
46
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
pq
rear
x
x
x
![Page 48: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/48.jpg)
47
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
pq
rear
x
x
x
![Page 49: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/49.jpg)
48
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
pq
rear
x
x
x
![Page 50: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/50.jpg)
49
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
pq
rear
x
x
x
![Page 51: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/51.jpg)
50
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
void cola_liberar(Cola *pq) {
if (pq != NULL) {
while (pq->front != pq->rear) {
elemento_liberar(*(pq->front));
if (pq->front != &(pq->datos[COLA_MAX-1])) {
pq->front = pq->front+1;
}
else {
pq->front = &(pq->datos[0]);
}
}
free(pq);
}
}
Existe: void elemento_liberar(Elemento *pe);
front datos
0
1
2
3
4
5
6
7
pq
rear
![Page 52: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/52.jpg)
51
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo puntero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
Elemento **front;
Elemento **rear;
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
![Page 53: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/53.jpg)
52
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
boolean cola_vacia(const Cola *pq) {
if (pq == NULL) {
return NULL_BOOLEAN;
}
if (pq->rear == pc->front) {
return TRUE;
}
return FALSE;
}
front datos
0
1
2
3
4
5
6
7
pq
rear
vacía
front datos
0
1
2
3
4
5
6
7
pq
rear
vacía
![Page 54: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/54.jpg)
53
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
front datos
0
1
2
3
4
5
6
7
pq
rear
llena
x
x
x
x
x
x
x
boolean cola_llena(const Cola *pq) {
Elemento **aux = NULL;
if (pq == NULL) {
return NULL_BOOLEAN;
}
// Apuntamos aux donde avanzaria rear si se incrementase
if (pq->rear == &(pq->datos[COLA_MAX-1])) {
aux = &(pq->datos[0]); // Al comienzo del array.
} // Equivale a aux = pq->datos
else {
aux = pc->rear + 1; // A la siguiente posicion
}
// Si aux (que es rear+1) coincide con front, cola llena
if (aux == pc->front) {
return TRUE;
}
return FALSE;
}
![Page 55: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/55.jpg)
54
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
front datos
0
1
2
3
4
5
6
7
pq
rear
llena
x
x
x
x
x
x
x boolean cola_llena(const Cola *pq) {
Elemento **aux = NULL;
if (pq == NULL) {
return NULL_BOOLEAN;
}
// Apuntamos aux donde avanzaria rear si se incrementase
if (pq->rear == &(pq->datos[COLA_MAX-1])) {
aux = &(pq->datos[0]); // Al comienzo del array.
} // Equivale a aux = pq->datos
else {
aux = pc->rear + 1; // A la siguiente posicion
}
// Si aux (que es rear+1) coincide con front, cola llena
if (aux == pc->front) {
return TRUE;
}
return FALSE;
}
![Page 56: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/56.jpg)
55
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo puntero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
Elemento **front;
Elemento **rear;
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
![Page 57: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/57.jpg)
56
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
status cola_insertar(Cola *pq, const Elemento *pe){
Elemento *aux = NULL;
if (pq == NULL || pe == NULL || cola_llena(pq) == TRUE) {
return ERROR;
}
aux = elemento_copiar(pe);
if (aux == NULL) {
return ERROR;
}
/* Guardamos el dato en el rear */
*(pq->rear) = aux;
/* Actualizamos el rear */
if (pq->rear == &(pq->datos[COLA_MAX-1])) {
pq->rear = &(pq->datos[0]); // pq->rear = pq->datos
}
else {
pq->rear++;
}
return OK;
} datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
e
e
pe
aux
![Page 58: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/58.jpg)
57
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
status cola_insertar(Cola *pq, const Elemento *pe){
Elemento *aux = NULL;
if (pq == NULL || pe == NULL || cola_llena(pq) == TRUE) {
return ERROR;
}
aux = elemento_copiar(pe);
if (aux == NULL) {
return ERROR;
}
/* Guardamos el dato en el rear */
*(pq->rear) = aux;
/* Actualizamos el rear */
if (pq->rear == &(pq->datos[COLA_MAX-1])) {
pq->rear = &(pq->datos[0]); // pq->rear = pq->datos
}
else {
pq->rear++;
}
return OK;
} datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
e
e
pe
aux
![Page 59: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/59.jpg)
58
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
Implementación en C de Cola
• Implementación con front y rear de tipo puntero
• Asumimos la existencia del TAD Elemento que, entre otras, tiene asociadas las primitivas liberar y copiar: void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en cola.h) Cola *cola_crear();
void cola_liberar(Cola *pq);
boolean cola_vacia(const Cola *pq);
boolean cola_llena(const Cola *pq);
status cola_insertar(Cola *pq, const Elemento *pe);
Elemento *cola_extraer(Cola *pq);
• Estructura de datos (en cola.c) struct _Cola {
Elemento *datos[COLA_MAX];
Elemento **front;
Elemento **rear;
}; datos
0
1
2
3
4
5
6
7
x
x
x
x
front
rear
![Page 60: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/60.jpg)
59
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
Elemento *cola_extraer(const Cola *pq){
Elemento *pe = NULL;
if (pq == NULL || cola_vacia(pq) == TRUE) {
return NULL;
}
/* Recuperamos el dato del front */
pe = *(pq->front);
/* Actualizamos el front */
if (pq->front == &(pq->datos[COLA_MAX-1])) {
pq->front = &(pq->datos[0]); // pq->rear = pq->datos
}
else {
pq->front++;
}
return pe;
}
datos
0
1
2
3
4
5
6
7
e
x
x
x
front
rear
extraer
![Page 61: Programación IIProgramación II – Tema 3: Colas Escuela Politécnica Superior Universidad Autónoma de Madrid El TAD Cola •Colas en el mundo real: para pagar en comercios, comprar](https://reader034.vdocuments.mx/reader034/viewer/2022042304/5ed03ded7d4cb6261160d4cd/html5/thumbnails/61.jpg)
60
Programación II – Tema 3: Colas Escuela Politécnica Superior
Universidad Autónoma de Madrid
• Implementación con front y rear de tipo puntero
Implementación en C de Cola
Elemento *cola_extraer(const Cola *pq){
Elemento *pe = NULL;
if (pq == NULL || cola_vacia(pq) == TRUE) {
return NULL;
}
/* Recuperamos el dato del front */
pe = *(pq->front);
/* Actualizamos el front */
if (pq->front == &(pq->datos[COLA_MAX-1])) {
pq->front = &(pq->datos[0]); // pq->front= pq->datos
}
else {
pq->front++;
}
return pe;
}
pe datos
0
1
2
3
4
5
6
7
e
x
x
x
front
rear