como recorrer una matriz con una lista sencillamente encadenada

[john_gato19]

hola amigos...

me he encontrado con varias maneras de hacer un recorrido a una matriz con listas c++. pero no encuentro ninguna con listas sencillas, solo aparecen listas doblemente encadenadas.

por fa ayudenme, ya que no se me ocurre nada y necesito hacerlo con listas sencillas!!!!!! ... muchas gracias muchachos.:

[t1esto]

Código C++:

//---------------------------------------------------------------------------
class Error
{
  private:
    AnsiString mensaje;
  public:
    Error(AnsiString pmensaje){mensaje = pmensaje;}
    AnsiString GetMensaje(){return mensaje;}
};
//---------------------------------------------------------------------------
template < class Tipo >
class NodoSE
{
  private:
    Tipo dato;
    NodoSE<Tipo>* siguiente;
 
  public:
    NodoSE(Tipo pdato){dato=pdato; siguiente=NULL;}
 
    Tipo GetDato(){return dato;}
    NodoSE<Tipo>* GetSiguiente(){return siguiente;}
 
    void SetDato(Tipo pdato){dato=pdato;}
    void SetSiguiente( NodoSE<Tipo>* psiguiente){siguiente = psiguiente;}
};
//---------------------------------------------------------------------------
template <class Tipo>
class ListaSE
{
  private:
     NodoSE<Tipo>* ptr_primero;
 
  public:
     ListaSE(){ptr_primero=NULL;}
                //----------------------\\
     void Adicionar(Tipo dato){
     NodoSE<Tipo>* nuevo = new  NodoSE<Tipo>(dato);
     NodoSE<Tipo>* aux=ptr_primero;
         if(ptr_primero==NULL)
           ptr_primero = nuevo;
         else
         {
         while(aux->GetSiguiente()!=NULL)
            aux=aux->GetSiguiente();
         aux->SetSiguiente(nuevo);
         }
     }
                //----------------------\\
    void Insertar(Tipo dato, int ppos){
    NodoSE<Tipo>* nuevo = new  NodoSE<Tipo>(dato);
    NodoSE<Tipo>* aux = ptr_primero;
    if(ppos == 1 && Longitud()==0)
        ptr_primero=nuevo;
    if(ppos>0 && ppos<= Longitud())
      {
        if(ppos==1)
        {
          nuevo->SetSiguiente(aux);
          ptr_primero=nuevo;
        }
        else
        {
          int cont=1;
          while(cont<ppos - 1)
           {
             aux= aux->GetSiguiente();
             cont++;
           }
          nuevo->SetSiguiente(aux->GetSiguiente());
          aux->SetSiguiente(nuevo);
        }
      }
    else
    throw new Error(" Posicion no valida ");
    }
                //----------------------\\
    int Longitud(){
    NodoSE<Tipo>* aux = ptr_primero;
    if(ptr_primero == NULL)
       return 0;
    else
    {
    int cont=1;
    while(aux->GetSiguiente()!=NULL)
    {
      aux = aux->GetSiguiente();
      cont++;
    }
    return cont;
    }
    }
                //----------------------\\
   void Eliminar(int ppos)
   {
    int cont = 1;
    NodoSE<Tipo>* aux = ptr_primero;
    NodoSE<Tipo>* aux1;
    if(ppos>0 && ppos<=Longitud())
    {
     if(ppos == 1 && ppos==Longitud())
      {
        delete aux;
        ptr_primero = NULL;
      }
      else
      {
       if(ppos == 1)
       {
         ptr_primero = aux->GetSiguiente();
         delete aux;
       }
       else
       {
         if(ppos == Longitud())
           {
             while(cont<ppos-1)
              {
                aux = aux->GetSiguiente();
                cont++;
              }
              aux1 = aux->GetSiguiente();
              delete aux1;
              aux->SetSiguiente(NULL);
           }
       }
         if(ppos>0 && ppos<Longitud())
           {
            while(cont<ppos-1)
             {
               aux=aux->GetSiguiente();
               cont++;
             }
             aux1=aux->GetSiguiente();
             aux->SetSiguiente(aux1->GetSiguiente());
             delete aux1;
            }
      }
    }
    else
    throw new Error(" Posicion no valida ");
   }
                //----------------------\\
   Tipo Obtener(int ppos){
   NodoSE<Tipo>* aux = ptr_primero;
   if(ppos>0 && ppos<=Longitud())
    {
      if(ppos == 1 && Longitud()==1)
      return aux->GetDato();
      else
      {
      int cont = 1;
      while(cont!=ppos)
      {
        aux= aux->GetSiguiente();
        cont++;
      }
      return aux->GetDato();
      }
    }
   else
   throw new Error(" Posicion no valida ");
   }
                //----------------------\\
   bool EstaVacia(){
    if(ptr_primero == NULL)
     return true;
    return false;
   }
                //----------------------\\
 
   void OrdenarLista(){
     int longitud = this->Longitud();
     for(int i=1; i<longitud; i++)
       for(int j=i+1; j<=longitud; j++){
          int oi = this->Obtener(i);
          int oj = this->Obtener(j);
          if(oi>oj){
            this->Insertar(this->Obtener(j),i);
            this->Eliminar(i+1);
            this->Insertar(oi,j);
            this->Eliminar(j+1);
          }
       }
   }
   //--------------------------------------------------------------------------
};
 

Cuidado con el ultimo metodo.