insertar un hijo en un determinado nodo en un arbol dinamico en c++

[Karpenito]

buenas noches comunidad , necesito su ayuda , estoy haciendo un arbol genealogico en c++ con el fin de darle un nombre de un nodo al arbol y que devuelva cuales nodos son sus primos , mi problema es el siguiente , quiero hacer una funcion que al pasarle el arbol , el nombre de un nodo y otro elemento , la funcion me agregue el elemento como un hijo de ese nodo , mi implementacion consta de una funcion localizar_nodo que me busca el nodo y me lo devuelve , esa funcion se llama en la funcion insertar nodo , mi problema es que me devuelve otro nodo diferente al buscado , agrego el codigo para que tengan una referencia , el arbol es un arbol binario

Código C++:

#include <iostream>
#include <iomanip>
#include <cstdlib>
 
using namespace std;
 
typedef struct ABB
{
   int elem;
   ABB *der, *izq;
} ABB;
 
ABB* crear_nodo()
{
   ABB *p;
   p = new ABB;
   if(p)
   {
      p->elem = 0;
      p->izq = NULL;
      p->der = NULL;
   }
   return p;
}
 
bool agregar_nodo(ABB* &p, int n)
{
   ABB *q, *aux;
   bool found;
   
   q = crear_nodo();
   
   if(q == NULL) return false;
 
   q->elem = n;
   
   if(p==NULL)
   {
     p = q;
     return true;
   }
   
   aux = p;
 
   found = false;
 
   while(!found)
   {
       if(q->elem <= aux->elem)
       {  
           if(aux->izq==NULL)
           {   
              aux->izq = q;
              found = true;
           }
           else
              aux = aux->izq;
       }
       else
       {
           if(aux->der==NULL)
           {
              aux->der = q;
              found = true;
           }
           else
             aux = aux->der;
       }
   }
   return true;
}
 
bool es_hoja(ABB *p)
{
    return (p->izq==NULL && p->der==NULL);
}
 
 
void inorden(ABB *p)
{
   if(p==NULL) return;
   
   inorden(p->izq);
   cout << p->elem << "  ";
   inorden(p->der);
    
   return;
}
 
void pre_orden(ABB* &abb){
    if(abb==NULL) return;
    pre_orden(abb->izq);
    pre_orden(abb->der);
    cout << setw(4) << abb->elem;
}
 
void en_orden(ABB* &abb){
    if(abb==NULL) return;
    en_orden(abb->izq);
    cout << setw(4) << abb->elem;
    en_orden(abb->der); 
}
 
void post_orden(ABB* &abb){
    if(abb==NULL) return;
    post_orden(abb->der);
    post_orden(abb->izq);
    cout << setw(4) << abb->elem;       
}
 
 
bool borrar(ABB* &p, int dat)
{
    if(p==NULL) return false;
    
    ABB *actual = p;
    ABB *padre  = NULL;
    ABB *aux    = NULL;
    
    while(actual!=NULL)
    {
        if(actual->elem == dat)
        {
            if(es_hoja(actual)) // Si es una hoja
            {
                cout << "Es una hoja!" << endl;
                // Si provenimos de una rama
                if(padre!=NULL) // Borramos la referencia a la hoja
                {
                    if(dat > padre->elem) padre->der = NULL; // Si estamos por la derecha
                    else                  padre->izq = NULL; // Si estamos por la izquierda
                }
                delete actual; // Borramos la hoja
                return true;
            }
            else
            {
                cout << "No es una hoja..." << endl;
                // En su lugar buscamos el nodo más a la izquierda del subárbol derecho,
                // o el más a la derecha del subárbol izquierdo e intercambiamos sus valores.
                // A continuación eliminamos el nodo hoja.
                aux = actual;
                padre = actual;
                if(aux->der!=NULL)
                {           
                    aux = actual->der;  
                    while(aux->izq!=NULL)
                    {
                        padre = aux;
                        aux = aux->izq;
                    }
                    if(actual!=padre) padre->izq = NULL;
                    else padre->der = NULL;
                }
                else if(aux->izq!=NULL)
                {           
                    aux = actual->izq;      
                    while(aux->der!=NULL)
                    {
                        padre = aux;
                        aux = aux->der;
                    }
                    if(actual!=padre) padre->der = NULL;
                    else padre->izq = NULL;
                }
                actual->elem = aux->elem;
                delete aux;
                actual = NULL;
                return true;
            }
        }
        else
        {
            padre = actual;
            if(dat > actual->elem) actual = actual->der;
            else                   actual = actual->izq;
        }       
    }
    
    return false;
}
 
