Universidad de Oriente

Ncleo de Sucre
Escuela de Ciencias
Departamento de Matemtica
Programa de la Lic. En Informtica
Cuman - Sucre
















Profesor(a): INTEGRANTES:
Carmona Claudia P. Br. Pablo Ochoa C.I:
Br. Luis Freites C.I:
Br. Astorino Frank C.I:
Br. Ral Prada C.I:
Seccin: 01


Cuman, Junio del 2009
INTRODUCCIN


Los algoritmos recientes vienen programados con una tcnica llamada
Programacin Orientada a Objetos (P.O.O.) que se basa en un enfoque que
suministra una forma de crear programas por mdulos, por medio de la creacin
de reas de memoria particionadas para tanto datos como funciones que puedan
ser usadas como plantilla para crear bajo demanda copia de tales mdulos. Este
mtodo tiene una caracterstica llamada Tipo de Dato Abstracto (T.D.A.) el cual es
aquel tipo de dato definido por el programador que puede ser manipulado de una
manera similar a los definidos por el sistema.

Un TDA puede ser una Cola la cual es una secuencia de elementos en la
que la operacin de insercin push se realiza por un extremo inicio y la operacin
de extraccin pop por el final de la misma, y los tipos de elementos guardados en
la cola vienen determinados por el programador. Esto nos lleva a lo que es una
Bicola o tambin llamada Doble cola la cual al igual que la cola guarda los datos
de forma secuencial donde las operaciones de insercin y extraccin de datos
pueden ser realizados por ambos extremos de la cola.

Una bicola es una estructura similar a una cola doble y diariamente
podemos ver su implementamos en la vida diaria, en el trabajo que les
presentamos a continuacin se explicar lo que es una bicola, los diferentes tipos
y su uso para la resolucin de problemas de la vida real.






Bicola (Cola Doble ) y su TDA

Definicin

Una Bicola es una estructura de datos similar a una cola, pero compuesta
por un conjunto de elementos que se pueden aadir (insertar) o quitar (eliminar)
en cualquiera de sus dos extremos llamados izquierdo y derecho respectivamente.

El acceso a los datos en las colas dobles o bicolas esta nicamente
permitido desde cualquiera de sus extremos ya sean operaciones tanto de insertar
como de eliminar, a diferencia de la cola normal, en donde el acceso solo se
permite por el extremo final de la cola. Se puede decir que una bicola es una cola
bidireccional.

Debido a estas caractersticas las bicolas pueden utilizarse como pilas o
como colas, es decir, es posible practicar los mtodos PEPS (Primeras Entradas
Primeras Salidas) y UEPS (Ultimas Entradas Primeras Salidas). Esto depender
de cmo el usuario ingrese y egrese datos de la misma.

Ejemplo:


Entrada Entrada

Salida Salida


Podemos crear restricciones para manejar mejor los datos, para esto
existen bicolas con entrada restringida que son aquellas que solo permite
inserciones por uno de los extremos pero acepta las eliminaciones por los dos
extremos, y las bicolas con salidas restringidas que son las que permite
inserciones por los dos extremos, pero solo permite retirar o eliminar elementos
por uno de ellos.


Implementacin Bicola (Esttica y Dinmica)

Segn la implementacin del cdigo en el algoritmo una Bicola puede ser
clasificada como:

Bicola Esttica: son aquellas que debido a que se usan vectores o
arreglos para crear el espacio en la memoria, los cuales no pueden
modificarse despus de ser creados.

Bicola Dinmica: son aquellas en las que se utiliza asignacin dinmica de
memoria (se crea un nuevo nodo cada vez que se ingresa un dato), lo cual
permite que sea el usuario o la cantidad de memoria de la maquina quien
ponga limite a la cantidad de elementos que tendr la estructura.

Operaciones bsicas para la Bicola

Las operaciones que pueden ser ejecutadas a una bicola son bsicamente
las mismas que las de una cola con la nica diferencia de que la bicola tiene
insercin y extraccin de datos por ambos extremos.

