fallo en lista enlazada alguien me puede ayudar

amg7
29 de Abril del 2010
#ifndef TIMEFIFO_HH

#define TIMEFIFO_HH




#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <sys/wait.h>



/* Declaraciones, macros, estructuras, etc */



struct elemento {

time_t t_a, t_b, t_c;

int id;

struct elemento *siguiente;

};



typedef struct elemento telemento;



// La fifo se construye mediante una lista enlazada de la cual se guarda el primer elemento.

// Al comienzo y si la lista esta vacia ese puntero debe valer NULL

struct fifo {

telemento *primero;

};



typedef struct fifo tfifo;



// Inserta en la FIFO un nuevo elemento con la informacion proporcionada (t_a, t_b, t_c, id).

void insertar_elem (tfifo *f, time_t t_a, time_t t_b, time_t t_c, int id){

telemento*paux;

telemento*nuevo=(telemento*)malloc(sizeof(telemento));
nuevo->t_a=t_a;
nuevo->t_b=t_b;

nuevo->t_c=t_c;
nuevo->siguiente=NULL;

if(f->primero==NULL){
f->primero=nuevo;
}
else{
paux=f->primero;
while(paux->siguiente!=NULL){
paux=paux->siguiente;
}
paux->siguiente=nuevo;
}

}

// Devuelve un puntero al elemento mas antiguo insertado en la lista con el id indicado

// LA FIFO NO SE MODIFICA TRAS ESTA LECTURA

// En caso de no existir ningun elemento con ese id, se devuelve NULL

// Si id=-1 lee el elemento más nuevo de la lista

// Si id = 0 lee el elemento más antiguo de la lista

telemento *leer_elem (tfifo *f, int id){

telemento*paux;

if(f->primero==NULL){
return NULL;
}
if(id==-1){
paux=f->primero;
while(paux->siguiente!=NULL){
paux=paux->siguiente;
}
return paux;
}
else if(id==0){
return f->primero;
}
else{
paux=f->primero;
while(paux->siguiente!=NULL){
if(paux->id==id){
return paux;
}
paux=paux->siguiente;
}
return NULL;
}


}

// Borra de la fifo el elemento mas antiguo insertado con el id indicado, en caso de existir

// Debe liberar la memoria del elemento

//Si id=-1 borra el elemento más nuevo de la lista.

// Si id = 0 borra el elemento más antiguo de la lista

void borrar_elem (tfifo *f, int id){

telemento*paux;
telemento*paux2;

paux=leer_elem(f,id);

if(paux!=NULL){
if(f->primero->siguiente==NULL){
f->primero=NULL;
}
else{
if(paux==f->primero){
f->primero=paux->siguiente;
}
else if(paux->siguiente==NULL){
paux2=f->primero;
while(paux2->siguiente!=paux){
paux2=paux2->siguiente;
}
paux2->siguiente=NULL;
}
else{
paux2=f->primero;
while(paux2->siguiente!=paux){
paux2=paux2->siguiente;
}
paux2->siguiente=paux->siguiente;
}
}
free(paux);
}

}

// Muestra todo el contenido de la fifo. Funcion con fines de depuracion. Cada grupo debe

// implementarla segun su criterio.

void ver_fifo (tfifo *fifo_datos){
telemento*paux;
struct tm *tlocal;
char output[128];
paux,fifo_datos->primero;

while(paux!=NULL){
tlocal=localtime(&paux->t_a);
strftime(output,strlen(output),"%a %b %d %H:%M:%S\n",tlocal);
printf("t_a:%s\n",output);


tlocal=localtime(&paux->t_b);
strftime(output,strlen(output),"%a %b %d %H:%M:%S\n",tlocal);
printf("t_b:%s\n",output);


tlocal=localtime(&paux->t_c);
strftime(output,strlen(output),"%a %b %d %H:%M:%S\n",tlocal);
printf("t_c:%s\n",output);

printf("ID: %d\n",paux->id);
paux=paux->siguiente;
}
}

// Borra todos los elementos de la fifo, liberando toda la memoria ocupada

