UNIVERSIDAD INCA GARCILASO DE LA VEGA

FACULTAD DE INGENIERIA DE SISTEMAS, COMPUTO Y TELECOMUNICACIONES

ASIGNATURA Estructura de Información

TEMA PILAS Y COLAS
PROFESOR Carlos A. Ruiz De La Cruz Melo
ALUMNO
CODIGO
FECHA 28 / 05 / 2009
CICLO IV
TURNO 1-A y 3-A
SEMESTRE 2009-2

1. OBJETIVOS

Que el estudiante:

 Defina las técnicas de conformación y administración de pilas y colas.

 Identifique las aplicaciones de pilas y colas.
 Conozca e implemente las operaciones que con las pilas y colas se pueden realizar.

2. INTRODUCCION TEORICA

Pila

Definición

Una pila (stack) es una colección ordenada de elementos en la cual se pueden insertar
nuevos elementos por un extremo y se pueden retirar otros por el mismo extremo; ese
extremo se llama ``la parte superior o tope'' de la pila.
Manejo de la pila: UEPS (LIFO)

• La inserción y extracción de elementos de la pila siguen el principio LIFO (last-in-

first-out).
• El último elemento en entrar es el único accesible en cada momento.

Operaciones con pilas: Push, Pop

• Las operaciones básicas de una pila son “push” (empujar, meter) y “pop” (sacar)
o Push: añade un nuevo elemento a la pila
o Pop: elimina un elemento de la pila
• Otras operaciones usualmente incluidas en el tipo de dato abstracto pila son:
o EstaVacia (estáVacia): verifica si la pila está vacía
o EstaLLena (estáLlena): verifica si la pila está llena

Aplicaciones de Pilas

• Navegador Web
o Se almacenan los sitios previamente visitados
o Cuando el usuario quiere regresar (presiona el botón de retroceso),
simplemente se extrae la última dirección (pop) de la pila de sitios visitados.
• Editores de texto
o Los cambios efectuados se almacenan en una pila
o Usualmente implementada como arreglo
o Usuario puede deshacer los cambios mediante la operación “undo”, la cual
extraer el estado del texto antes del último cambio realizado.
• La recursividad se simula en un computador con la ayuda de una pila.

Implementación de pilas con arreglos

• Una pila es una colección ordenada de objetos.

• En C, los arreglos permiten almacenar colecciones ordenadas.
• La desventaja de implementar una pila mediante un arreglo es que esta última es
de tamaño fijo, mientras que la pila es de tamaño dinámico.
Ejemplo 1

Escriba un programa que permita implementar una pila de datos enteros.

ESPECIFICACIÓN DEL TAD Y LOS ALGORITMOS

Especificacion ENTERO
variable
num: entero
operaciones
IngEntero : no retorna valor
VisEntero : no retorna valor
ecuaciones
IngEntero lee los datos de un valor entero
VisEntero visualiza los datos del valor entero
finespecificacion

Especificacion PILA
variable
e: ENTERO
sgte:PILA
tope: entero
i: entero
operaciones
CREAR : no retorna valor
CREAR(raiz, TAMANO) : no retorna valor
Ocupada : retorna valor logico
VACIA : retorna valor logico
METER(raiz, dato) : retorna valor logico
SACAR(raiz) : retorna valor logico
VER(raiz) : no retorna valor
ecuaciones
CREAR permite crear un nodo
CREAR(raiz, TAMANO) permite crear la pila asignando un tamaño a traves de la
variable TAMAÑO a la pila con cabecera raiz.
Ocupada retorna verdadero si la pila llego al tope de su tamaño, en caso contrario
retorna falso
VACIA retorna verdadero si la pila esta vacia, en caso contrario retorna falso.
METER(raiz, dato) retorna verdadero si el TAD dato se ingreso correctamente a la
pila con cabecera raiz, en caso contrario retorna falso.
SACAR(raiz) retorna verdadero si el TAD de la cima de la pila con cabecera raiz se
saco correctamente de la pila, en caso contrario retorna falso.
VER(raiz) permite visualizar los datos de la pila con cabecera raiz
finespecificacion
 predicado Ocupada
