Construir una cola con una lista estática.







Análisis del problema
Una cola es una estructura de datos similar a una pila, y se caracteriza porque posee únicamente dos operaciones: Las colas suelen denominarse estructuras FIFO (first-in,first-out) porque el primer elemento que entra es el primero que sale.
Además de poner y quitar, el programa tiene que ofrecer la posibilidad de visualizar ordenadamente la lista, y también la posibilidad de vaciarla.

Diseño del programa
Es análogo al programa construido para reproducir el comportamiento de una pila. Se emplea como base un programa genérico y se modifica únicament el procedimiento empleado para añadir elementos (por un extremo) y tomar elementos (por el otro).

Implementación

Una posible versión del programa sería la siguiente:

/*
Este programa muestra la creación y utilización de una
cola basada en una lista estática. No se emplean funciones.
*/
#include<stdio.h>
#include<ctype.h>
#include<string.h>
 

/* DECLARACIONES GENERICAS */
int fin;
char instruccion;
char menu[80];
char opcionesvalidas[80];
 

/* DECLARACIONES ESPECIFICAS */
#define Tipo_base int
#define DIM_COLA 5
Tipo_base cola[DIM_COLA];
Tipo_base valor;
int qe, i;
/* qe : final de la cola (por aquí se añaden elementos) */
 

int main(void)
{
	/* Iniciaciones generales */
	fin = 0;
	strcpy(menu,"P)ush Po)p V)er Va)ciar S)alir");
	strcpy(opcionesvalidas,"POVASQ");
	qe = 0; /* Empezamos en cola vacía */
	do {
		do {
			puts(menu);
			scanf("%c%*c",&instruccion);
			instruccion=toupper(instruccion);
		} while (!strchr(opcionesvalidas,instruccion));
		 

		switch(instruccion)
		{
			case 'P': { /* PUSH */
			if (qe < DIM_COLA)
			{
				printf("Escriba el valor: ");
				scanf("%d%*c", &valor);
				cola[qe]=valor;
				qe++;
			}
			else
				printf("\nLa cola está llena.\n\n");
			}
			break;
			case 'O': { /* POP */
				if (qe)
				{
					printf("\nValor = %d\n",cola[0]);
					for(i=0;i<qe;i++)
					cola[i] = cola[i+1];
					qe--;
				}
				else
					printf("\nLa cola está vacía.\n\n");
				}
			break;
			case 'V': { /* VER */
				printf("\n");
				if (qe)
				{
					for(i=0;i<qe;i++)
						printf("cola[%d] = %d\n",i,cola[i]);
					printf("\n");
				}
				else
					printf("\nLa cola está vacía.\n\n");
				}
			break;
			case 'A': { /* VACIAR */
				if (qe)
					qe=0;
				else
					printf("\nLa cola está vacía.\n\n");
				}
			break;
			case 'S':
			case 'Q': {
				fin = 1;
				puts("Nos vamos!\n");
				}
			break;
			}
		}
	while (!fin);
	puts("\n\nTerminación normal del programa.\n");
}
/*
RESULTADO
P)ush Po)p V)er Va)ciar S)alir
p
Escriba el valor: 1
P)ush Po)p V)er Va)ciar S)alir
p
Escriba el valor: 2
P)ush Po)p V)er Va)ciar S)alir
p
Escriba el valor: 3
P)ush Po)p V)er Va)ciar S)alir
p
Escriba el valor: 4
P)ush Po)p V)er Va)ciar S)alir
p
Escriba el valor: 5
P)ush Po)p V)er Va)ciar S)alir
o
Valor = 1
P)ush Po)p V)er Va)ciar S)alir
o
Valor = 2
P)ush Po)p V)er Va)ciar S)alir
o
Valor = 3
P)ush Po)p V)er Va)ciar S)alir
o
Valor = 4
P)ush Po)p V)er Va)ciar S)alir
o
Valor = 5
P)ush Po)p V)er Va)ciar S)alir
o
La cola está vacía.
P)ush Po)p V)er Va)ciar S)alir
s
Nos vamos!
Terminación normal del programa.
*/

Comentarios .- Las pilas y colas son estructuras de datos que pueden construirse tomando como base otras estructuras como las listas estáticas y las listas enlazadas. No tiene sentido decir que una pila o cola deben ser estáticas o dinámicas; la implementación de base dependerá únicamente de los requisitos del programa considerado.

Comprobación y Depuración
El programa se ha comprobado insertando el máximo número de elementos, y se han verificado todas las opciones. No se hace comprobación alguna en lo tocante al intervalo admisible (aunque los elementos del tipo base son enteros).

Documentación
El programa contiene comentarios internos. El algoritmo de una cola es bien conocido; la única dificultad consiste en desplazar los elementos de la cola hacia adelante cuando se extrae el primero de ellos. Esto se hace mediante un bucle for() que recorre la cola desde el primer elemento (el cero) hasta el último, desplazándolos todos una posición hacia adelante (hacia el 0).