Esta es una variación de la implementación en el libro C & Data Structures de una cola ( FIFO ) construida sobre un array. Me intereso esa estructura de datos por 2 cosas. Primero, el hecho de que la estructura de datos era más que el array donde se guardaban los datos, necesitándose una serie de variables asociados para usarlo y segundo el uso de la aritmética mod( n ) para moverse entre las posiciones del array.

Sin embargo, existen una serie de errores en la implementación del ejemplo y además considerando que se utilizan un conjunto de variables para definir el funcionamiento de la estructura, lo lógico sería agrupar todas estas variables dentro de un struct de C. Así que esta es mi implementación, que además fue un buen ejercicio para repasar la sintaxis de punteros y de structs en C:


#include <stdio.h>
#include <stdlib.h>
#define MAX 10 /* The maximum size of the queue */

struct ca {
	int cola[ MAX ];
	int fin;
	int frente;
	int num_elems;
};
typedef struct ca cola_array;


void insert( cola_array *carr, int value ) {
	if(carr->frente == carr->fin && carr->num_elems > 0) {
		printf("Cola Llenan");
	} else {
		carr->cola[ carr->fin ] = value;
		carr->fin = ( carr->fin + 1) % MAX;
		carr->num_elems ++;
	}
}

int delete( cola_array *carr ) {
	int temp;
	if( carr->num_elems == 0 ) {
		printf("Cola Vacian");
		return -1;
	} else {
		temp = carr->cola[ carr->frente ];
		carr->frente = ( carr->frente + 1) % MAX;
		carr->num_elems--;
		return temp;
	}
}

void listar( cola_array *carr ) {
	int x;
	if( carr->num_elems == 0 ) {
		printf("Cola Vacia");
	} else {
		printf("Numero de Elementos: %dt Frente: %dt Fin: %dn", carr->num_elems, carr->frente, carr->fin);
		for( x = 0; x < carr->num_elems; x++) {
			printf("%dt", carr->cola[ ( x + carr->frente ) % MAX  ]);		
		}
	}
	printf("n");
}

int main()
{
	int menu, value;
	cola_array carr;
	carr.fin = carr.frente = carr.num_elems = 0;
	do {
		printf("Seleccione:n");
		printf("1. Insertarn");
		printf("2. Borrarn");
		printf("3. Listarn");
		printf("4. Salirn");
		scanf("%d", &menu);
		switch(menu) {
			case 1: 
				printf("Valor a Insertar (Mayor o Igual que 0): n");
				scanf("%d", &value);
				insert( &carr, value);
			break;
			case 2: 
				value = delete( &carr );
				if(value >= 0) {
					printf("Valor borrado: %d n", value);
				}
			break;
			case 3:
				listar( &carr );
			break;
			case 4: 
				return(0);
			break;
			default:
				printf("Opcion no Valida.n");
			break;
		}
	} while( menu != 4 );
	return(0);
}

La parte que me gusto hacer es:


		for( x = 0; x < carr->num_elems; x++) {
			printf("%dt", carr->cola[ ( x + carr->frente ) % MAX  ]);		
		}

Y en particular ( x + carr->frente ) % MAX por el uso de la aritmética mod( n ) que me hizo recordar al concepto de clases de equivalencias de Algebra.

Explicación

Supongamos que la cola tiene 5 elementos (sobre un máximo de 10), pero como la cola ya se estuvo utilizando quedaron ubicados los 2 primeros en las posiciones 8 y 9 del array y los 3 últimos en las posiciones 0 a 2. El loop va a iterar a x de 0 a 4, cuando x este en 0 ( x + carr->frente ) % MAX va a equivaler a 8, cuando este en 1 a 9; pero cuando llegue a 2, ( x + carr->frente ) equivale a 10 y 10 % MAX equivale a 0.

Esto es así porque en la 0/10, 10/10, 20/10.. etc, tienen exactamente el mismo resto, 0; de la misma manera que 1/10, 11/10, 21/10.. etc tienen todos resto 1. ( La operación % establece clases de equivalencia sobre N). Lo que permite moverse circularmente sobre el array.