Help with binary tree

The code fails in the function createNode (), specifically in the following line:

strcpy(nuevo_nodo->nombre,nom);

The problem is that your functions insertNode () and createNode () should receive pointers to char and simply receive char.

Change this:

Nodo *crearNodo(int ed, char nom);
void insertarNodo(Nodo *&arbol, char nom);

To this:

Nodo *crearNodo(int ed, char *nom);
void insertarNodo(Nodo *&arbol, char *nom);

Your code two important problems:

• Function prototypes do not match definitions :
  • crearNodo is declared as Nodo *(int,char[]) and is defined as Nodo *(int, char) .
  • insertarNodo is declared as void(Nodo *&, int, char[]) and is defined as void(Nodo *&, int, char) .
• You are programming C ++ using headers from C : the header <string.h> is from C language , you have a version for C ++ that is <cstring> . Read this thread for more information.

Apart from the above problems, you have other minor problems:

• Programs in C ++ with paradigms of C : Not that it is forbidden to do it, but since C ++ offers utilities to make your code more secure and compact, why use more verbose alternatives that require more control ( and therefore are more likely to error)?
• Why do not you use objects? : This is a variation of the previous one, C ++ is a multi-paradigm language, but in its fundamentals is object orientation, why do not you take advantage of it?

Knowing these problems of your code, let's see the fault:

Nodo *crearNodo(int ed, char nom){


    Nodo *nuevo_nodo = new Nodo();
          nuevo_nodo->edad = ed;
          nuevo_nodo->nombre=nom; // Asignación incorrecta.
          nuevo_nodo->der = NULL;
          nuevo_nodo->izq = NULL;

          return nuevo_nodo;
}

Your problem is in assigning the name, and it is normal. The argument nom is of type char while Nodo::nombre is type char[30] . They are different types and therefore not assignable, you could solve it like this:

nuevo_nodo->nombre[0] = nom; // Asignación correcta.

But even if it is correct, surely it is not what you want to do; I assume that you expect nom to be more than one letter and assuming that the function crearNodo had the same signature as in its definition the correct code would be this:

Nodo *crearNodo(int ed, char nom[]){
//  char[], no char --> ~~~~~~~~~~


    Nodo *nuevo_nodo = new Nodo();
          nuevo_nodo->edad = ed;
          std::copy(nom, nom + 30, nuevo_nodo->nombre);
//        ~~~~~~~~~ <-- función de copia.
          nuevo_nodo->der = NULL;
          nuevo_nodo->izq = NULL;

          return nuevo_nodo;
}

However, I propose something different:

Proposal.

Start by changing your Nodo like this:

struct Nodo{
    std::string nombre;
    int edad = 0;
    Nodo *der = nullptr;
    Nodo *izq = nullptr;
};

As member Nodo::nombre an object of type std::string you can assign arbitrarily long names (not limited to 30 characters). In the rest of the members, when you add values by defecation in your definition, you can have control over your data in a more secure way.

The Nodo should be an internal object of a class Arbol , this last class being the owner of the creation and insertion functions of nodes (instead of single functions):

struct Arbol{

    void insertar(int edad, std::string nombre);
    void mostrar();

private:

    Nodo *crear(int edad, std::string nombre);
    void insertar(Nodo *&posicion, int edad, std::string nombre);

    struct Nodo{
//  ~~~~~~~~~~~ <--- El Nodo pertenece al Abol y es inaccesible desde fuera
        std::string nombre;
        int edad = 0;
        Nodo *der = nullptr;
        Nodo *izq = nullptr;
    };

    Nodo *raiz = nullptr;
};

The previous code follows the principles of encapsulation by hiding the user from the object Arbol everything that you should not interact with. Private functions can be much simpler even if you follow the same code:

Nodo *Arbol::crear(int edad, std::string nombre){
    return new Nodo{nombre, edad};
}

void Arbol::insertar(Nodo *&posicion, int edad, char nombre){

    if (posicion == nullptr){
        posicion = crearNodo(edad, nombre);
    }
    else{
        insertarNodo(edad < posicion->edad ? posicion->izq : posicion->der, edad, nombre);
    }
}