b1kt0r
04 de Octubre del 2004

Tengo un problema con una tarea, a ver si alguien me hace el favor de analizar mi INTENTO de hacer una lista simple circular encadenada. Ya saben, de esas listas con un solo nodo en donde el ultimo apunta al primero... Aqui les pongo el codigo para que vean donde esta mal mi codigo (pueden ser muchas cosas o talvez solo una..)




--------


// Una lista genérica de enlace simple ciruclar Estructura de datos L. Jiménez Bedoy
// Archivo ListaTemp.h
#include <iostream.h>
#include <stdlib.h>


template <class T> // La clase Nodo
class NodoTemp
{ public:
T dato;
NodoTemp<T> *sig;
NodoTemp(){sig = NULL;}
NodoTemp(T d) { dato = d; sig = NULL;}
~NodoTemp(){cout << "se borra un nodo";}
}; // fin de la clase Nodo

// La clase ListaTemp (lista con template)
template <class T>
class ListaTemp
{ private:
NodoTemp<T> *inicio;
public:
ListaTemp(){inicio=NULL;} // Constructor de una lista vacia
ListaTemp(const ListaTemp & lista);// Copyconstructor (clonador)
void forma_lista(int tam);//Agrega tam nodos a una lista vacia
void despliega(); // despliega la lista
void borra_inicio(); // PRECONDICION: La lista ya tiene datos
void agrega_inicio(T dato); // PRECONDICION: La lista ya tiene datos
void borra_final(); // PRECONDICION: La lista ya tiene datos
void agrega_final(T dato); // PRECONDICION: La lista ya tiene datos
~ListaTemp();
friend ostream& operator <<<>(ostream& out, const ListaTemp<T> &l);
ListaTemp & operator =(const ListaTemp & l);
}; // fin de la clase ListaTemp







/////////////////////////////////////////////////////////////////////










template <class T> // El CopyConstructor la lista se clona en una lista nueva
ListaTemp<T>::ListaTemp(const ListaTemp & lista) //lista= lista original
{ NodoTemp<T> *aux1 = lista.inicio, *aux2; // dos apuntadores auxiliares
if( lista.inicio != NULL) // Si la lista a clonar lista, no esta vacía
{ inicio = new NodoTemp<T>(lista.inicio->dato);
aux1 = aux1-> sig; // pasar al siguiente nodo en la lista original
}
else
inicio = NULL;

aux2 = inicio;

while( aux1 != NULL ) //Mientras no se termine la lista a copiar
{ aux2->sig = new NodoTemp<T>( aux1->dato);
aux2 = aux2->sig; // brincar en la lista copiada
aux1 = aux1->sig; // brincar en la lista original
}
}

template <class T>
void ListaTemp<T>::borra_inicio(){ // PRECONDICION: La lista ya tiene datos while (){
// solo para debug cout << inicio->dato;
NodoTemp<T> *aux = inicio; //aux debe apuntar al primer nodo
inicio = inicio->sig; // cambiar inicio al siguiente nodo
delete aux; // borrar el nodo
cout << "n nodo inicial eliminado " ;
}

template <class T>
void ListaTemp<T>::agrega_inicio(T dato){
NodoTemp<T> *aux = new NodoTemp<T>(dato); // inicio debe apuntar al nuevo nodo
aux->sig = inicio;
inicio = aux;
delete aux;
cout << endl << dato <<" insertado al inicio: ";
}

template <class T>
void ListaTemp<T>::borra_final(){ // PRECONDICION: La lista ya tiene datos
NodoTemp<T> *p = inicio, *antp = NULL; // Dos apuntadores a nodo
while ( p->sig != inicio )
{ antp=p; // antp donde esta p
p=p->sig; // brincar p al siguiente nodo
}
if (p==inicio) // Si es el único nodo
{ delete p;
inicio->dato = 0;
inicio->sig = inicio;
}
else // si hay mas de un nodo
{ delete p;
antp -> sig = inicio;
}
cout << "n Ultimo nodo borrado";
}