si (i>=tope)
Ocupadaverdadero
Sino
Ocupadafalso
Finsi
finOcupada
predicado VACIA
si(i<=0)
VACIAverdadero
Sino
VACIAfalso
finsi
finVACIA
predicado METER(raiz, dato)
si (no Ocupada())
crear(n)
asignar(n,dato)
si (raiz = nulo)
raiz  n
sgte(n)nulo
sino
sgte(n)raiz
raizn
finsi
ii+1
METERverdadero

sino
METERfalso
finsi
finMETER
predicado SACAR(raiz)
si( no VACIA())
qsgte(raiz)
liberar( raiz)
raizq
ii-1
SACARverdadero
Sino
SACARfalso
finsi
finSACAR
IMPLEMENTACIÓN DEL TAD

#include "iostream.h"
#include "conio.h"
class ENTERO{
int num;
public:
void IngEntero(){cout<<"\n Ingrese un entero: ";cin>>num;}
void VisEntero(){ cout<<" "<<num; }
};

class PILA{
ENTERO e;
PILA *sgte;
int tope;
int i;
public:
PILA(){}
PILA(PILA *&raiz,int TAMANO){
tope=TAMANO;
raiz=NULL;
i=0;
}
bool Ocupada(){
if (i>=tope)
return true;
else return false;
}
bool VACIA(){
if(i<=0) return true;
else return false;
}

bool METER(PILA *&raiz, ENTERO dato){

if (!Ocupada()){
PILA *n=new PILA;
n->e=dato;
if (raiz == NULL){
n->tope=1;
raiz = n;
n->sgte=NULL; }
else { n->sgte=raiz;
n->tope=raiz->tope+1;
raiz=n;
}
i++;
return true;

}
else return false;
}
bool SACAR(PILA *&raiz){
 PILA *q;
if(!VACIA()){
q=raiz->sgte;
delete raiz;
raiz=q;
i--;
return true; }
else return false;
}

void VER(PILA *raiz){

PILA *q=raiz;
while(q!=NULL){
q->e.VisEntero();
q=q->sgte;
}
getch();
}
};

int main(int argc, char *argv[]){

char op;
ENTERO dato;

PILA *raiz=NULL;
PILA p(raiz,3);
for(;;){
cout<<"\n Poner <1>\n Quitar <2>\n Ver <3>\n Salir <4>";
op=getch();
switch(op){
case '1': dato.IngEntero();
if(p.METER(raiz,dato)) cout<<"se ingreso correctamente";
else cout<<"la pila esta llena";
break;
case '2': if(p.SACAR(raiz)) cout<<"se retiro correctamente";
else cout<<"\n La pila esta vacia";
break;
case '3': p.VER(raiz);break;
case '4': return 0;
}
}
}
Colas

Definición

Una cola es una estructura de datos de acceso restrictivo a sus elementos. Un ejemplo
sencillo es la cola del cine o del autobús, el primero que llegue será el primero en entrar, y
afortunadamente en un sistema informático no se cuela nadie salvo que el programador lo
diga.

Las colas serán de ayuda fundamental para ciertos recorridos de árboles y grafos.

Las colas ofrecen dos operaciones fundamentales, que son encolar (al final de la cola) y
desencolar (del comienzo de la cola). Al igual que con las pilas, la implementación de las
colas suele encapsularse, es decir, basta con conocer las operaciones de manipulación
de la cola para poder usarla, olvidando su implementación interna

Manejo de la cola: PEPS(FIFO)

• La inserción y extracción de elementos de la cola siguen el principio FIFO (first-in-
first-out).
• El elemento con más tiempo en la cola es el que puede ser extraído.