De la misma forma podemos decir que las operaciones sobre las bicolas
estticas son las mismas que en las dinmicas pero solo hasta un cierto punto, es
necesario aclarar que al momento de la creacin de bicola esttica o creada con
un tamao establecido que indiferentemente de haber cargado o no los elementos
en ella la misma ya fue creada, a diferencia de una bicola dinmica que es creada
por asignacin dinmica de memoria que al momento de su utilizacin, acta de
manera diferente ya que como su nombre lo indica ira reservando el espacio en
memoria de forma dinmica, aclarado este punto podemos decir que se realizan
las mismas operaciones en ambas, las cuales son:

1) Verificar si la Bicola est Vaca: Se utiliza una funcin generalmente
booleana que devuelva verdadera (true)) si contiene elementos o falso
(false) en caso de estar vaca.

2) Insertar por la Derecha: crea un nodo al final de la cola, se agrega los
elementos por el final de la bicola.

3) Insertar por la Izquierda: crea un nodo en el inicio de la cola, se insertar
los elementos por el inicio de la bicola.

4) Eliminar por la Derecha: elimina un nodo del final de la cola, se eliminan
los elementos por el final de la bicola.

5) Eliminar por la Izquierda: elimina un nodo del inicio de la cola, se
eliminan los elementos por el inicio de la bicola.

6) Mostrar los elementos de la Bicola: se muestra los elementos que
contiene la estructura.

Ejemplo:
Bicola Esttica


#include<iostream.h>
#include<conio.h>
#include<stdlib.h>

int cant;

class Bicola
{
int inicio,final;
int *arreglo;
//bicola *final;
public:
void inicializar(){inicio=final=-1;}
void Ingrezar_inicio(int);
void Ingrezar_final(int);
//void mostrardato();
int quitar_inicio();
int quitar_final();
bool vacia();
bool llena();
Bicola()
{
arreglo=new int[cant];
inicio=final=-1;
}
};

void Bicola::Ingrezar_inicio(int dato)
{
if((inicio==0)&&(final==cant-1)||(final+1==inicio))
cout<<"ERROR BICOLA LLENA\n";
else
{
if(inicio==-1)
inicio=final=0;
else
{
if((inicio>0)&&(inicio-1!=final))
inicio--;
else
{
if(final!=cant-1)
inicio=cant-1;
}
}
arreglo[inicio]=dato;
}
}

/*void Bicola::mostrardato()
{
bicola* final;

if(inicio!=NULL)
{
final=inicio;
cout<<"\n\n";
while(final!=NULL)
{
final->mostrar();
cout<<" ";
final=final->retornarsig();
}
getch();
}
else
{
cout<<"\n\nAlmacen Vacio"<<endl;
getch();
}
}*/

void Bicola::Ingrezar_final(int dato)
{
if((inicio==0)&&(final==cant-1)||(final+1==inicio))
cout<<"ERROR: BICOLA LLENA\n";

else
{
if(inicio==-1)
inicio=final=0;

else
{
if(final<cant-1)
final++;
else
final=0;
}
arreglo[final]=dato;
}
}

int Bicola::quitar_final()
{
int dato;
if(inicio==-1)
{
cout<<"ERROR: LA BICOLA ESTA VACIA\n";
exit(1);
}
else
{
dato=arreglo[final];
if(final==inicio)
final=inicio=-1;
else
final--;
}

return dato;
}

int Bicola::quitar_inicio()
{
int dato;
if(inicio==-1)
{
cout<<"ERROR UNDERFLOW LA BICOLA ESTA VACIA.\n";
exit(1);
}
else
{
dato=arreglo[inicio];
if(final==inicio)
final=inicio=-1;
else
if(inicio<cant-1)
inicio++;
else
inicio=0;
}
return dato;
}

bool Bicola::vacia()
{
if(inicio==-1)
return true;
else
return false;
}

bool Bicola::llena()
{
if((inicio==0)&&(final==cant-1)||(final+1==inicio))
return true;
else
return false;
}

