Buenas amigos, hoy vengo con algo interesante.
Resulta que debo hacer un programa que me permita escribir o registrar las cedulas de algunas personas que van llegando en orden.
Debo registrar las cedulas en el orden que llegan para que se vaya atendiendo a cada persona.
La primera en llegar es la primera en ser atendida.
Cola -> Primera en llegar es la primera en salir.
TENGO UN EJEMPLO DE PILA EN C:
/* TAD Pila- Implementacion #3 */
/*-------------------------------------------------------------------*/
#include <stdio.h>
/*-------------------------------------------------------------------*/
/* ESTRUCTURAS DE DATOS */
/*-------------------------------------------------------------------*/
typedef int TipoP;
typedef struct TNodoPila
{ TipoP info;
struct TNodoPila *sig;
} TPila, *Pila;
/*-------------------------------------------------------------------*/
/* Inicializadora: Crea una pila vacia */
/* Complejidad : O(1) */
Pila inicPila(void)
{ Pila pil=(Pila)malloc(sizeof(TPila));
pil->sig=NULL;
return pil;
}
/*-------------------------------------------------------------------*/
/* Modificadora: Agrega un elemento al tope de la pila */
/* Complejidad : O(1) */
void adicPila(Pila pil, TipoP elem)
{ Pila p=(Pila)malloc(sizeof(TPila));
p->info=elem;
p->sig=pil->sig;
pil->sig=p;
}
/*-------------------------------------------------------------------*/
/* Modificadora: Elimina el elemento del tope de la pila */
/* Complejidad : O(1) */
void elimPila(Pila pil)
{ Pila p=pil->sig;
pil->sig=pil->sig->sig;
free(p);
}
/*-------------------------------------------------------------------*/
/* Analizadora: Retorna el elemento del tope de la pila */
/* Complejidad : O(1) */
TipoP infoPila(Pila pil)
{ return pil->sig->info;
}
/*-------------------------------------------------------------------*/
/* Analizadora: Informa si la pila se encuentra vacia */
/* Complejidad : O(1) */
int vaciaPila(Pila pil)
{ return pil->sig==NULL;
}
/*-------------------------------------------------------------------*/
/* Destructora: Destruye la pila y retorna toda la memoria */
/* Complejidad: O(N) */
void destruirPila(Pila pil)
{ Pila p,q;
for(p=pil; p!=NULL; p=p->sig)
{ q=p;
p=p->sig;
free(q);
}
}
/*-------------------------------------------------------------------*/
/* Depuracion: Imprime el contenido de una pila */
void impPila(Pila pil)
{ Pila p;
for (p=pil->sig; p!=NULL; p=p->sig)
printf("%d ",p->info);
printf("]\n");
}
void main(void)
{ int com,elem;
Pila pil;
pil=inicPila();
do
{ /* Presenta el menu de opciones */
printf("\n0. Salir\n");
printf("1. Agregar cedula\n");
printf("2. Eliminar cedula\n");
printf("3. Ver Lista ingresada\n");
printf("4. Pila vacia?\n");
printf("\nOpcion: ");
scanf("%d",&com);
/* Da control a cada una de las operaciones del TAD Pila */
switch(com)
{ case 1: printf("Elemento: ");
scanf("%d",&elem);
adicPila(pil,elem);
break;
case 2: elimPila(pil);
break;
case 3: printf("Tope= %d\n",infoPila(pil));
break;
case 4: if (vaciaPila(pil))
printf("Pila vacia\n");
else
printf("Pila no vacia\n");
break;
}
/* Imprime el contenido de la pila */
impPila(pil);
} while (com!=0);
destruirPila(pil);
}
Es fantastco y funciona, pero el anterior ejemplo es PILA por lo que el primero que llega es el ultimo en salir.
Ahora he tratado de pasarlo a COLA (Primero en llegar, primero en salir):
OJO: AMIGO TEN PENDIENTE DE LOS EN CADA FUNCION YA QUE TENGO LOS COMENTARIOS DE PILAS PARA PODER GUIARME ABAJO DE CADA FUNCION DE COLA
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 30
typedef int TipoC;
typedef struct
{
TipoC info[MAX];
int primero;
int ultimo;
}TCola, *Cola;
/* Constructora */
Cola inicCola(void)
{
Cola col=(Cola)malloc(sizeof(TCola));
col->primero=col->ultimo=-1;
return col;
}
/* { Pila pil=(Pila)malloc(sizeof(TPila));
pil->sig=NULL;
return pil;
}*/
/* Modificadoras */
void adicCola(Cola col, TipoC elem)
{
if (col->primero==-1)
{
col->info[0]=elem;
col->primero=col->ultimo=0;
}
else
{
col->ultimo=(col->ultimo+1)%MAX;
col->info[col->ultimo]=elem;
}
}
/*{ Pila p=(Pila)malloc(sizeof(TPila));
p->info=elem;
p->sig=pil->sig;
pil->sig=p;
}*/
void elimCola(Cola col)
{
if(col->primero==col->ultimo)
col->primero=col->ultimo=-1;
else
col->primero=(col->primero+1)%MAX;
}
/*
{ Pila p=pil->sig;
pil->sig=pil->sig->sig;
free(p);
}*/
/* Analizadoras */
TipoC infoCola(Cola col)
{
return col->info[col->primero];
}
/*{ return pil->sig->info;
}*/
int vaciaCola(Cola col)
{
return col->primero==-1&&col->ultimo==-1;
}
/*{ return pil->sig==NULL;
}*/
/* destructora */
void destruirCola(Cola col)
{
free(col);
}
/*
{ Pila p,q;
for(p=pil; p!=NULL; p=p->sig)
{ q=p;
p=p->sig;
free(q);
}
}
*/
main ()
{
int com;
inicCola();
printf("Ingrese un valor");
scanf("%d",&com);
adicCola(col, com);
}
Me he enredado, simplemente la idea es que pida la cedula , la guarde segun orden , y cuando quiera moistrarla, este de primero el que ingreso de primero, y los que vayan ingresando se vayan guardando en la cola.
Foro