Operaciones con colas: Push, Pop

• Las operaciones básicas de una cola son “enqueue” (meter) y “dequeue” (sacar)
o enqueue: añade un nuevo elemento a final de la cola
o dequeue: elimina (saca) el primer elemento de la cola
• Otras operaciones usualmente incluidas en el tipo abstracto COLA son:
o EstaVacia (estáVacia): verifica si la cola está vacía
o EstaLLenal (estáLlena): verifica si la cola está llena

Implementación de colas con arreglos

• Una cola es una colección ordenada de objetos.
• En C, los arreglos permiten almacenar colecciones ordenadas.
• Misma desventaja: los arreglos tienen tamaño fijo.
• Uso eficiente mediante un arreglo circular.
Aplicaciones de colas
• En general, operaciones en redes de computadoras
o Trabajos enviados a una impresora
o Solicitudes a un servidor.
• Clientes solicitando ser atendidos por una telefonista
• Simulaciones de cualquier situación real en la que se presente una “organización”
tipo cola.
• Estas entidades corresponden a lo que en matemáticas se conoce como líneas de
espera, y su estudio teórico, conocido como teoría de colas, es muy importante en
transporte y telecomunicación (una modalidad de transporte).

PRIMITIVAS USADAS POR LAS PILAS Y COLAS

 Meter
 Sacar
 EstaOcupada
 EstaVacia

Ejemplo 2

Escriba un programa que permita implementar una cola de datos enteros.

ESPECIFICACIÓN DEL TAD Y LOS ALGORITMOS

Especificacion ENTERO
variable
num: entero
operaciones
IngEntero : no retorna valor
VisEntero : no retorna valor
ecuaciones
IngEntero lee los datos de un valor entero
VisEntero visualiza los datos del valor entero
finespecificacion

Especificacion COLA
variable
e: ENTERO
sgte:COLA
tope: entero
i: entero
operaciones
CREAR : no retorna valor
CREAR(raiz, TAMANO) : no retorna valor
Ocupada : retorna valor logico
VACIA : retorna valor logico
METER(raiz, dato) : retorna valor logico
 SACAR(raiz) : retorna valor logico
VER(raiz) : no retorna valor
ecuaciones
CREAR permite crear un nodo
CREAR(raiz, TAMANO) permite crear la cola asignando un tamaño a traves de la
variable TAMAÑO a la cola con cabecera raiz.
Ocupada retorna verdadero si la cola llego al tope de su tamaño, en caso contrario
retorna falso
VACIA retorna verdadero si la cola esta vacia, en caso contrario retorna falso.
METER(raiz, dato) retorna verdadero si el TAD dato se ingreso correctamente a la
cola con cabecera raiz, en caso contrario retorna falso.
SACAR(raiz) retorna verdadero si el TAD de la parte del frente de la cola con
cabecera raiz se saco correctamente, en caso contrario retorna falso.
VER(raiz) permite visualizar los datos de la cola con cabecera raiz
finespecificacion

predicado Ocupada
si (i>=tope)
Ocupadaverdadero
Sino
Ocupadafalso
Finsi
finOcupada
predicado VACIA
si(i<=0)
VACIAverdadero
Sino
VACIAfalso
finsi
finVACIA

predicado METER(raiz, dato)

si (no Ocupada())
crear(n)
asignar(n,dato)
si (raiz = nulo)
raiz  n
sino
qraiz
mientras (sgte(q) nulo )
hacer
qsgte(q)
finhacer
sgte(q)n
finsi
sgte(n)nulo
ii+1
METERverdadero
 sino
METERfalso
finsi
finMETER
predicado SACAR(raiz)
si( no VACIA())
qsgte(raiz)
liberar( raiz)
raiz=q
ii-1
SACARverdadero
Sino
SACARfalso
finsi
finSACAR

IMPLEMENTACIÓN DEL TAD