int CantNivel(ABB *arbol,int nivel)
{
   if(arbol==NULL)
     return 0;
   else if(nivel==0)
     return 1;
   else
     return(CantNivel(arbol->izq,nivel-1) + CantNivel(arbol->der,nivel-1));       
}
 
 
ABB* buscar(ABB* &abb, int dat){
    if(abb == NULL){
        return false;
    }
    
    if(abb->elem == dat){ 
        return abb;
    }
    else {
        (buscar(abb->izq, dat) || buscar(abb->der, dat));
    }    
}
 
int nivel_elemt(ABB* &abb, int dat){
    if(abb == NULL){
        return false;
    }
    
    if(abb->elem == dat){ 
        return true;
    }
    else {
        return (buscar(abb->izq, dat) || buscar(abb->der, dat));
    }    
}
 
int EstaenArbol(ABB *arbol,int elem)
{
   if(arbol==NULL)    
     return 0;
    
   else if(elem == arbol->elem) 
     return 1;
     
   else
     return(EstaenArbol(arbol->izq,elem) || EstaenArbol(arbol->der,elem));
}
 
int nivel(ABB *arbol, int num)
{
   if(arbol==NULL)
     return -1;
   else if(arbol->elem == num)
     return 0;
   else if(EstaenArbol(arbol->izq,num))  
     return nivel(arbol->izq,num) +1;
   else if(EstaenArbol(arbol->der,num))  
     return nivel(arbol->der,num) +1;
   else return -1; 
 
}
 
ABB* localizar_nodo(int dat,ABB* &abb){
 
    if(abb != NULL) {
    
        localizar_nodo(dat,abb->izq);
        localizar_nodo(dat,abb->der);
        
        if (abb->elem == dat){
            return abb;    
        }
    
    }
}
 
void inserta_hijo_en_nodo(ABB *arbol,int dato_nodo,int nuevo_elem)
{
    ABB *nuevo;
    ABB *nodo;
    
    nodo = localizar_nodo( dato_nodo , arbol);
    
    //Esta es una salida de prueba aqui es donde me doy cuenta que el nodo es
    //diferente al buscado
    
    cout<<"El elemnto en el nodo es"<<nodo->elem<<endl;
    
    nuevo = crear_nodo();
    nuevo->elem = nuevo_elem;
    
    nodo->izq = nuevo;        
}
 
 
 
int main()
{
  ABB *p;
  p = NULL;
  
  agregar_nodo(p, 8);
  agregar_nodo(p, 2);
  agregar_nodo(p, 9);
  agregar_nodo(p, 4);
  agregar_nodo(p, 1);
  agregar_nodo(p, 3);
  
  inserta_hijo_en_nodo(p,9,7);
  /*
  agregar_nodo(p, 7);
  agregar_nodo(p,10);
  agregar_nodo(p,11);
  agregar_nodo(p,12);
  agregar_nodo(p,14);
  agregar_nodo(p,15);
  agregar_nodo(p,16);
  */
  //+++++++++++++++++++++++++++++++++++
  //Estas son unas pruebas para ver si el hijo de 9 es 7
  //cout<<"Primer nodo->"<<p->elem<<endl;
  //cout<<"A su izquierda->"<<p->izq->elem<<endl;
  //cout<<"A su derecha ->"<<p->der->izq->elem<<endl;
  //+++++++++++++++++++++++++++++++++
  
  //buscar(p, 4);
  
  //cout<<"el elemento esta en el nivel"<<nivel(p,3)<<endl;  
 
  //cout<<"elementos en el nivel :"<<CantNivel(p,3)<<endl;
  
  system("pause");
  return 0;
}
 