main()
{
cout<<"ASIGNE TAMAO A LA BICOLA: ";
cin>>cant;
Bicola bicola;

int opcion,valor;
do
{
clrscr();
cout<<"MENU PRINCIPAL\n";
cout<<"[1] Ingrezar al Final\n";
cout<<"[2] Ingrezar al Frente\n";
cout<<"[3] Eliminar el ultimo\n";
cout<<"[4] Eliminar el primero\n";
cout<<"[5] Verificar Bicola Llena\n";
cout<<"[6] Verificar Bicola Vacia\n";
cout<<"[7] Inicializar Bicola\n";
cout<<"[8] ver Bicola (no esta listo)\n ";
cout<<"[9] SALIR\n\n";
cout<<"OPCION: ";
cin>>opcion;
clrscr();
switch(opcion)
{
case 1:
cout<<"Ingrezar entero: ";cin>>valor;
bicola.Ingrezar_final(valor);
getch();
break;
case 2:
cout<<"Ingrezar entero: ";cin>>valor;
bicola.Ingrezar_inicio(valor);
getch();
break;
case 3:
cout<<"Valor Eliminado del Final: "<<bicola.quitar_final();
getch();
break;
case 4:
cout<<"Valor Eliminado del Frente:
"<<bicola.quitar_inicio();
getch();
break;
case 5:
if(bicola.llena())
cout<<"La Bicola esta llena";
else
cout<<"La Bicola aun no esta llena";
getch();
break;
case 6:
if(bicola.vacia())
cout<<"La Bicola esta Vacia";
else
cout<<"La Bicola no esta Vacia";
getch();
break;
case 7:
bicola.inicializar();
break;
}
}while(opcion!=9);
}


Bicola Dinmica:
Ejemplo:

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int numerin;

class contenedor
{
char carga[3], carga2[3];
int numero;
contenedor *sig;

public:
void ponerdato(char ingreso1[3],int numero2,char ingreso2[3])
{
strcpy(carga,ingreso1);
strcpy(carga2,ingreso2);
numero=numero2;
}

void ponerpuntero(contenedor *siguiente)
{
sig=siguiente;
}

void mostrar()
{
cout<<carga<<numero<<carga2;
}

contenedor* retornarsig()
{
return sig;
}
};

class almacen
{
contenedor* principio;
contenedor* final;

public:

almacen()
{
principio=NULL;
final=NULL;
}

void mostrardato()
{
contenedor* recorrer;

if(principio!=NULL)
{
recorrer=principio;
cout<<"\n\n";
while(recorrer!=NULL)
{
recorrer->mostrar();
cout<<" ";
recorrer=recorrer->retornarsig();
}
getch();
}
else
{
cout<<"\n\nAlmacen Vacio"<<endl;
getch();
}
}

void ingresoizq()
{
contenedor* nuevo;

nuevo=new contenedor;
numerin++;
nuevo->ponerdato("[:",numerin,":]");
nuevo->ponerpuntero(principio);
principio=nuevo;
if(final==NULL)
{
final=nuevo;
}
}

void ingresoder()
{
contenedor* nuevo;

nuevo=new contenedor;
numerin++;
nuevo->ponerdato("[:",numerin,":]");
nuevo->ponerpuntero(NULL);
if(final!=NULL)
{
final->ponerpuntero(nuevo);
final=nuevo;
}
else
{
final=nuevo;
principio=nuevo;
}
}

void extraerizq()
{
if(principio!=NULL)
{
contenedor* eliminar;
cout<<endl;

eliminar=principio;
principio=principio->retornarsig();
eliminar->ponerpuntero(NULL);
if(eliminar==final)
{
final=NULL;
}
delete eliminar;
cout<<"\n\n Carga extraida por el porton izquierdo";
getch();
}
else
{
cout<<"\n\nAlmacen Vacio"<<endl;
getch();
}
}

void extraerder()
{
if(principio!=NULL)
{
contenedor* eliminar;
eliminar=principio;
if(eliminar->retornarsig()!=NULL)
{
while(eliminar->retornarsig()!=final)
{
eliminar=eliminar->retornarsig();
}
final=eliminar;
eliminar=eliminar->retornarsig();
final->ponerpuntero(NULL);
delete eliminar;
cout<<"\n Carga extraida por el porton derecho";
getch();
}
else
{
principio=NULL;
final=NULL;
delete eliminar;
cout<<"\n Carga extraida por el porton derecho"<<endl;
getch();
}
}
else
{
cout<<"\n\nAlmacen Vacio"<<endl;
getch();
}
}
};