#include "iostream.h"
#include "conio.h"
class ENTERO{
int num;
public:
void IngEntero(){cout<<"\n Ingrese un entero: ";cin>>num;}
void VisEntero(){ cout<<" "<<num; }
};

class COLA{
ENTERO e;
COLA *sgte;
int tope;
int i;
public:
COLA(){}
COLA(COLA *&raiz,int TAMANO){
tope=TAMANO;
raiz=NULL;
i=0;
}
bool Ocupada(){
if (i>=tope)
return true;
else return false;
}
bool VACIA(){
if(i<=0) return true;
else return false;
}

bool METER(COLA *&raiz, ENTERO dato){

COLA *q;
if (!Ocupada()){
 COLA *n=new COLA;
n->e=dato;
if (raiz == NULL) raiz = n;
else {
q=raiz;
while(q->sgte!=NULL) q=q->sgte;
q->sgte=n;
}
n->sgte=NULL;
i++;
return true;
}
else return false;
}
bool SACAR(COLA *&raiz){
COLA *q;
if(!VACIA()){
q=raiz->sgte;
delete raiz;
raiz=q;
i--;
return true; }
else return false;
}

void VER(COLA *raiz){

COLA *q=raiz;
while(q!=NULL){
q->e.VisEntero();
q=q->sgte;
}
getch();
}
};

int main(int argc, char *argv[]){

char op;
ENTERO dato;

COLA *raiz=NULL;
COLA p(raiz,3);
for(;;){
cout<<"\n Poner <1>\n Quitar <2>\n Ver <3>\n Salir <4>";
op=getch();
switch(op){
case '1': dato.IngEntero();
if(p.METER(raiz,dato)) cout<<"se ingreso correctamente";
else cout<<"la cola esta llena";
break;
case '2': if(p.SACAR(raiz)) cout<<"se retiro correctamente";
else cout<<"\n La cola esta vacia";
break;
case '3': p.VER(raiz);break;
case '4': return 0;
 }
}
}
VENTAJAS Y DESVENTAJAS DE LAS PILAS Y COLAS

La ventajas o desventajas se dan en funcion de la estructura con la cual son

implementadas.

3. REQUERIMIENTOS DE MATERIAL Y EQUIPO

 Software Dev C++

 1 Diskete

4. PROCEDIMIENTO

El procedimiento consiste en dos pasos

 Especificación del TAD
 Implementación del TAD

Ejercicio 1

Una pila con capacidad para 10 números enteros como máximo, tiene las siguientes operaciones:

 Retirar elemento (se retira de manera automática)

 Retirar elemento que no este en la cima de la pila
 Poner elemento

Cuando se retira un numero que no este en la cima debe primero leerse el numero que se va a retirar, si el
numero buscado se encuentra en la cima de la pila debe generarse el siguiente mensaje de error:

Operación incorrecta, habilitada solo para números que no estén en la cima

En este caso el número no se retira de la pila. Pero si el número no se encuentra en la cima de la pila debe
primero retirarse los números encima del número que se quiere retirar para poder retirar recién el número
indicado y luego deben retornar a la pila los números que estaban encima del número que se fue. Por
ejemplo:

Pila principal

20 cima

15
Cada vez que su programa retire un
elemento como el valor 11 que no esta 11
en la cima de la pila, su programa debe
visualizar la siguiente información: 12
fondo

Pila auxiliar pila principal

15

20
 12
Presione <enter> para mostrar la pila actualizada
cima
20

15

12
fondo

Presione <enter> para continuar

NOTA
 Implemente la pila en C usando asignación dinamica

ESPECIFICACIÓN DEL TAD Y LOS ALGORITMOS

Especificacion ENTERO
variable
num: entero
operaciones
IngEntero : no retorna valor
VisEntero : no retorna valor
RetEntero : retorna un valor entero

