Tema: como recorrer una matriz con una lista sencillamente encadenada
Ver Mensaje Individual
  #2 (permalink)  
Antiguo 06/05/2011, 10:09
t1esto
 
Fecha de Ingreso: abril-2011
Mensajes: 3
Antigüedad: 13 años, 7 meses
Puntos: 0
Respuesta: como recorrer una matriz con una lista sencillamente encadenada
Código C++: 
Ver original
  1. //---------------------------------------------------------------------------
  2. class Error
  3. {
  4.   private:
  5.     AnsiString mensaje;
  6.   public:
  7.     Error(AnsiString pmensaje){mensaje = pmensaje;}
  8.     AnsiString GetMensaje(){return mensaje;}
  9. };
  10. //---------------------------------------------------------------------------
  11. template < class Tipo >
  12. class NodoSE
  13. {
  14.   private:
  15.     Tipo dato;
  16.     NodoSE<Tipo>* siguiente;
  17.  
  18.   public:
  19.     NodoSE(Tipo pdato){dato=pdato; siguiente=NULL;}
  20.  
  21.     Tipo GetDato(){return dato;}
  22.     NodoSE<Tipo>* GetSiguiente(){return siguiente;}
  23.  
  24.     void SetDato(Tipo pdato){dato=pdato;}
  25.     void SetSiguiente( NodoSE<Tipo>* psiguiente){siguiente = psiguiente;}
  26. };
  27. //---------------------------------------------------------------------------
  28. template <class Tipo>
  29. class ListaSE
  30. {
  31.   private:
  32.      NodoSE<Tipo>* ptr_primero;
  33.  
  34.   public:
  35.      ListaSE(){ptr_primero=NULL;}
  36.                 //----------------------\\
  37.      void Adicionar(Tipo dato){
  38.      NodoSE<Tipo>* nuevo = new  NodoSE<Tipo>(dato);
  39.      NodoSE<Tipo>* aux=ptr_primero;
  40.          if(ptr_primero==NULL)
  41.            ptr_primero = nuevo;
  42.          else
  43.          {
  44.          while(aux->GetSiguiente()!=NULL)
  45.             aux=aux->GetSiguiente();
  46.          aux->SetSiguiente(nuevo);
  47.          }
  48.      }
  49.                 //----------------------\\
  50.     void Insertar(Tipo dato, int ppos){
  51.     NodoSE<Tipo>* nuevo = new  NodoSE<Tipo>(dato);
  52.     NodoSE<Tipo>* aux = ptr_primero;
  53.     if(ppos == 1 && Longitud()==0)
  54.         ptr_primero=nuevo;
  55.     if(ppos>0 && ppos<= Longitud())
  56.       {
  57.         if(ppos==1)
  58.         {
  59.           nuevo->SetSiguiente(aux);
  60.           ptr_primero=nuevo;
  61.         }
  62.         else
  63.         {
  64.           int cont=1;
  65.           while(cont<ppos - 1)
  66.            {
  67.              aux= aux->GetSiguiente();
  68.              cont++;
  69.            }
  70.           nuevo->SetSiguiente(aux->GetSiguiente());
  71.           aux->SetSiguiente(nuevo);
  72.         }
  73.       }
  74.     else
  75.     throw new Error(" Posicion no valida ");
  76.     }
  77.                 //----------------------\\
  78.     int Longitud(){
  79.     NodoSE<Tipo>* aux = ptr_primero;
  80.     if(ptr_primero == NULL)
  81.        return 0;
  82.     else
  83.     {
  84.     int cont=1;
  85.     while(aux->GetSiguiente()!=NULL)
  86.     {
  87.       aux = aux->GetSiguiente();
  88.       cont++;
  89.     }
  90.     return cont;
  91.     }
  92.     }
  93.                 //----------------------\\
  94.    void Eliminar(int ppos)
  95.    {
  96.     int cont = 1;
  97.     NodoSE<Tipo>* aux = ptr_primero;
  98.     NodoSE<Tipo>* aux1;
  99.     if(ppos>0 && ppos<=Longitud())
  100.     {
  101.      if(ppos == 1 && ppos==Longitud())
  102.       {
  103.         delete aux;
  104.         ptr_primero = NULL;
  105.       }
  106.       else
  107.       {
  108.        if(ppos == 1)
  109.        {
  110.          ptr_primero = aux->GetSiguiente();
  111.          delete aux;
  112.        }
  113.        else
  114.        {
  115.          if(ppos == Longitud())
  116.            {
  117.              while(cont<ppos-1)
  118.               {
  119.                 aux = aux->GetSiguiente();
  120.                 cont++;
  121.               }
  122.               aux1 = aux->GetSiguiente();
  123.               delete aux1;
  124.               aux->SetSiguiente(NULL);
  125.            }
  126.        }
  127.          if(ppos>0 && ppos<Longitud())
  128.            {
  129.             while(cont<ppos-1)
  130.              {
  131.                aux=aux->GetSiguiente();
  132.                cont++;
  133.              }
  134.              aux1=aux->GetSiguiente();
  135.              aux->SetSiguiente(aux1->GetSiguiente());
  136.              delete aux1;
  137.             }
  138.       }
  139.     }
  140.     else
  141.     throw new Error(" Posicion no valida ");
  142.    }
  143.                 //----------------------\\
  144.    Tipo Obtener(int ppos){
  145.    NodoSE<Tipo>* aux = ptr_primero;
  146.    if(ppos>0 && ppos<=Longitud())
  147.     {
  148.       if(ppos == 1 && Longitud()==1)
  149.       return aux->GetDato();
  150.       else
  151.       {
  152.       int cont = 1;
  153.       while(cont!=ppos)
  154.       {
  155.         aux= aux->GetSiguiente();
  156.         cont++;
  157.       }
  158.       return aux->GetDato();
  159.       }
  160.     }
  161.    else
  162.    throw new Error(" Posicion no valida ");
  163.    }
  164.                 //----------------------\\
  165.    bool EstaVacia(){
  166.     if(ptr_primero == NULL)
  167.      return true;
  168.     return false;
  169.    }
  170.                 //----------------------\\
  171.  
  172.    void OrdenarLista(){
  173.      int longitud = this->Longitud();
  174.      for(int i=1; i<longitud; i++)
  175.        for(int j=i+1; j<=longitud; j++){
  176.           int oi = this->Obtener(i);
  177.           int oj = this->Obtener(j);
  178.           if(oi>oj){
  179.             this->Insertar(this->Obtener(j),i);
  180.             this->Eliminar(i+1);
  181.             this->Insertar(oi,j);
  182.             this->Eliminar(j+1);
  183.           }
  184.        }
  185.    }
  186.    //--------------------------------------------------------------------------
  187. };

Cuidado con el ultimo metodo.