COLAS

COLAS
1. Conceptos Básicos.
2. Implementación de una COLA
3. Operaciones Básicas
1. Creación de la COLA
2. Insertar en una COLA
3. Extraer de la COLA
4. Mostrar FRENTE de la COLA
4. Ejercicios
 COLAS
Estructura lineal de elementos homogéneos, a la
cual se puede acceder por uno de los dos
extremos: colocar elementos siempre por un
extremo y sacar elementos por extremo opuesto.
Las aplicaciones utilizan una cola para
almacenar elementos en su orden de aparición u
ocurrencia.

Los elementos se eliminan o sacan de la cola en

el mismo orden en que se almacenan, por
consiguiente una cola es una estructura FIFO
(first in /first out , primero en entrar – primero en
salir ó en otras palabras primero en llegar primero
en ser servido ) .
 COLAS
1. Conceptos Básicos.
2. Implementación de una COLA
3. Operaciones Básicas
1. Creación de la COLA
2. Insertar en una COLA
3. Extraer de la COLA
4. Mostrar Cima de la COLA
4. Ejercicios
Implementación de COLAS usando Listas Simples

struct datos
{ tipo cpo_1;
cpo_1
tipo cpo_2;
: sig
// cpo_n
tipo cpo_n; cpo_1
}; : Info sig cpo_1
typedef datos DATO cpo_n : sig
struct NODO cpo_n
{ DATO Info;
NODO * Sig; cpo_1
}; : sig
typedef NODO* ptNODO; cpo_n
void main()
{ ptNODO Cola = NULL, Fin = NULL; cpo_1
//instrucciones que permiten : sig
//realizar operaciones sobre la COLA cpo_n
}
Cola bxxxxx
Fin bxxxxx
 COLAS
1. Conceptos Básicos.
2. Implementación de una COLA
3. Operaciones Básicas
1. Creación de la COLA
2. Insertar en una COLA
3. Extraer de la COLA
4. Mostrar Cima de la COLA
4. Ejercicios
CREACION DE UNA COLA.- Usando Listas Enlazadas

struct datos
{ tipo cpo_1;
tipo cpo_2;
//
tipo cpo_n;
};
typedef datos DATO
struct NODO NUEVO cpo_1
{ DATO Info; cpo_2 sig
NODO * Sig; cpo_n
};
typedef NODO* ptNODO;
void main()
{ ptNODO COLA1=NULL, FIN1=NULL, NUEVO;
DATO X;
cout<<"Campo 1:"; cin>>X.cpo_1;
cout<<"Campo 2:"; cin>>X.cpo_2;
//
cout<<"Campo n:"; cin>>X.cpo_n;
NUEVO = new NODO;
NUEVO->Info=X; COLA1
NUEVO->Sig=NULL; FIN1 NULL
bxx
COLA1 = NUEVO;
FIN11 = NUEVO;
}
IMPLEMENTACION DE UNA COLA.- Usando Listas Enlazadas
struct datos
{ tipo cpo_1; tipo cpo_2; tipo cpo_n; };
typedef datos DATO
struct NODO
void PUSH_COLA(ptNODO &Cola, ptNODO &Fin, DATO X)
{ ptNODO NUEVO; { DATO Info; NODO * Sig; };
NUEVO = new NODO; typedef NODO* ptNODO;
NUEVO->Info = X; NUEVO->sig = NULL;
if(Cola==NULL) Cola = NUEVO;
else Fin->Sig=NUEVO;
Fin = NUEVO; COLA1 cpo_1
} FIN1 cpo_2 sig
} cpo_n
void main()
{ ptNODO COLA1 = NULL, FIN1;
DATO X;
NUEVO cpo_1
int opc; FIN1 cpo_2 sig
do cpo_n
{ cout<<"[1] Insertar en la COLA";
cout<<"[2] Sacar de la COLA"; NUEVO
cout<<"Opcion: "; cin>>opc; cpo_1
switch(opc) FIN1 cpo_2 sig
{ case 1: cpo_n
{ cout<<"Campo 1:"; cin>>X.cpo_1;
cout<<"Campo 2:"; cin>>X.cpo_2;
NUEVO
cout<<"Campo n:"; cin>>X.cpo_n; cpo_1
PUSH(COLA1,X);
FIN1 cpo_2 sig
} cpo_n
case 2:
}
}while(opc<3);
}
 COLAS