ecuaciones
IngEntero lee los datos de un valor entero
VisEntero visualiza los datos del valor entero
finespecificacion

Especificacion PILA
variable
e: ENTERO
sgte:PILA
raiz: PILA
tope: entero
i: entero
operaciones
CREAR : no retorna valor
CREAR(TAMANO) : no retorna valor
Ocupada : retorna valor logico
VACIA : retorna valor logico
METER(dato) : retorna valor logico
SACAR() : retorna valor logico
VER() : no retorna valor
RetCima(valor): retorna valor logico
RetLongitud : retorna un entero
RetElemento(max, valor) : no retorna valor
 ExtraerElemento(aux, prin, dato): retorna valor lógico
ecuaciones
CREAR permite crear un nodo
CREAR(raiz, TAMANO) permite crear la pila asignando un tamaño a traves de la
variable TAMAÑO a la pila con cabecera raiz.
Ocupada retorna verdadero si la pila llego al tope de su tamaño, en caso contrario
retorna falso
VACIA retorna verdadero si la pila esta vacia, en caso contrario retorna falso.
METER(raiz, dato) retorna verdadero si el TAD dato se ingreso correctamente a la
pila con cabecera raiz, en caso contrario retorna falso.
SACAR(raiz) retorna verdadero si el TAD de la cima de la pila con cabecera raiz se
saco correctamente de la pila, en caso contrario retorna falso.
VER(raiz) permite visualizar los datos de la pila con cabecera raiz
RetCima(valor) retorna un valor de verdad si la pila esta vacia, de lo contrario
retorna falso. Si la pila tiene algun dato valor retorna el dato que esta en la cima
RetLongitud retorna un entero que indica el tamaño de la pila
RetElemento(max, valor) según la posición de un elemento indicado por max,
devuelve en valor el dato que esta en esa posición de la pila
ExtraerElemento(aux, prin, dato) retorna un valor de verdad si la extracción de un
elemento fue correcta, de lo contrario devuelve falso. La funcion para operar
necesita como entrada dos pilas y la información del dato a extraer.

finespecificacion

predicado ExtraerElemento(aux, prin, dato)

SALIR falso
si(prin.RetCima(valor))
si(valor.RetEntero() dato.RetEntero())
j0
mientras ((j<prin.RetLongitud()) y no SALIR)
hacer
prin.RetElemento(j,valor)
si (dato.RetEntero()=valor.RetEntero())
SALIR verdadero
sino
jj+1
finsi
finhacer
si(SALIR=verdadero)
jprin.RetLongitud() -j
t  prin.RetLongitud() -j
k0
mientras(k<t)
hacer
prin.RetCima(valor)
aux.METER(valor)
prin.SACAR()
kk+1
finhacer
aux.VER()
prin.SACAR()
prin.VER()
k0
 mientras(k<t)
hacer
aux.RetCima(valor)
prin.METER(valor)
aux.SACAR()
kk+1
finhaer
aux.VER()
prin.VER()
sino
escribir " ERROR: el dato no existe en la PILA"
finsi
sino
escribir " ERROR: el dato esta en la cima"
finsi
sino
escribir " ERROR: pila vacia"
finExtraerElemento

IMPLEMENTACIÓN DEL TAD

#include "iostream.h"
#include "conio.h"
class ENTERO{
int num;
public:
void IngEntero(){cout<<"\n Ingrese un entero: ";cin>>num;}
void VisEntero(){ cout<<" "<<num; }
int RetEntero(){ return num; }
};