template <class T>
void ListaTemp<T>::agrega_final(T dato){ // PRECONDICION: La lista ya tiene datos
NodoTemp<T> *p = inicio, *aux;

while ( p->sig != inicio) // Mientras no llegue al final de la lista
p = p->sig; // brincar p al siguiente nodo

aux = new NodoTemp<T>(dato); // un Nuevo nodo
p->sig = aux; // ultimo nodo apunta al nuevo nodo
aux->sig = inicio;
cout << "nNodo insertado al final: ";
}

template <class T>
void ListaTemp<T>::forma_lista(int tam) // La lista debe estar vacía
{
T dato;
cout << "Dame un dato del tipo T para el nodo ";
cin >> dato;
inicio = new NodoTemp<T>(dato);// Que pasa si la lista no está vacía??
tam--;
NodoTemp<T> *aux = inicio;
for(;tam>0; tam--)
{ cout << "Dame un dato para el Nodo: ";
cin >> dato;
aux->sig = new NodoTemp<T>(dato);
aux = aux->sig;
}
aux->sig = inicio;
} // Fin de Forma_Lista

template <class T>
void ListaTemp<T>::despliega()
{ NodoTemp<T> *aux = inicio->sig;
cout << inicio->dato << " ";
while (aux != inicio)
{ cout << aux->dato << " " ;
aux = aux->sig;}

cout << endl;
}

template <class T> // el Killer de listas
ListaTemp<T>::~ListaTemp()
{ NodoTemp<T> *aux;
cout << "matando la lista ";
while (inicio != NULL)
{ aux = inicio->sig;
delete inicio;
inicio = aux;
cout << "n matando los nodos de la lista ";
}
}

template <class T> // para imprimir una lista en lugar de despliega()
ostream& operator <<(ostream& out, const ListaTemp<T> &l)
{ NodoTemp<T> *aux =l.inicio->sig;
out << l.inicio->dato << " ";

while (aux != l.inicio)
{ out << aux->dato << " " ;
aux = aux->sig; // brincar al siguiente nodo
}
out << endl;
return out;
}

template <class T> // Para poder igualar una lista con otra
ListaTemp<T> & ListaTemp<T>::operator =(const ListaTemp<T> &l)
{
if (this == &l) // precaución de no igualar una lista a si misma
return *this;
else // si es otra lista
{ NodoTemp<T> *aux1=inicio, *aux2;

while (aux1 !=NULL) // Destruir la posible lista existente
{ aux1 = inicio->sig;
delete inicio;
inicio = aux1;
}

if(l.inicio) // Si la lista a copiar no esta vacia
{ aux1 = l.inicio; // al primer nodo a copiar
inicio = new NodoTemp<T>(aux1->dato);
aux1 = aux1->sig; // al siguiente nodo
}
else
inicio = NULL;

aux2 = inicio;

while(aux1 != NULL) // mientras queden nodo por copiar
{ aux2->sig = new NodoTemp<T>(aux1->dato);
aux2 = aux2->sig; //mover aux2 al siguiente nodo
aux1 = aux1->sig;//mover aux1 al siguiente nodo
}
return *this; // devolver la lista nueva
}
}











//////////////////////////////////////////////////////////////7





int main(int argc, char *argv[])// ejecutar nombre n m n= #datos de la lista 1
{ // m # de datos en la lista 2
ListaTemp<int> l1; // Una lista de enteros
ListaTemp<char> l2; // Una lista de Char
int x;
cout << "enteros para la lista 1: n";
l1.forma_lista(atoi(argv[1]));
cout << "Char´s para la lista 2: n";
l2.forma_lista(atoi(argv[2]));
cout << l1 ; // Usando el operador << sobrecargado
cout << l2 ;
cout << "dame un entero: ";
cin >> x;

l1.agrega_inicio(x); cout << l1;
l1.agrega_final(x); cout << l1; // Lo agregamos al final
l1.borra_final(); l1.despliega();// Lo borramos del final
l1.borra_inicio(); cout << l1; // Lo borramos del inicio



ListaTemp<int> l3(l1); // l3 es un clon de l1
cout << "nEl Clon de la lista L1 es: n";
cout << l3;

ListaTemp<char> l4; // Una cuarta lista
l4 = l2; // L4 es una copia de l2
cout << "la Lista L4: " << l4; // Probando el operador << sobrecargado

system("PAUSE");
return 0;
}