1. Conceptos Básicos.
2. Implementación de una COLA
3. Operaciones Básicas
1. Creación de la COLA
2. Insertar en una COLA
3. Extraer de la COLA
4. Mostrar Cima de la COLA
4. Ejercicios
IMPLEMENTACION DE UNA COLA.- Usando Listas Enlazadas
struct datos
{ tipo cpo_1; tipo cpo_2; tipo cpo_n; };
typedef datos DATO
void PUSH_COLA(ptNODO &Cola, ptNODO Fin, DATO X); struct NODO
bool POP_COLA(ptNODO &Cola, ptNODO &Fin) { DATO Info; NODO * Sig; };
{ ptNODO A=Cola; typedef NODO* ptNODO;
if(A!=NULL)
{ Cola=Cola->Sig; A
if(Cola==NULL) Fin=NULL; COLA cpo_1
delete(A); cpo_2 sig
return true; cpo_n
} A
else return false;
} COLA cpo_1
void main() cpo_2 sig
{ ptNODO COLA=NULL,A; cpo_n
DATO X; A
int opc; COLA cpo_1
do cpo_2 sig
{ cout<<"[1] Insertar en la COLA"; cpo_n
cout<<"[2] Sacar de la COLA"; A
cout<<"Opcion: "; cin>>opc; COLA cpo_1
switch(opc)
{ case 1: { //Lectura del registro }
FIN1 cpo_2 sig
cpo_n
case 2: { POP(COLA); }
}
}while(opc<3);
}
 COLAS
1. Conceptos Básicos.
2. Implementación de una COLA
3. Operaciones Básicas
1. Creación de la COLA
2. Insertar en una COLA
3. Extraer de la COLA
4. Mostrar Cima de la COLA
4. Ejercicios
IMPLEMENTACION DE UNA COLA.- Usando Listas Enlazadas
struct datos
{ tipo cpo_1; tipo cpo_2; tipo cpo_n; };
typedef datos DATO
void PUSH_COLA(ptNODO &Cola, ptNODO Fin, DATO X); struct NODO
bool POP_COLA(ptNODO &Cola, ptNODO &Fin) { DATO Info; NODO * Sig; };
bool FRENTE(ptNODO Cola, DATO &XFr) typedef NODO* ptNODO;
{ if(Cola != NULL)
{ XFr=Cola->Info;
return true; COLA ANA
}
123456 sig
return false;
}
void main()
{ ptNODO COLA=NULL, FIN=NULL, A; ROSA
DATO X; 654321 sig
int opc;
do
{ cout<<"[1] Insertar en la COLA";
cout<<"[2] Sacar de la COLA"; LOLA
cout<<"[3] Mostrar Frente"; 665544 sig
cout<<"Opcion: "; cin>>opc;
switch(opc)
{ case 1: { //Lectura del registro }
case 2: { POP_COLA(COLA); } FIN MARIA
case 3: 223344 sig
if(FRENTE(COLA,X))
{ cout<<X.nombre; cout<<X.cedula; }
else cout<<"COLA vacia";
}
}while(opc<3);
}
 void PUSH_COLA(ptNODO &Cola, ptNODO &Fin, DATO X)
{
ptNODO NUEVO;
NUEVO = new NODO;
NUEVO->Info = X; NUEVO->sig = NULL;
if(Cola==NULL)
Cola = NUEVO;
else
Fin->Sig=NUEVO;
Fin = NUEVO;
}

bool POP_COLA(ptNODO &Cola, ptNODO &Fin)

{ bool FRENTE(ptNODO Cola, DATO &XFr)
ptNODO A=Cola; {
if(A!=NULL) if(Cola != NULL)
{ Cola=Cola->Sig; {
if(Cola==NULL) XFr=Cola->Info;
Fin=NULL; return true;
delete(A); }
return true; return
} false;
else }
return false;
}
 Ejercicio

Se tiene un conjunto de registros (Nombre, sexo) almacenados en una

cola como se muestra en la figura, a la izquierda. Escribir una función,
usando colas, que permita organizar los datos almacenados en la cola
como se muestra en la figura a la derecha. El orden de cada grupo debe
ser mantenido.
Solución Ejercicio

void F2 (ptNODO &COLA_INI, ptNODO &COLA_FIN)

{ DATO X;
ptNODO FEM_INI=NULL, FEM_FIN=NULL;
ptNODO MAS_INI=NULL, MAS_FIN=NULL;
while(COLA_INI != NULL)
{ FRENTE(COLA_INI,X)
if(X.sex=='F')
PUSH_COLA(FEM_INI,FEM_FIN,X);
if(X.sex=='M')
PUSH_COLA(MAS_INI,MAS_FIN,X);
POP_COLA(COLA_INI, COLA_FIN);
}
while(FEM_INI != NULL)
{ FRENTE(FEM_INI,X);
PUSH_COLA(COLA_INI,COLA_FIN,X);
POP_COLA(FEM_INI, FEM_FIN);
}
while(MAS_INI != NULL)
{ FRENTE(MAS_INI,X);
PUSH_COLA(COLA_INI,COLA_FIN,X);
POP_COLA(MAS_INI, MAS_FIN);
}
}