class PILA{
ENTERO e;
PILA *sgte,*raiz;
int tope;
int i;
public:
PILA(){}
PILA(int TAMANO){
tope=TAMANO;
raiz=NULL;
i=0;
}
bool Ocupada(){
if (i>=tope)
return true;
else return false;
}
bool VACIA(){
if(i<=0) return true;
else return false;
}
bool METER(ENTERO dato){
if (!Ocupada()){
PILA *n=new PILA;
n->e=dato;
if (raiz == NULL){
n->tope=1;
raiz = n;
n->sgte=NULL; }
else { n->sgte=raiz;
n->tope=raiz->tope+1;
raiz=n;
}
i++;
return true;

}
else return false;
}
bool SACAR(){
PILA *q;
if(!VACIA()){
q=raiz->sgte;
delete raiz;
raiz=q;
i--;
return true; }
else return false;
}

void VER(){
PILA *q=raiz;
cout<<"\n";
while(q!=NULL){
q->e.VisEntero();
q=q->sgte;
}
}
bool RetCima(ENTERO &valor){
if(raiz!=NULL){
valor=raiz->e;
return true;
}
else return false;
}
int RetLongitud(){ return i; }
void RetElemento(int max, ENTERO &valor){
PILA *q=raiz;
for(int k=0; k<max; k++)
q=q->sgte;
valor=q->e;
}
bool ExtraerElemento(PILA &aux, PILA &prin, ENTERO dato){
int t,k,j;
ENTERO valor;
bool SALIR=false;
if(prin.RetCima(valor)){
if(valor.RetEntero()!=dato.RetEntero()){
j=0;
while ((j<prin.RetLongitud()) && !SALIR){
prin.RetElemento(j,valor);
if(dato.RetEntero()==valor.RetEntero()) SALIR =true;
else j++;
}

if(SALIR){
j= prin.RetLongitud()-j;
cout<<"\n long="<<prin.RetLongitud()<<" j="<<j;
t = prin.RetLongitud()-j;
k=0;
while(k<t){
prin.RetCima(valor);
aux.METER(valor);
prin.SACAR();
k++;
}
cout<<"\n ESTADO INICIAL DE PILAS AUXILIAR Y PRINCIPAL t="<<t;
aux.VER();
prin.SACAR();
prin.VER();
k=0;
while(k<t){
aux.RetCima(valor);
prin.METER(valor);
aux.SACAR();
k++;
}
cout<<"\n ESTADO FINAL DE LAS PILAS AUXILIAR Y PRINCIPAL";
aux.VER();
prin.VER();
getch();
return SALIR;
}
else
cout<<"\n ERROR: el dato no existe en la PILA";
}
else
cout<<"\n ERROR: el dato esta en la cima";

}
else
cout<<"\n ERROR: pila vacia";
getch();
return SALIR;
 }
};

int main(int argc, char *argv[]){

char op;
ENTERO dato;
PILA p(5),aux(5);
for(;;){
cout<<"\n Poner <1>\n Quitar <2>\n Quitar2 <3>\n Ver <4>\n Salir <5>";
op=getch();
switch(op){
case '1': dato.IngEntero();
if(p.METER(dato)) cout<<"se ingreso correctamente";
else cout<<"la pila esta llena";
break;
case '2': if(p.SACAR()) cout<<"se retiro correctamente";
else cout<<"\n La pila esta vacia";
break;
case '3': dato.IngEntero();
if (p.ExtraerElemento(aux,p, dato))
cout<<"\n se retiro correctamente ";
else cout<<"\n no se retiro correctamente";
getch();
break;
case '4': p.VER();break;
case '5': return 0;
}
}
}

Ejercicio 2

Cree Ud el algoritmo y el programa en C de una pila que permita guardar palabras. Ud

elige el tamaño de la pila. La pila debe controlar que no se sobrepase el tope si intenta
ingresar una palabra que sobrepase el tamaño de la pila o que no se intente sacar una
palabra cuando la pila este vacía. Puede usar arreglos o listas dinámicas para
implementar la estructura.

Por ejemplo
Para una pila de tamaño 10, puede ingresar la palabra UNO, luego CUANDO pero
si intenta ingresar la palabra TRES no podrá porque sobrepasa el tamaño. Si aplica
la operación sacar la palabra inmediata a salir será CUANDO

