Foro de elhacker.net

Buenas a todos !!

estoy actualmete aprendiendo a implementar una lista enlazada simple y me gustaria saber como es que los punteros estan trabajando de manerar interna para poder comunicarse, si es algo sencillo en teoria pero tengo una duda que ronda en mi cabeza hace un par de minutos, estoy siguiendo un tutorial y he entendido algunas cosas como que cada nodo (usando una estructura ) tieene un puntero a otro nodo que esta en una "lista" y al final de la lista hay uno que apunta a NULL y para este aproach estoy usando c++ y plantillas , le explico un poco como tengo mi codigo:

tengo una clase llamada List esta contiene una estructura Node que contiene el dato T y el link al sugiente elemento de la estructura .... ahora en la clase tengo 2 puntero first y curr
estos contienen el dato de la cabeza (Inicio de la estructura) y curr que contiene el frente de la estructura (front )  bien en la funcion siguiente

 

 
    void insert(T f)
    {
      Node<T> *temp= new Node<T>(f);
       if(first == NULL)
       {
    	   first= temp;
    	   curr = temp;
       }
       else
       {
    	   curr->next=temp;
    	   curr = temp;
       }
    }
 

el primer if esta bien  pero esta parte en else me hace perderme por ejemeplo

     void Print(){
    	 if(first == NULL) return;
         curr = first;
    	 while( curr  )
    	 {
    		 cout << "Value is : "<< curr->date<<endl;
    		 curr = curr->next;
    	 }
     }
 

donde curr = first
toma el first pero en la funcion Insert la que se lleno fue curr por que first tiene el link de first, alguien podria explicarme eso por favor.

#include <iostream>
 
#include <string.h>
using std::cout;
using std::string;
 
template<typename T>
class List
{
private:
	template<class R>
	struct Node{
		R  date;
		Node *next;
	    Node(T t){
	    	date = t;
	    	next = NULL;
	    }
	};
 
	Node<T> *first;
	Node<T> *curr;
 
public:
 
	List(){
		first = NULL;
		curr  = NULL;
	}
    List(int d)
    {
    	Node<T> *temp= new Node<T>(d);
    	first = temp;
    	curr  = temp;
    }
 
    void insert(T f)
    {
      Node<T> *temp= new Node<T>(f);
       if(first == NULL)
       {
    	   first= temp;
    	   curr = temp;
       }
       else
       {
    	   curr->next=temp;
    	   curr = temp;
       }
    }
 
     void Print(){
    	 if(first == NULL) return;
         curr = first;
    	 while( curr  )
    	 {
    		 cout << "Value is : "<< curr->date<<endl;
    		 curr = curr->next;
    	 }
     }
 
 
     void DeleteData(int data)
     {
         	 Node<T> *delPtr = NULL;
         	 Node<T> *temp   = first;
         	 curr            = first;
 
         	 while(curr != NULL && curr->date != data)
         	 {
         		 temp = curr;
         		 curr = curr->next;
         	 }
 
         	 if(curr == NULL)
         	 {
         		cout << "this data is not in the list;";
         	 }
         	 else
         	 {
         		 delPtr = curr;
         		 curr = curr->next;
         		  temp->next = curr;
         		 if(delPtr == first)
         		 {
         			 first = first->next;
         			  temp  = NULL;
         		 }
         	     delete delPtr;
         	 }
 
     }
 
 
 
 
};
 
 
 
int main()
{
   List<int > ls;
   ls.insert(12);
   ls.insert(345);
   ls.insert(345);
   ls.DeleteData(345);
   ls.Print();
}
 
 

Bien, un detalle.

void Print(){
	if(first == NULL) return;
	curr = first;
	while( curr  )
	{
		cout << "Value is : "<< curr->date<<endl;
		curr = curr->next;
	}
}

Al acabar esa función, curr queda siendo igual a NULL. Eso te dará un error si luego tratas de hacer un insert, al tratar de hacer curr->next. Utiliza una variable a parte:

void Print(){
	if(first == NULL) return;
	Node<T> *temp = first;
	while( temp  )
	{
		cout << "Value is : "<< temp->date<<endl;
		temp = temp->next;
	}
}

Y como dato, el if lo puedesobviar si quieres (si es NULL, simplemente no entrará al while)

void Print(){
	Node<T> *temp = first;
	while( temp  )
	{
		cout << "Value is : "<< temp->date<<endl;
		temp = temp->next;
	}
}

No se si estoy entendiendo muy bien. En la función Print, quieres recorrer toda la lista. Así que, empiezas desde el primer elemento (first), y vas avanzando al siguiente (temp->next) hasta que sea NULL (final de la lista).

Perdona si no entendí bien la pregunta.