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
#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