void vaciar_fifo (tfifo *fifo_datos){

telemento*paux1;
telemento*paux2;

if(fifo_datos->primero!=NULL){
paux2=fifo_datos->primero;
paux1=paux2->siguiente;
while(paux1!=NULL){
free(paux2);
paux2=paux1;
paux1=paux2->siguiente;
}
free(paux2);
fifo_datos->primero=NULL;
}

}



#end


el fallo que me da es el siguiente:
al insertar y extraer elemento de lista vacia... no encuentra el elemento. No apunta a NULL el primer elemento al quedar la lista vacia

tortuperro
30 de Abril del 2010
#include "listasdinamicas.h" #include using namespace std; Lista::Lista () { inicio = NULL; fin = NULL; pto = NULL; } Lista::Lista (const Lista& orig) { if (! Copiar (orig)) cerr info = x; pto->sig = aux; if ( pto == fin ) //caso particular fin = aux; pto = aux; } } return (ok); } bool Lista::Eliminar () { Puntero aux; bool ok; if ( (pto == NULL) || ListaVacia() ) ok = false; else { ok = true; if (pto == fin) //no hay nada detr? { if (pto == inicio) //es el nico { delete pto; inicio = fin = pto = NULL; } else { aux = inicio; //buscar el penfin while ( aux->sig != fin ) aux = aux->sig; fin = aux; fin->sig = NULL; delete pto; pto = NULL; } } else { //caso normal aux = pto->sig; *pto = *aux; if (aux == fin) fin = pto; delete aux; } } return (ok); } bool Lista::Consultar (Valor& x) { bool ok; if ((pto == NULL) || ListaVacia()) ok = false; else { ok = true; x = pto->info; } return (ok); } bool Lista::ListaVacia () { return ( inicio == NULL ); } void Lista::IrInicio() { pto = inicio; } void Lista::IrUltimo() { pto = fin; } bool Lista::Avanzar() { bool ok; if ( pto == NULL ) ok = false; else { ok = true; pto = pto->sig; } } bool Lista::Retroceder() { bool ok; Puntero aux; if ( pto == inicio ) ok = false; else { ok= true; if ( pto == NULL) pto = fin; else { aux = inicio; //buscar el anterior while ( aux->sig != pto ) aux = aux->sig; pto = aux; } } return (ok); } bool Lista::FinalLista() { return ( pto == NULL ); } bool Lista::Copiar (const Lista& orig) { Puntero aux, dup; aux = orig.inicio; while ( aux != NULL ) { dup = new Nodo; dup->info = aux->info; dup->sig = NULL; if (inicio == NULL) //si vacia inicio = dup; else //detras del fin fin->sig = dup; fin = dup; //siempre es el fin if ( aux == orig.pto ) //fijar pto. de interes pto = dup; aux = aux->sig; } return true; } void Lista::Vaciar () { pto =inicio; while ( Eliminar() ); } bool Lista::Mezclar(Lista lista1, Lista lista2) { lista1.pto = lista1.inicio; lista2.pto = lista2.inicio; while(lista1.pto != NULL && lista2.pto != NULL) { if(lista1.pto -> info info) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } else { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } while(lista1.pto != NULL) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } while(lista2.pto != NULL) { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } /*********************************/ /*este es el listasdinamicas.h */ #ifndef _LISTA_H_ #define _LISTA_H_ //Declaracion del tipo base de la lista //Si el tipo base cambia es preciso modificar esta linea typedef int Valor; class Lista { public: //Constructores, destructor y asignacion Lista (); Lista (const Lista&); ~Lista(); const Lista& operator= (const Lista&); //Operaciones con datos: //Insertar (Valor): Inserta el Valor delante del pto de interes //devuelve false si no hay memoria suficiente bool Insertar (Valor); //Eliminar(): Elimina el Valor del pto de interes //devuelve false si el pto de interes es nulo bool Eliminar (); //Consultar (Valor&): Recupera el Valor del pto de interes //y lo almacena en el argumento por referencia //devuelve false si el pto de interes es nulo bool Consultar (Valor&); //ListaVacia(): Indica si la lista no tiene elementos //devuelve true si la lista esta vacia bool ListaVacia(); //Operaciones con el pto. de interes: //IrInicio(): Desplaza el pto. de interes al primer elemento //de la lista void IrInicio(); //IrUltimo(): Desplaza el pto. de interes al ultimo elemento //de la lista void IrUltimo(); //Avanzar(): Desplaza el pto. de interes al siguiente elemento //de la lista. Es posible ir una posicion mas alla del ultimo //Devuelve false si el pto. de interes es nulo y no es posible //seguir avanzando bool Avanzar(); //Retroceder(): Desplaza el pto. de interes al anterior elemento //de la lista. No es posible retroceder mas atras del primer elemento //Devuelve false si el pto. de interes es el inicio bool Retroceder (); //FinalLista(): Indica si el pto. de interes ha sobrepasado //la posicion del ultimo elemento de la lista y devuelve true //en ese caso. bool FinalLista(); bool Mezclar(Lista, Lista ); private: //lista simplemente enlazada struct Nodo; typedef Nodo* Puntero; struct Nodo { Valor info; Puntero sig; }; Puntero inicio, fin; Puntero pto; bool Copiar (const Lista&); void Vaciar (); }; #endif