muchas gracias de antemano

[Karpenito]

haciendo pruebas descubri que en la funcion inserta_hijo_en_nodo en la linea que hago

Código C++:

nodo = localizar_nodo( dato_nodo , arbol);
 

por alguna razon no se estan pasando los datos del nodo encontrado , actualmente las funciones son estas

Código C++:

ABB* localizar_nodo(int dat,ABB* abb){
 
    ABB* copia_arbol = NULL;
    copia_arbol = abb;
 
    if(copia_arbol != NULL) {
    
        cout<<"elemento "<<copia_arbol->elem<<endl;   
        if (copia_arbol->elem == dat){
            cout<<"elemento retornado:"<<copia_arbol->elem<<endl;
            return copia_arbol;    
        }else{  
    
            localizar_nodo(dat,copia_arbol->izq);
            localizar_nodo(dat,copia_arbol->der);
        }
        
        
    
    }
}
 

y la que inserta el nodo

Código C++:

void inserta_hijo_en_nodo(ABB *arbol,int dato_nodo,int nuevo_elem)
{
    ABB *nuevo;
    ABB *nodo;
    
    nodo = localizar_nodo( dato_nodo , arbol);
    
    //Esta es una salida de prueba aqui es donde me doy cuenta que el nodo es
    //diferente al buscado
    
    cout<<"El elemento en el nodo es "<<&nodo->elem<<endl;
    
    nuevo = crear_nodo();
    nuevo->elem = nuevo_elem;
    
    //nodo->izq = nuevo;        
}
 

[Karpenito]

Al final resolvi haciendo esto

Código C++:

void localizar_nodo(int dat,ABB* abb,ABB* &nodo_localizado){
 
    ABB* copia_arbol = NULL ; 
    ABB* nodo_encontrado = NULL;
    copia_arbol = abb;
    
    
    nodo_encontrado = copia_arbol;
    nodo_localizado = copia_arbol;
 
    if(copia_arbol != NULL) {
       
        if (copia_arbol->elem == dat){
            
            //Copiamos el nodo encontrado
            nodo_encontrado = copia_arbol;
    
        }else{  
    
            localizar_nodo(dat,copia_arbol->izq,nodo_localizado);
            localizar_nodo(dat,copia_arbol->der,nodo_localizado);
        }
    
    }
    
}
 

Código C++:

void inserta_hijo_en_nodo(ABB *arbol,int dato_nodo,int nuevo_elem)
{
    ABB *nuevo;
    ABB *nodo_objetivo;
 
    
    localizar_nodo( dato_nodo , arbol , nodo_objetivo);
    
    //Esta es una salida de prueba aqui es donde me doy cuenta que el nodo es
    //diferente al buscado
    
    cout<<"El elemento en el nodo es "<<nodo_objetivo->elem<<endl;
    
    nuevo = crear_nodo();
    nuevo->elem = nuevo_elem;
    
    nodo_objetivo->izq = nuevo;        
}
 

ya hace lo que queria , el cambio radica que la funcion que localiza el nodo ya no lo retorna sino que en los parametros le paso una variabel ABB* & nodo_encontrado
en esta grabo el nodo y posteriormente lo uso , nose porque retornando no funciona , lo unico que se me ocurre es que las funciones retornan cosas por defecto y esos retornos se juntaban con el retorno resultado y lo dañaba , si alguien me puede explicar eso se lo agradeceria un monton