PARADIGMA
La única manera de poseer un amigo es serlo ..!!
Ralph Emerson
PARADIGMA
Qué es esto..??
Pila Lista
Pila Array
Colas
Cabecera
Altas
Buscar
Modificar
Baja
Consulta
| Volver | |
Arbol | |
Archivo | |
Agenda |
Base de Datos | |
Básico |
| Editor | |
Editor2 | |
Fibonacci | |
Hanoi | |
Listas | |
Matriz |
| Modelo 1 | |
Modelo | |
Polimorfismo |
Punteros | |
Sobrecarga | |
Vectores |
PARADIGMA
Colega virtual, aunque te parezca extraño existe una toda una "Teoría de las Colas" la cual las clasifica en:
A las colas se las conoce también como "Filas de Espera", por lo tanto ya estás imaginando el rumbo de toda esta teoría cuyo análisis matemático por suerte, corresponde a la disciplina de la "Investigación Operativa", que por cierto es muy apasionante..!!
En este link, el enfoque tanto de las colas y de las pilas es puramente algorítmico y como estructuras lineales de datos tratadas como con enlaces estáticos o mediante enlaces dinámicos.
Colega algorítmico, te ofrezco un sistema integral con las operaciones básicas y clásicas que pueden efectuarse con estas estructuras dinámicas... Ah pero ..
..no tomes la vida en serio, pues nunca saldremos vivos de ella.!!!
Los años forman una cola cíclica, porque el EXITO ES...
... si esto de las colas te huela mal, te recomiendo..
.. ahora si estas de acuerdo con la Caperucita, que afirma que el Lobo la tiene chica, entonces te recomiendo solo..
OOHH..!!
La droga te buelbe vruto.!!!
CONCEPTOS BASICOS...!!
La manera clásica para idealizar una pila es pensar en la estructura que adopta la pila de platos, donde para aumentar otro plato en ella, es necesario colocarla en la parte superior y para retirar un plato, debemos levantar el que está en la cima o en la parte superior; por ello, las pilas son estructuras de datos tipo LIFO ( último en entrar, primero en salir): el último elemento que se coloca (mete o inserta) en la pila es el primero que se quita (saca o remueve) de ella.
La pila es una versión restringida de una lista enlazada, ya que los nuevos nodos solo pueden agregarse a una pila y eliminarse de una pila desde la parte superior de ésta. El miembro de enlace del último nodo de la pila está establecido a nulo (cero) para indicar el fondo de la pila.
En el mundo de los programas informáticos las pilas tienen aplicaciones como por ejemplo, cuando se realiza una llamada de función, la función llamada debe saber la manera de regresar a su invocador, y por esto la dirección de devolución se pone en una pila. También los compiladores utilizan a las pilas en el proceso de evaluación de expresiones y en la generación de código de lenguaje de maquina.
Cuando sucede una serie de llamadas de función, los valores de devolución sucesivos se ponen en la pila en un orden último en entrar, primero en salir, para que cada función pueda regresar a su invocador. Las pilas soportan las llamadas de función recursivas en la misma forma que lo hacen con las llamadas no recursivas convencionales.
Las pilas contienen el espacio que se crea para las variables automáticas en cada llamada a una función. Cuando la función regresa a su invocador, el espacio para las variables automáticas de la función se saca de la pila, y de ésta manera el programa ya no conoce dichas variables.
Como una pila es una lista, podemos plantear dos técnicas de proceso.
Perro que ladra, no es mudo..!!!
METER Y SACAR...!!
Realiza altas (Meter) insertando al frente de la lista y la baja (Sacar) eliminando el elemento que está al frente de la lista. Una operación cima solo examina el elemento del frente de la lista, devolviendo su valor. A veces la operación sacar y cima se combinan en una. Podríamos usar llamadas a las rutinas sobre listas enlazadas.
Primero implantamos la pila con cabecera. Después se examina una pila vacía en la misma manera que una lista vacía.
La creación de una pila vacía requiere crear una cabecera con un apuntador siguiente a NULL. El meter se implanta como inserción al frente de la lista enlazada, donde el frente de la lista se conoce como cima de la pila. La cima se efectúa examinando el elemento de la primera posición de la lista. Por ultimo, implantaremos sacar eliminando el frente de la lista.
Todas las operaciones tardan un tiempo constante, por que en ninguna de las rutinas tiene referencia al tamaño de la pila ( excepto en la comprobación de si esta vacía ); tampoco se encuentra un ciclo que dependa del tamaño.
Si no eres parte de la solución eres parte del problema...!!!
ARREGLOS...!!
Es la alternativa que evita los apuntadores y probablemente es la solución mas utilizada y solo se necesita declarar el tamaño de un arreglo con anticipación. Para ello en aplicaciones típicas, aun si se tienen muy pocas operaciones con pilas, el numero de elementos en la pila no crece demasiado y siempre es fácil declarar el arreglo suficientemente grande sin desperdiciar demasiado espacio.
En el proceso con arreglos con arreglos, cada pila tiene la cima de la pila, la cual es 0 para una pila vacía. Para meter algún elemento x en la pila, se debe incrementar la cima de la pila y después se hace PILA ( cima de la pila ) = x; donde PILA es el arreglo que representa la pila real.
Para sacar, se devuelve el valor de PILA ( cima de la pila ) y después se decrementa la cima de la pila. Por supuesto, ya que puede haber varias pilas, el arreglo PILA y la cima de la pila son parte de un registro que representa una pila.
Las operaciones se realizan no solo en tiempos constantes, sino en un tiempo muy corto y en algunas maquinas, meter y sacar se pueden escribir en una sola instrucción de maquina y operar en un arreglo de direccionamiento con auto incremento y auto decremento.
Dado que la mayoría de las maquinas modernas tienen operaciones sobre pilas como parte del conjunto de instrucciones refuerza la idea de que la pila es probablemente la estructura de datos más importante en informática, después del arreglo.
Suele ocurrir que un problema del procesamiento de pilas como arreglos es la comprobación de errores; un sacar de una pila vacía o un meter en una pila llena excederá los limites del arreglo y causara una ruptura.
Si se incluyen tales comprobaciones en la implantación de arreglos podrían tomar tanto tiempo como la manipulación de la pila. Por esta razón, puede convenir omitir la comprobación de errores en las rutinas de pilas, excepto cuando el manejo de errores sea crucial, tal ocurre en los sistemas operativos.
Se puede resolver este problema declarando un tamaño de la pila suficiente para no excederlo y asegurándose de que las rutinas que usan sacar y meter nunca intenten sacar de una pila vacía.
Errar es humano y echarle la culpa al otro es mas humano todavía..!!!
Las filas de espera también llamadas colas, se producen cada vez que hacemos cola en la caja del comercio, cuando cargamos combustible en el automóvil, cuando abordamos un autobús, cuando pagamos en la caseta de cobro de la autopista; los estudiantes hacen cola para inscribirse en las materias que quieren y en los sistemas informáticos usamos internamente muchas colas de espera.
En estas estructuras de datos abstractos, los usuarios hacen altas o ponen cosas en ellas, una a la vez mediante una operación de encolamiento, y las retiran o dan de baja, un elemento a la vez por medio de una operación de desencolamiento.
Aunque en teoría la cola puede ser infinitamente grande, en la práctica, ella es finita y sus elementos se devuelven de la cola en orden de FIFO (Firts In Firts Out: primero en entrar, primero en salir): el primer elemento que entra en la cola es el primero en ser retirado de ella.
Del mismo modo que las pilas, también las colas son listas. Con una cola, no obstante, la inserción se hace por un extremo, mientras que la eliminación se realiza por el otro extremo.
Las operaciones básicas sobre una cola son encolar, que inserta un elemento al final de la lista, y dar de baja o desencolar, para eliminar el elemento del inicio de la lista o frente.
COLAS COMO ARREGLOS
Para las colas pueden aplicarse los procesos de los arreglos, usando la estructura de datos COLA[ ], y la posición Frente y Final, que representan los extremos de la cola, y Tamaño que es el numero de elementos de la cola.
Veamos el siguiente programa estructurado con fines didácticos y en el aprenderas a usar simultaneamente ambas estructuras de pila y cola, con archivo de datos.
Si no tienes experiencia en el manejo de estructuras dinámicas te recomiendo iniciar con otro link más simple, o en su defecto copia textualmente los siguientes que te propongo.
Buena suerte..!!
////////////////////////////////////////////////////// // ESTRUCTURA DINAMICA DE DATOS Wilo Carpio // MANEJO DE PILA Y COLA // C++ Builder ////////////////////////////////////////////////////// #include//Para reconocer los tipos de datos ingresados #pragma hdrstop #include #include "PilaYCola.h" //Archivo de cabecera pila y cola.h #pragma package(smart_init) #pragma resource "*.dfm" TMiFormulario *MiFormulario; struct Registro { char NombrePila[30]; // Para la pila char EmailPila[40]; // Para la pila char NombreCola[30]; // Para la cola char EmailCola[30]; // Para la cola int EstaEnPila,EstaEnCola; // Flag de borrado struct Registro *SiguientePila,*SiguienteCola; }*NodoPila,*NodoCola,*NodoAuxPila,*NodoAuxCola,*AuxCola,*CabeceraPila, *CabeceraCola ,*Ultimo,*Primero; struct Persona { char NombrePila[30]; char EmailPila[40]; char NombreCola[30]; char EmailCola[40]; }; Persona MonoPila,MonoCola; int bandera, i, j; char NombrePila[30],EmailPila[30]; char NombreCola[30],EmailCola[30]; AnsiString NombreEnPila, NombreEnCola; //////////////////////////////////////////////////////////////// //*procedimiento de busqueda para validar los datos en la pila// //////////////////////////////////////////////////////////////// int BuscarEnLaPila(AnsiString NombreEnPila) { int EstaEnLaPila=0; NodoPila=CabeceraPila; if (NodoPila!=NULL) while (NodoPila != NULL) { if ((NombreEnPila)==NodoPila->NombrePila) { EstaEnLaPila=1; break; } NodoPila=NodoPila->SiguientePila; } return(EstaEnLaPila); } /////////////////////////////////////////////////////////////// // Busqueda para validar los datos en la cola /////////////////////////////////////////////////////////////// int BuscarEnLaCola(AnsiString NombreEnCola) { int EstaEnLaCola=0; NodoCola=CabeceraCola; if (NodoCola!=NULL) while (NodoCola != NULL) { if ((NombreEnCola)==NodoCola->NombreCola) { EstaEnLaCola=1; break; } NodoCola=NodoCola->SiguienteCola; } return(EstaEnLaCola); } ///////////////////////////////////////////////////////////////////// // Liberar memoria e insertar los datos en la pila ///////////////////////////////////////////////////////////////////// void InsertarEnPila(char NombrePila[30], char EmailPila[40]) // { NodoPila=new Registro [sizeof (Registro)]; // new asigna memoria al puntero strcpy(NodoPila->NombrePila,NombrePila); // strcpy copia dos cadenas strcpy(NodoPila->EmailPila,EmailPila); NodoPila->EstaEnPila=0; //valor que sirve para la eliminacion NodoPila->SiguientePila=NULL; if (CabeceraPila == NULL) CabeceraPila = NodoPila; else { NodoPila->SiguientePila = CabeceraPila; CabeceraPila = NodoPila; } if (bandera==0) ShowMessage("Informacion registrada..!!"); } /////////////////////////////////////////////////////////////////////// // Liberar memoria e insertar los datos en la cola ///////////////////////////////////////////////////////////////////// void InsertarEnCola(char NombreCola[30], char EmailCola[30]) //*void palabra reservada que no va a apuntar a ningun tipo { NodoCola=new Registro [sizeof (Registro)]; strcpy(NodoCola->NombreCola,NombreCola); strcpy(NodoCola->EmailCola,EmailCola); NodoCola->EstaEnCola=0; //Sirve para la eliminacion NodoCola->SiguienteCola=NULL; if (CabeceraCola == NULL) { CabeceraCola = NodoCola; CabeceraCola->SiguienteCola=NULL; Primero= CabeceraCola; } else { Primero->SiguienteCola = NodoCola; NodoCola->SiguienteCola = NULL; Primero = NodoCola; } if (bandera==0) ShowMessage("Informacion Registrada"); } //--------------------------------------------------------------------------- __fastcall TMiFormulario::TMiFormulario(TComponent* Owner) : TForm(Owner) { } void __fastcall TMiFormulario::BRPAClick(TObject *Sender) { MiFormulario->PanelAutor->Visible=false; } //--------------------------------------------------------------------------- void __fastcall TMiFormulario::FormCreate(TObject *Sender) { MiFormulario->PanelAutor->Visible=false; } //--------------------------------------------------------------------------- void __fastcall TMiFormulario::Autor1Click(TObject *Sender) { MiFormulario->PanelAutor->Visible=true; }
void __fastcall TMiFormulario::Altas1Click(TObject *Sender)
{
MiFormulario->Caption=("Digita los datos de la agenda");
bandera=0;
PanelPila->Visible=true;
BoxNombreP->Clear();
BoxEmailP->Clear();
BoxNombreP->SetFocus();
BoxNombreP->SetFocus();
}
//---------------------------------------------------------------------------
//Grabar los datos en la agenda ingresados en la pila
void __fastcall TMiFormulario::BotonGrabarPClick(TObject *Sender)
{
int Mensaje;
char NombrePila[30], EmailPila[40];
if((BoxNombreP->Text!="")||(BoxEmailP->Text!=""))
{
strcpy(NombrePila,BoxNombreP->Text.c_str());
strcpy(EmailPila,BoxEmailP->Text.c_str());
if(BuscarEnLaPila(NombrePila)==0)
{
InsertarEnPila(NombrePila,EmailPila);
BoxNombreP->Clear();
BoxEmailP->Clear();
BoxNombreP->SetFocus();
}
else
{
Mensaje=Application->MessageBox("Desea ingresarlo nuevamente","Dato existente",MB_OKCANCEL);
if(Mensaje==IDOK)
{
strcpy(NodoPila->NombrePila,BoxNombreP->Text.c_str());
strcpy(NodoPila->EmailPila,BoxEmailP->Text.c_str());
BoxNombreP->Clear();
BoxEmailP->Clear();
BoxNombreP->SetFocus();
}
else
{
BoxNombreP->Clear();
BoxEmailP->Clear();
BoxNombreP->SetFocus();
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonLimpiarPClick(TObject *Sender)
//procedimiento para limpiar los box en caso de arrepentirme de haber ingresado algun dato//
{
BoxNombreP->Clear();
BoxEmailP->Clear();
BoxNombreP->SetFocus();
}
void __fastcall TMiFormulario::BotonGrabarCClick(TObject *Sender)
{
int Mensaje;
char NombreCola[30], EmailCola[40];
if((BoxNombreC->Text!="")||(BoxEmailC->Text!=""))
{
strcpy(NombreCola,BoxNombreC->Text.c_str());
strcpy(EmailCola,BoxEmailC->Text.c_str());
if(BuscarEnLaCola(NombreCola)==0)
{
InsertarEnCola(NombreCola,EmailCola);
BoxNombreC->Clear();
BoxEmailC->Clear();
BoxNombreC->SetFocus();
}
else
{
Mensaje=Application->MessageBox("Desea ingresarlo nuevamente","Dato existente",MB_OKCANCEL);
if(Mensaje==IDOK)
{
strcpy(NodoCola->NombreCola,BoxNombreC->Text.c_str());
strcpy(NodoCola->EmailCola,BoxEmailC->Text.c_str());
BoxNombreC->Clear();
BoxEmailC->Clear();
BoxNombreC->SetFocus();
}
else
{
BoxNombreC->Clear();
BoxEmailC->Clear();
BoxNombreC->SetFocus();
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Altas2Click(TObject *Sender)
{ MiFormulario->Caption=("Ingresa los datos en la agenda");
bandera=0;
PanelCola->Visible=true;
BoxNombreC->Clear();
BoxEmailC->Clear();
BoxNombreC->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonLimpiarCClick(TObject *Sender)
{
BoxNombreC->Clear();
BoxEmailC->Clear();
BoxNombreC->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonVolverCClick(TObject *Sender)
{ MiFormulario->Caption=("Agenda con Pilas y Colas");
PanelCola->Visible = false;
}
void __fastcall TMiFormulario::BotonVolverPClick(TObject *Sender)
//procedimiento para retornar al formulario principal//
{
MiFormulario->Caption=("Agenda con Pilas y Colas");
PanelPila->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Visualizacion1Click(TObject *Sender)
//procedimiento para visualizar los datos en la grilla introducidos en el procedimiento de la pila//
{
MiFormulario->Caption=("Los datos en la agenda son:");
i=1;
if(CabeceraPila==NULL)
{
Application->MessageBox("No hay datos en la lista","Atencion...",MB_OK);
}
PanelVisualizarP->Visible = true;
if (CabeceraPila!=NULL)
{
GrillaPila->Cells [0][0]="Nombre";
GrillaPila->Cells[1][0]="EmailPila";
NodoAuxPila = CabeceraPila;
while (NodoAuxPila->SiguientePila!= NULL)
{
GrillaPila->Cells[0][i]=NodoAuxPila->NombrePila;
GrillaPila->Cells[1][i]=NodoAuxPila->EmailPila;
i=i+1;
while ( GrillaPila->Cells[0][i+1]!="")
{
GrillaPila->Cells[0][i+1]="";
GrillaPila->Cells[1][i+1]="";
}
NodoAuxPila=NodoAuxPila->SiguientePila;
}
GrillaPila->Cells[0][i]=NodoAuxPila->NombrePila;
GrillaPila->Cells[1][i]=NodoAuxPila->EmailPila;
}
else
{
PanelVisualizarP->Visible = false;
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonRegresarPClick(TObject *Sender)
//procedimiento para retornar al formulario principal*//
{
MiFormulario->Caption=("Agenda con Pilas y Colas");
PanelVisualizarP->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Consultas1Click(TObject *Sender)
//*procedimiento para consultar un dato en el combo//
{
MiFormulario->Caption=("Elija el nombre a consultar");
PanelBuscarPila->Visible = true;
bandera=4; //*si es una consulta
Registro *Actual;
Actual = CabeceraPila;
ComboPila->Clear();
while (Actual!=NULL)
{
ComboPila->Items->Add(Actual->NombrePila);
Actual=Actual->SiguientePila;
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonAceptarPilaClick(TObject *Sender)
{
MiFormulario->Caption=("El nombre elegido es:");
int encontrado;
char bus[40];
AnsiString var;
encontrado=0;
NodoAuxPila=CabeceraPila;
var=ComboPila->Items->Strings[ComboPila->ItemIndex];
strcpy(bus,var.c_str());
while (NodoAuxPila !=NULL )
{ //funcion de busqueda
if (stricmp(NodoAuxPila->NombrePila,bus)==0)
{
encontrado=1;
if (bandera==1) //si es una modificacion
{
if (NodoAuxPila->EstaEnPila!=1)
{
BotonGrabarP->Visible=true;
BotonLimpiarP->Visible=true;
PanelPila->Visible=true;
PanelBuscarPila->Visible=false;
BoxNombreP->Text=NodoAuxPila->NombrePila;
BoxEmailP->Text=NodoAuxPila->EmailPila;
NodoAuxCola=NodoAuxPila;
NodoAuxPila=NULL;
}
}
else
{
if(bandera==4)
{
if (NodoAuxPila->EstaEnPila!=1)
{
BotonGrabarP->Visible=false;
BotonLimpiarP->Visible=false;
PanelPila->Visible=true;
PanelBuscarPila->Visible=false;
BoxNombreP->Text=NodoAuxPila->NombrePila;
BoxEmailP->Text=NodoAuxPila->EmailPila;
NodoAuxCola=NodoAuxPila;
NodoAuxPila=NULL;
}
}
}
}
else
NodoAuxPila=NodoAuxPila->SiguientePila;
} //fin del while
if (encontrado==0)
{
ShowMessage("La ficha que busca no ha sido ingresada");
PanelBuscarPila->Visible=false;
}
}
void __fastcall TMiFormulario::Modificaciones1Click(TObject *Sender)
{
MiFormulario->Caption=("Seleccione el nombre a modificar");
bandera=1;
PanelBuscarPila->Visible=true;
Registro *Actual;
Actual = CabeceraPila;
ComboPila->Clear();
while (Actual!=NULL)
{
ComboPila->Items->Add(Actual->NombrePila);
Actual=Actual->SiguientePila;
}
}
void __fastcall TMiFormulario::Modificaciones2Click(TObject *Sender)
{ MiFormulario->Caption=("Seleccione el nombre a modificar");
bandera=1;
PanelBuscarCola->Visible=true;
Registro *actual;
actual = CabeceraCola;
ComboCola->Clear();
while (actual!=NULL)
{
ComboCola->Items->Add(actual->NombreCola);
actual=actual->SiguienteCola;
}
}
void __fastcall TMiFormulario::Bajas1Click(TObject *Sender)
{
PanelBajaP->Visible=true;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonEliminarPilaClick(TObject *Sender)
{
NodoAuxPila=CabeceraPila;
if (CabeceraPila==NULL)
{
Application->MessageBox("No hay datos en la cola","ATENCION",+MB_OK);
}
else
{
int opcion;
opcion = Application->MessageBox("EstaEnLaPila seguro de eliminar el dato","ATENCION",+MB_OKCANCEL+MB_ICONQUESTION);
if (opcion==IDOK)
{
CabeceraPila = NodoAuxPila->SiguientePila;
delete(NodoAuxPila);
Application->MessageBox("El dato fue eliminado con exito!!!","ATENCION",+MB_OK);
}
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonRetornarPClick(TObject *Sender)
{
MiFormulario->Caption=("Agenda con Pilas y Colas");
PanelBajaP->Visible = false;
}
void __fastcall TMiFormulario::Bajas2Click(TObject *Sender)
{
PanelBajasC->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonEliminarColaClick(TObject *Sender)
{
if (CabeceraCola==NULL)
{
Application->MessageBox("No hay datos en la cola","ATENCION",+MB_OK);
}
else
{
int opcion;
opcion = Application->MessageBox("EstaEnLaPila seguro de eliminar el dato","ATENCION",+MB_OKCANCEL+MB_ICONQUESTION);
if (opcion==IDOK)
{
NodoCola = CabeceraCola;
CabeceraCola = NodoCola->SiguienteCola;
delete(NodoCola);
{
Application->MessageBox("El dato fue eliminado con exito!!!","ATENCION",+MB_OK);
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonRetornarCClick(TObject *Sender)
{ MiFormulario->Caption=("Agenda con Pilas y Colas");
PanelBajasC->Visible = false;
}
void __fastcall TMiFormulario::Visualizacion2Click(TObject *Sender)
{MiFormulario->Caption=("Los datos en la agenda son:");
i=1;
if(CabeceraCola==NULL)
{
Application->MessageBox("No hay datos en la lista","Atencion...",MB_OK);
}
PanelVisualizarC->Visible = true;
if (CabeceraCola!=NULL)
{
GrillaC->Cells [0][0]="NOMBRE";
GrillaC->Cells[1][0]="EmailPila";
NodoCola = CabeceraCola;
while (NodoCola->SiguienteCola!= NULL)
{
GrillaC->Cells[0][i]=NodoCola->NombreCola;
GrillaC->Cells[1][i]=NodoCola->EmailCola;
i=i+1;
while ( GrillaC->Cells[0][i+1]!="")
{
GrillaC->Cells[0][i+1]="";
GrillaC->Cells[1][i+1]="";
}
NodoCola=NodoCola->SiguienteCola;
}
GrillaC->Cells[0][i]=NodoCola->NombreCola;
GrillaC->Cells[1][i]=NodoCola->EmailCola;
}
else
{
PanelVisualizarC->Visible = false;
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonRegresarCClick(TObject *Sender)
{
MiFormulario->Caption=("Agenda con Pilas y Colas");
PanelVisualizarC->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Consultas2Click(TObject *Sender)
{ MiFormulario->Caption=("Elija el nombre a consultar");
PanelBuscarCola->Visible = true;
bandera=4;
Registro *actual;
actual = CabeceraCola;
ComboCola->Clear();
while (actual!=NULL)
{
ComboCola->Items->Add(actual->NombreCola);
actual=actual->SiguienteCola;
}
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonAceptarColaClick(TObject *Sender)
{ MiFormulario->Caption=("El nombre elegido es:");
int encontrado;
char bus[40];
AnsiString var;
encontrado=0;
NodoCola=CabeceraCola;
var=ComboCola->Items->Strings[ComboCola->ItemIndex];
strcpy(bus,var.c_str());
while (NodoCola !=NULL )
{ //funcion de busqueda
if (stricmp(NodoCola->NombreCola,bus)==0)
{
encontrado=1;
if (bandera==1) //si es una modificacion
{
if (NodoCola->EstaEnCola!=1)
{
BotonGrabarC->Visible=true;
BotonLimpiarC->Visible=true;
PanelCola->Visible=true;
PanelBuscarCola->Visible=false;
BoxNombreC->Text=NodoCola->NombreCola;
BoxEmailC->Text=NodoCola->EmailCola;
AuxCola=NodoCola;
NodoCola=NULL;
}
}
else
{
if(bandera==4)
{
if (NodoCola->EstaEnCola!=1)
{
BotonGrabarC->Visible=false;
BotonLimpiarC->Visible=false;
PanelCola->Visible=true;
PanelBuscarCola->Visible=false;
BoxNombreC->Text=NodoCola->NombreCola;
BoxEmailC->Text=NodoCola->EmailCola;
AuxCola=NodoCola;
NodoCola=NULL;
}
}
}
}
else
NodoCola=NodoCola->SiguienteCola;
} //fin del while
if (encontrado==0)
{
ShowMessage("La ficha que busca no ha sido ingresada");
PanelBuscarCola->Visible=false;
}
}
MODIFICACIÓN DE ARCHIVO
void __fastcall TMiFormulario::FormActivate(TObject *Sender)
{
FILE *Archivo,*Archivo1; //declaracion de un puntero a un archivo
Archivo = fopen("Pila.dat", "rb");
Archivo1 = fopen("Cola.dat", "rb"); //abre el archivo
bandera=3; //para decir que es la carga desde el archivo
while (!feof(Archivo))
{
fread(&MonoPila, sizeof(MonoPila),1,Archivo);
if(!feof(Archivo))
InsertarEnPila(MonoPila.NombrePila,MonoPila.EmailPila);
}
while (!feof(Archivo1))
{
fread(&MonoCola, sizeof(MonoCola),1,Archivo1);
if(!feof(Archivo1))
InsertarEnCola(MonoCola.NombreCola,MonoCola.EmailCola);
}
fclose(Archivo);
fclose(Archivo1);
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Salir1Click(TObject *Sender)
{
if (Application->MessageBox("Cierras la agenda?","ATENCION...!!",MB_OKCANCEL+MB_ICONQUESTION)== IDOK);
{
FILE *ArchPila,*ArchCola;
Registro *NodoPilaActual,*NodoColaActual;
ArchPila = fopen("Pila.dat","wb");
ArchCola = fopen("Cola.dat","wb");
NodoPilaActual=NodoPila;
NodoColaActual=NodoCola;
while (NodoPilaActual != NULL)
{
if (NodoPilaActual->EstaEnPila != 1)
{
strcpy(MonoPila.NombrePila,NodoPilaActual->NombrePila);
strcpy(MonoPila.EmailPila,NodoPilaActual->EmailPila);
fwrite(&MonoPila , sizeof(MonoPila),1,ArchPila);
}
NodoPilaActual=NodoPilaActual->SiguientePila;
}
while (NodoColaActual != NULL)
{
if (NodoColaActual->EstaEnCola != 1)
{
strcpy(MonoCola.NombreCola,NodoColaActual->NombreCola);
strcpy(MonoCola.EmailCola,NodoColaActual->EmailCola);
fwrite(&MonoCola , sizeof(MonoCola),1,ArchCola);
}
NodoColaActual=NodoColaActual->SiguienteCola;
}
fclose(ArchPila);
fclose(ArchCola);
Close();
}
}
void __fastcall TMiFormulario::BotonCerrarClick(TObject *Sender)
{
if (Application->MessageBox("Cierras la agenda?","ATENCION...!!",MB_OKCANCEL+MB_ICONQUESTION)== IDOK);
{
FILE *ArchPila,*ArchCola;
Registro *NodoPilaActual,*NodoColaActual;
ArchPila = fopen("Pila.dat","wb");
ArchCola = fopen("Cola.dat","wb");
NodoPilaActual=NodoPila;
NodoColaActual=NodoCola;
while (NodoPilaActual != NULL)
{
if (NodoPilaActual->EstaEnPila != 1)
{
strcpy(MonoPila.NombrePila,NodoPilaActual->NombrePila);
strcpy(MonoPila.EmailPila,NodoPilaActual->EmailPila);
fwrite(&MonoPila , sizeof(MonoPila),1,ArchPila);
}
NodoPilaActual=NodoPilaActual->SiguientePila;
}
while (NodoColaActual != NULL)
{
if (NodoColaActual->EstaEnCola != 1)
{
strcpy(MonoCola.NombreCola,NodoColaActual->NombreCola);
strcpy(MonoCola.EmailCola,NodoColaActual->EmailCola);
fwrite(&MonoCola , sizeof(MonoCola),1,ArchCola);
}
NodoColaActual=NodoColaActual->SiguienteCola;
}
fclose(ArchPila);
fclose(ArchCola);
Close();
}
}
IMPRIMIR
void __fastcall TMiFormulario::PrintDialogClick(TObject *Sender)
{
int respuesta;
{
respuesta=Application->MessageBox("Tu impresora Está prendida?","Atencion",MB_OKCANCEL);
if (respuesta==IDOK)
PrintDialog1->Execute();
}
}