tortuperro
30 de Abril del 2010
/*ESPERO QUE TE SIRVA*/ #include "listasdinamicas.h" #include using namespace std; Lista::Lista () { inicio = NULL; fin = NULL; pto = NULL; } Lista::Lista (const Lista& orig) { if (! Copiar (orig)) cerr info = x; pto->sig = aux; if ( pto == fin ) //caso particular fin = aux; pto = aux; } } return (ok); } bool Lista::Eliminar () { Puntero aux; bool ok; if ( (pto == NULL) || ListaVacia() ) ok = false; else { ok = true; if (pto == fin) //no hay nada detr? { if (pto == inicio) //es el nico { delete pto; inicio = fin = pto = NULL; } else { aux = inicio; //buscar el penfin while ( aux->sig != fin ) aux = aux->sig; fin = aux; fin->sig = NULL; delete pto; pto = NULL; } } else { //caso normal aux = pto->sig; *pto = *aux; if (aux == fin) fin = pto; delete aux; } } return (ok); } bool Lista::Consultar (Valor& x) { bool ok; if ((pto == NULL) || ListaVacia()) ok = false; else { ok = true; x = pto->info; } return (ok); } bool Lista::ListaVacia () { return ( inicio == NULL ); } void Lista::IrInicio() { pto = inicio; } void Lista::IrUltimo() { pto = fin; } bool Lista::Avanzar() { bool ok; if ( pto == NULL ) ok = false; else { ok = true; pto = pto->sig; } } bool Lista::Retroceder() { bool ok; Puntero aux; if ( pto == inicio ) ok = false; else { ok= true; if ( pto == NULL) pto = fin; else { aux = inicio; //buscar el anterior while ( aux->sig != pto ) aux = aux->sig; pto = aux; } } return (ok); } bool Lista::FinalLista() { return ( pto == NULL ); } bool Lista::Copiar (const Lista& orig) { Puntero aux, dup; aux = orig.inicio; while ( aux != NULL ) { dup = new Nodo; dup->info = aux->info; dup->sig = NULL; if (inicio == NULL) //si vacia inicio = dup; else //detras del fin fin->sig = dup; fin = dup; //siempre es el fin if ( aux == orig.pto ) //fijar pto. de interes pto = dup; aux = aux->sig; } return true; } void Lista::Vaciar () { pto =inicio; while ( Eliminar() ); } bool Lista::Mezclar(Lista lista1, Lista lista2) { lista1.pto = lista1.inicio; lista2.pto = lista2.inicio; while(lista1.pto != NULL && lista2.pto != NULL) { if(lista1.pto -> info info) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } else { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } while(lista1.pto != NULL) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } while(lista2.pto != NULL) { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } /*********************************/ /*este es el listasdinamicas.h */ #ifndef _LISTA_H_ #define _LISTA_H_ //Declaracion del tipo base de la lista //Si el tipo base cambia es preciso modificar esta linea typedef int Valor; class Lista { public: //Constructores, destructor y asignacion Lista (); Lista (const Lista&); ~Lista(); const Lista& operator= (const Lista&); //Operaciones con datos: //Insertar (Valor): Inserta el Valor delante del pto de interes //devuelve false si no hay memoria suficiente bool Insertar (Valor); //Eliminar(): Elimina el Valor del pto de interes //devuelve false si el pto de interes es nulo bool Eliminar (); //Consultar (Valor&): Recupera el Valor del pto de interes //y lo almacena en el argumento por referencia //devuelve false si el pto de interes es nulo bool Consultar (Valor&); //ListaVacia(): Indica si la lista no tiene elementos //devuelve true si la lista esta vacia bool ListaVacia(); //Operaciones con el pto. de interes: //IrInicio(): Desplaza el pto. de interes al primer elemento //de la lista void IrInicio(); //IrUltimo(): Desplaza el pto. de interes al ultimo elemento //de la lista void IrUltimo(); //Avanzar(): Desplaza el pto. de interes al siguiente elemento //de la lista. Es posible ir una posicion mas alla del ultimo //Devuelve false si el pto. de interes es nulo y no es posible //seguir avanzando bool Avanzar(); //Retroceder(): Desplaza el pto. de interes al anterior elemento //de la lista. No es posible retroceder mas atras del primer elemento //Devuelve false si el pto. de interes es el inicio bool Retroceder (); //FinalLista(): Indica si el pto. de interes ha sobrepasado //la posicion del ultimo elemento de la lista y devuelve true //en ese caso. bool FinalLista(); bool Mezclar(Lista, Lista ); private: //lista simplemente enlazada struct Nodo; typedef Nodo* Puntero; struct Nodo { Valor info; Puntero sig; }; Puntero inicio, fin; Puntero pto; bool Copiar (const Lista&); void Vaciar (); }; #endif