int main()
{
int op,repetir=0;
almacen almacen1;
numerin=0;
do
{
system("cls");
cout<<"\n MENU\n\n";
cout<<"\n 1 Ingreso de carga por el porton izquierdo del almacen";
cout<<"\n 2 Ingreso de carga por el porton derecho del almacen";
cout<<"\n 3 Extraer carga por el porton izquierdo del almacen";
cout<<"\n 4 Extraer carga por el porton derecho del almacen";
cout<<"\n 5 Mostrar todo lo almcenado";
cout<<"\n 6 Salir\n";
cout<<"\n Op:";
cin>>op;
switch(op)
{
case 1: system("cls");
almacen1.ingresoizq();
cout<<"\nCarga numero: "<<numerin<<" Almacenada por el
porton izquierdo";
getch();
break;
case 2: system("cls");
almacen1.ingresoder();
cout<<"\nCarga numero: "<<numerin<<" Almacenada por el
porton derecho";
getch();
break;
case 3: system("cls");
almacen1.extraerizq();
break;
case 4: system("cls");
almacen1.extraerder();
break;
case 5: system("cls");
almacen1.mostrardato();
break;
case 6: system("cls");
repetir=1;
break;
}

}
while(repetir!=1);
return 0;
}

Uso de las bicolas en la solucin de problemas

La programacin orientada a objetos se enfoca en las caractersticas
especficas del objeto que simula. En la vida cotidiana surgen problemas que
pueden ser resueltos a travs de algoritmos, al crear una bicola es posible simular
un problema y a travs de ella encontrar la solucin correcta al mismo.

La bicola es uno de los muchos recursos informticos para la resolucin de
problemas, como por ejemplo, esta puede ser utilizada para controlar la cantidad
de vehculos que entran y salen de un estacionamiento adems se puede adaptar
a la situacin ya que se pueden restringir accesos a la misma, de la misma forma
puede ser utilizada para controlar la cantidad de gente que entra en un vehculo de
gran tamao con 2 o menos entradas y salidas en el cual es necesario un conteo
de los pasajeros, ubicacin, en otros casos como aviones, se necesita el nombre y
otros datos, aqu se utiliza mucho un mecanismo para organizar como en una cola
de prioridades, tambin son muy tiles para llevar registros del movimiento de las
personas en un determinado ambiente; todo depende del problema a tratar y de la
mejor solucin encontrada para resolver dicho problema.

CONCLUSIN

Recordemos que la Programacion Orientada a Objetos (POO) tiende a
reflejar las caractersticas de un objeto, en el computador para resolver problemas
que surgen en torno a ese objeto fsico o incluso una situacin determinada.
Actualmente se utilizan algoritmos para resolver los problemas de la vida diaria,
entre ellos se encuentra el ya hablado anteriormente (bicola) el cual su uso es de
gran ayuda, debido a que es fcil comprender dependiendo cual sea la situacin
del problema, como puede ser utilizada una bicola para dar solucin al mismo.
.
As y de muchas otras formas podemos representar situaciones de la vida
diaria en un programa, simularlas y encontrar solucin a los problemas que traen
consigo. Entonces una bicola es simplemente una secuencia de datos con ingreso
de los mismos por ambos extremos de la bicola y es utilizada para representar un
problema en la maquina, analizarlo y darle solucin y as mejorar la eficiencia de
una solucin a un problema cotidiano.

Para finalizar, las estructuras de datos son de gran importancia al momento
del anlisis para la solucin de algn problema, y conjuntamente con la
programacin orientada a objetos que facilita el manejo de los tipos de datos
abstractos los cuales ayudan a el programados pueda establecer diferentes
patrones o datos que contienen caractersticas particulares.









BIBLIOGRAFA


Deitel, Harvey M. Como programar en C++. PEARSON EDUCACION, CIUDAD
MEXICO, MEXICO. 4a. ed. 2003

Joyanes Aguilar, Luis. Fundamentos de programacin: algoritmos y estructura de
datos.
McGRAW-HILL, MADRID, ESPAA. 1988.

http://boards4.melodysoft.com/app?ID=2005AEDI0202&msg=47

http://ji.ehu.es/maiteu/EDA/EJERCICIOS/EJERCICIOS_TADsLineales11_12.pdf

http://sistemas.itlp.edu.mx/tutoriales/estru1/25.htm