Tema: Duda con punteros
Ver Mensaje Individual
  #5 (permalink)  
Antiguo 29/07/2011, 03:07
Checho360
 
Fecha de Ingreso: marzo-2011
Mensajes: 94
Antigüedad: 13 años, 7 meses
Puntos: 3
Respuesta: Duda con punteros
Perdon joder valla día.... me cagoen to lo escribo mal 10 veces igual... mira te copio el código de lo que hice y ya esta:

Código C: 
Ver original
  1. /*Esta funcion sirve para eliminar un nodo de un ABB de forma recursiva:
  2.  
  3.  
  4. int eliminar_nodo ( ptrNuevoArbol * ptrRaiz, int elemento ){
  5.     
  6.     if ( *ptrRaiz == NULL ){
  7.          
  8.          return 0;
  9.          
  10.     }
  11.     
  12.     else if ( (*ptrRaiz)->nodo > elemento ){
  13.          
  14.          return ( eliminar_nodo ( &((*ptrRaiz)->ptrIzq), elemento ) );
  15.          
  16.     }
  17.     
  18.     else if ( (*ptrRaiz)->nodo < elemento ){
  19.          
  20.          return ( eliminar_nodo ( &((*ptrRaiz)->ptrDrcho), elemento ) );
  21.          
  22.     }
  23.     
  24.     else if ( (*ptrRaiz)->nodo == elemento ){
  25.          
  26.          if ( (*ptrRaiz)->ptrIzq == NULL ){
  27.               
  28.               ptrNuevoArbol temp = *ptrRaiz;
  29.               
  30.               *ptrRaiz = (*ptrRaiz)->ptrDrcho;
  31.               
  32.               free(temp);
  33.               
  34.               return 1;
  35.               
  36.          }
  37.          
  38.          else if ( (*ptrRaiz)->ptrDrcho == NULL ){
  39.               
  40.               ptrNuevoArbol temp = *ptrRaiz;
  41.               
  42.               *ptrRaiz = (*ptrRaiz)->ptrIzq;
  43.               
  44.               free(temp);
  45.               
  46.               return 1;
  47.               
  48.          }
  49.          
  50.          else{
  51.               
  52.               ptrNuevoArbol aux = *ptrRaiz;
  53.               
  54.               intercambiar ( ptrRaiz, &aux );
  55.               
  56.               return 1;
  57.               
  58.          }
  59.          
  60.     }
  61.     
  62. }*/
  63.  
  64. /*void intercambiar ( ptrNuevoArbol *ptrRaiz, ptrNuevoArbol *aux ){
  65.      
  66.      if ( (*ptrRaiz)->ptrIzq != NULL ){
  67.           
  68.           intercambiar ( &((*ptrRaiz)->ptrIzq), aux );
  69.           
  70.      }
  71.      
  72.      else{
  73.           
  74.           (*aux)->nodo = (*ptrRaiz)->nodo;
  75.           
  76.           ptrNuevoArbol temp = *ptrRaiz;
  77.           
  78.           *ptrRaiz = (*ptrRaiz)->ptrDrcho;
  79.           
  80.           free (temp);
  81.           
  82.      }
  83.      
  84. }*/ 
  85.  
  86. //Esta funcion elimina un nodo de un ABB  
  87.  
  88. int eliminar_nodo ( ptrNuevoArbol * ptrRaiz, int elemento ){
  89.     
  90.     ptrNuevoArbol *ptrDir = ptrRaiz;
  91.     
  92.     while ( (*ptrDir)->nodo != elemento ){
  93.           
  94.           if ( *ptrDir == NULL ){
  95.                
  96.                return 0;
  97.                
  98.           }
  99.           
  100.           else if ( (*ptrDir)->nodo > elemento ){
  101.                
  102.                ptrDir = &((*ptrDir)->ptrIzq);
  103.                
  104.           }
  105.           
  106.           else if ( (*ptrDir)->nodo < elemento ){
  107.                
  108.                ptrDir = &((*ptrDir)->ptrDrcho);
  109.                
  110.           }
  111.           
  112.     }
  113.  
  114.     if ( (*ptrDir)->ptrIzq == NULL ){
  115.               
  116.               ptrNuevoArbol temp = *ptrDir;
  117.               
  118.               *ptrDir = (*ptrDir)->ptrDrcho;
  119.               
  120.               free(temp);
  121.               
  122.               return 1;
  123.               
  124.     }
  125.          
  126.     else if ( (*ptrDir)->ptrDrcho == NULL ){
  127.               
  128.               ptrNuevoArbol temp = *ptrDir;
  129.               
  130.               *ptrDir = (*ptrDir)->ptrIzq;
  131.               
  132.               free(temp);
  133.               
  134.               return 1;
  135.               
  136.     }
  137.          
  138.     else{
  139.               
  140.               ptrNuevoArbol aux = *ptrDir;
  141.               
  142.               intercambiar ( ptrDir, &aux );
  143.               
  144.               return 1;
  145.               
  146.     }
  147.          
  148. }
  149.  
  150. /*Esta funcion intercambia el nodo de aux por el mayor del subarbol izquierdo*/
  151.  
  152. void intercambiar ( ptrNuevoArbol *ptrDir, ptrNuevoArbol *aux ){
  153.      
  154.      ptrDir = &((*ptrDir)->ptrDrcho);
  155.      
  156.      while ( (*ptrDir)->ptrIzq != NULL ){
  157.            
  158.            ptrDir = &((*ptrDir)->ptrIzq);
  159.            
  160.      }
  161.           
  162.      (*aux)->nodo = (*ptrDir)->nodo;
  163.           
  164.      ptrNuevoArbol temp = *ptrDir;
  165.           
  166.      *ptrDir = (*ptrDir)->ptrDrcho;
  167.           
  168.      free (temp);
  169.           
  170. }

Y no era ptrNuevoArbol ptrDir, era ptrNuevoArbol *ptrDir.

Aver si soy capaz de explicarme. Yo tengo un nodo, el cual tiene un puntero derecho y un puntero izquierdo (por definicion de la estructura ABB). Esos dos punteros (me refiero al izquierdo y al derecho) lo que almacenan es una direccion de memoria en la que se encuentra una estructura. Hasta ahí todo tiene sentido para mi. Lo que no entiendo es, al hacer &((*arbol)->ptrDrcho), que dirección hay ahí y por qué al modificar la dirección a la que apunta se modifica también la dirección a la que apunta (*arbol)->ptrDrcho

Un saludo!