tortuperro
30 de Abril del 2010
/*ESPERO QUE TE SIRVA es c++*/ #include "listasdinamicas.h" #include using namespace std; Lista::Lista () { inicio = NULL; fin = NULL; pto = NULL; } Lista::Lista (const Lista& orig) { if (! Copiar (orig)) cerr info = x; pto->sig = aux; if ( pto == fin ) //caso particular fin = aux; pto = aux; } } return (ok); } bool Lista::Eliminar () { Puntero aux; bool ok; if ( (pto == NULL) || ListaVacia() ) ok = false; else { ok = true; if (pto == fin) //no hay nada detr? { if (pto == inicio) //es el nico { delete pto; inicio = fin = pto = NULL; } else { aux = inicio; //buscar el penfin while ( aux->sig != fin ) aux = aux->sig; fin = aux; fin->sig = NULL; delete pto; pto = NULL; } } else { //caso normal aux = pto->sig; *pto = *aux; if (aux == fin) fin = pto; delete aux; } } return (ok); } bool Lista::Consultar (Valor& x) { bool ok; if ((pto == NULL) || ListaVacia()) ok = false; else { ok = true; x = pto->info; } return (ok); } bool Lista::ListaVacia () { return ( inicio == NULL ); } void Lista::IrInicio() { pto = inicio; } void Lista::IrUltimo() { pto = fin; } bool Lista::Avanzar() { bool ok; if ( pto == NULL ) ok = false; else { ok = true; pto = pto->sig; } } bool Lista::Retroceder() { bool ok; Puntero aux; if ( pto == inicio ) ok = false; else { ok= true; if ( pto == NULL) pto = fin; else { aux = inicio; //buscar el anterior while ( aux->sig != pto ) aux = aux->sig; pto = aux; } } return (ok); } bool Lista::FinalLista() { return ( pto == NULL ); } bool Lista::Copiar (const Lista& orig) { Puntero aux, dup; aux = orig.inicio; while ( aux != NULL ) { dup = new Nodo; dup->info = aux->info; dup->sig = NULL; if (inicio == NULL) //si vacia inicio = dup; else //detras del fin fin->sig = dup; fin = dup; //siempre es el fin if ( aux == orig.pto ) //fijar pto. de interes pto = dup; aux = aux->sig; } return true; } void Lista::Vaciar () { pto =inicio; while ( Eliminar() ); } bool Lista::Mezclar(Lista lista1, Lista lista2) { lista1.pto = lista1.inicio; lista2.pto = lista2.inicio; while(lista1.pto != NULL && lista2.pto != NULL) { if(lista1.pto -> info info) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } else { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } while(lista1.pto != NULL) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } while(lista2.pto != NULL) { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } /*********************************/ /*este es el listasdinamicas.h */ #ifndef _LISTA_H_ #define _LISTA_H_ //Declaracion del tipo base de la lista //Si el tipo base cambia es preciso modificar esta linea typedef int Valor; class Lista { public: //Constructores, destructor y asignacion Lista (); Lista (const Lista&); ~Lista(); const Lista& operator= (const Lista&); //Operaciones con datos: //Insertar (Valor): Inserta el Valor delante del pto de interes //devuelve false si no hay memoria suficiente bool Insertar (Valor); //Eliminar(): Elimina el Valor del pto de interes //devuelve false si el pto de interes es nulo bool Eliminar (); //Consultar (Valor&): Recupera el Valor del pto de interes //y lo almacena en el argumento por referencia //devuelve false si el pto de interes es nulo bool Consultar (Valor&); //ListaVacia(): Indica si la lista no tiene elementos //devuelve true si la lista esta vacia bool ListaVacia(); //Operaciones con el pto. de interes: //IrInicio(): Desplaza el pto. de interes al primer elemento //de la lista void IrInicio(); //IrUltimo(): Desplaza el pto. de interes al ultimo elemento //de la lista void IrUltimo(); //Avanzar(): Desplaza el pto. de interes al siguiente elemento //de la lista. Es posible ir una posicion mas alla del ultimo //Devuelve false si el pto. de interes es nulo y no es posible //seguir avanzando bool Avanzar(); //Retroceder(): Desplaza el pto. de interes al anterior elemento //de la lista. No es posible retroceder mas atras del primer elemento //Devuelve false si el pto. de interes es el inicio bool Retroceder (); //FinalLista(): Indica si el pto. de interes ha sobrepasado //la posicion del ultimo elemento de la lista y devuelve true //en ese caso. bool FinalLista(); bool Mezclar(Lista, Lista ); private: //lista simplemente enlazada struct Nodo; typedef Nodo* Puntero; struct Nodo { Valor info; Puntero sig; }; Puntero inicio, fin; Puntero pto; bool Copiar (const Lista&); void Vaciar (); }; #endif