FONDO CIMA

U N O C U A N D O
Ejercicio 3

Escriba un programa en C que implemente una pila con las siguientes características. Los elementos a
empilar son varias cadenas de tres tipos de longitud. Los de longitud 1 contienen la cadena “1”, los de
longitud 2 contienen la cadena “22” y los de longitud 3 contienen la cadena “333”. La pila tendrá un tamaño
máximo de 5 caracteres. Observe un ejemplo de una secuencia de posibles operaciones.

vacía

push push
push push push 2 pop pop
22 22
333 333 22
no podrá 2 2
3 ya que 3 3 3 2
supera la
3 pila 3 3 3 2 2
3 3   
3 3 2 2

Observación:
 La pila debe implementar las operaciones básicas y emitir mensajes de error cuando se
produzca algo incorrecto
 La implementación puede ser hecha con arreglos o listas enlazadas dinámicamente.

Ejercicio 4

Se desea crear el algoritmo y el programa que permita crear una cola basado en dos pilas

Cuando queremos ingresar los datos(enteros), se ingresaran a la pila A

Cuando queremos realizar la extracción de un elemento, vaciamos el contenido de la pila A a la pila B, de

manera que el primer elemento que se encuentra en el fondo de la pila A será el ultimo elemento de la pila
B, de esta forma extraemos de la pila B el elemento que esta en la cima, el cual es el primer elemento que
se ingreso en A, cumpliendo así con la política de las pilas(ultimo en entrar, primero en salir), finalmente
volvemos a vaciar el contenido de la pila B a la pila A.

Por ejemplo

Suponemos que hemos ingresado algunos datos a la pila y cuando sacamos un valor realizamos tres pasos

pila A pila A pila B pila A pila B pila A pila B

9 8
10 5 5 9
5 10 10 10
8 9 9 5

Paso 2 Paso 3
Ejercicio 5 Paso 1

Una cola medieval se comporta como una cola ordinaria, con la única diferencia de que los elementos
almacenados en ella se dividen en dos estamentos: nobles y plebeyos. Dentro de cada estamento, los
elementos deben ser atendidos en orden de llegada; pero siempre que haya nobles en la cola, estos deben ser
atendidos antes que los plebeyos. Se pide:

Escribir un programa en C que implemente la cola medieval, especificando tipo abstracto de datos para las
colas medievales que disponga de las operaciones básicas de una cola (ingresar, retirar, preguntar si esta
vacía o llena). La implementación puede ser hecha con arreglos o listas enlazadas dinámicamente.

Ejercicio 6

Cree un programa para una agencia de empleos en el cual su base de datos que es una lista simple dinamica
sirve para registrar a las personas que vienen con sus curriculos. Esta lista que es la principal tiene un limite
maximo de 5 personas, asi que cuando se supera ese tamaño los que no alcanzan van a una cola de espera
que tambien es una lista simple dinamica sin limite de tamaño. Cuando hay un empleo disponible sale de la
lista principal el primero que esta en espera y si hay en la cola de espera gente esperando entra a la lista
principal.

5. ANALISIS DE RESULTADOS

 Son estructuras dinamicas

 Se diferencian en la forma de ingresar los datos, mientras en la pila el ultimo dato
que entra es el primero que sale, en una cola el primero que entra es el primero
que sale.
 Tanto pilas y colas tienen cuatro operaciones basicas como meter(push),
sacar(pop), preguntar si la estructura esta llena y preguntar si la estructura esta
vacia

6. BIBLIOGRAFIA

 Estructura de Datos, Un Enfoque Algorítmico. Manuel Gallardo O., Teodomiro

Pérez C.
 Estructura de Datos en Pascal, AARON M. TENENBAUM, MOSHE J.
AUGENSTEIN
 Fundamentos de Programación, Algoritmos y Estructura de Datos. LUIS JOYANES
AGUILAR