tortuperro
30 de Abril del 2010
/*ESPERO QUE TE SIRVA es c++*/ /*este es el .cpp con los metodos*/ #include "listasdinamicas.h" #include using namespace std; Lista::Lista () { inicio = NULL; fin = NULL; pto = NULL; } Lista::Lista (const Lista& orig) { if (! Copiar (orig)) cerr info = x; pto->sig = aux; if ( pto == fin ) //caso particular fin = aux; pto = aux; } } return (ok); } bool Lista::Eliminar () { Puntero aux; bool ok; if ( (pto == NULL) || ListaVacia() ) ok = false; else { ok = true; if (pto == fin) //no hay nada detr? { if (pto == inicio) //es el nico { delete pto; inicio = fin = pto = NULL; } else { aux = inicio; //buscar el penfin while ( aux->sig != fin ) aux = aux->sig; fin = aux; fin->sig = NULL; delete pto; pto = NULL; } } else { //caso normal aux = pto->sig; *pto = *aux; if (aux == fin) fin = pto; delete aux; } } return (ok); } bool Lista::Consultar (Valor& x) { bool ok; if ((pto == NULL) || ListaVacia()) ok = false; else { ok = true; x = pto->info; } return (ok); } bool Lista::ListaVacia () { return ( inicio == NULL ); } void Lista::IrInicio() { pto = inicio; } void Lista::IrUltimo() { pto = fin; } bool Lista::Avanzar() { bool ok; if ( pto == NULL ) ok = false; else { ok = true; pto = pto->sig; } } bool Lista::Retroceder() { bool ok; Puntero aux; if ( pto == inicio ) ok = false; else { ok= true; if ( pto == NULL) pto = fin; else { aux = inicio; //buscar el anterior while ( aux->sig != pto ) aux = aux->sig; pto = aux; } } return (ok); } bool Lista::FinalLista() { return ( pto == NULL ); } bool Lista::Copiar (const Lista& orig) { Puntero aux, dup; aux = orig.inicio; while ( aux != NULL ) { dup = new Nodo; dup->info = aux->info; dup->sig = NULL; if (inicio == NULL) //si vacia inicio = dup; else //detras del fin fin->sig = dup; fin = dup; //siempre es el fin if ( aux == orig.pto ) //fijar pto. de interes pto = dup; aux = aux->sig; } return true; } void Lista::Vaciar () { pto =inicio; while ( Eliminar() ); } bool Lista::Mezclar(Lista lista1, Lista lista2) { lista1.pto = lista1.inicio; lista2.pto = lista2.inicio; while(lista1.pto != NULL && lista2.pto != NULL) { if(lista1.pto -> info info) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } else { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } while(lista1.pto != NULL) { pto = new Nodo; pto -> info = lista1.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista1.pto = lista1.pto -> sig; } while(lista2.pto != NULL) { pto = new Nodo; pto -> info = lista2.pto -> info; pto -> sig = NULL; fin -> sig = pto; fin = pto; if( inicio = NULL) inicio = pto; lista2.pto = lista2.pto -> sig; } } /*********************************/ /*este es el listasdinamicas.h */ #ifndef _LISTA_H_ #define _LISTA_H_ //Declaracion del tipo base de la lista //Si el tipo base cambia es preciso modificar esta linea typedef int Valor; class Lista { public: //Constructores, destructor y asignacion Lista (); Lista (const Lista&); ~Lista(); const Lista& operator= (const Lista&); //Operaciones con datos: //Insertar (Valor): Inserta el Valor delante del pto de interes //devuelve false si no hay memoria suficiente bool Insertar (Valor); //Eliminar(): Elimina el Valor del pto de interes //devuelve false si el pto de interes es nulo bool Eliminar (); //Consultar (Valor&): Recupera el Valor del pto de interes //y lo almacena en el argumento por referencia //devuelve false si el pto de interes es nulo bool Consultar (Valor&); //ListaVacia(): Indica si la lista no tiene elementos //devuelve true si la lista esta vacia bool ListaVacia(); //Operaciones con el pto. de interes: //IrInicio(): Desplaza el pto. de interes al primer elemento //de la lista void IrInicio(); //IrUltimo(): Desplaza el pto. de interes al ultimo elemento //de la lista void IrUltimo(); //Avanzar(): Desplaza el pto. de interes al siguiente elemento //de la lista. Es posible ir una posicion mas alla del ultimo //Devuelve false si el pto. de interes es nulo y no es posible //seguir avanzando bool Avanzar(); //Retroceder(): Desplaza el pto. de interes al anterior elemento //de la lista. No es posible retroceder mas atras del primer elemento //Devuelve false si el pto. de interes es el inicio bool Retroceder (); //FinalLista(): Indica si el pto. de interes ha sobrepasado //la posicion del ultimo elemento de la lista y devuelve true //en ese caso. bool FinalLista(); bool Mezclar(Lista, Lista ); private: //lista simplemente enlazada struct Nodo; typedef Nodo* Puntero; struct Nodo { Valor info; Puntero sig; }; Puntero inicio, fin; Puntero pto; bool Copiar (const Lista&); void Vaciar (); }; #endif

tortuperro
30 de Abril del 2010
Lo siento no se porque se ve asi