Деревья С++ (функция, которая получает указатель на корень дерева и возвращает длину самой длинной ветки на дереве)

//-----------------------------------------------------------------------------
//--------------------------Including Section----------------------------------
//-----------------------------------------------------------------------------
#include <iostream>
#include <cmath>
#include <new>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <new>
#include <fstream>
//-----------------------------------------------------------------------------
//------------------------------Using Section----------------------------------
//-----------------------------------------------------------------------------
using std::cin;
using std::cout;
using std::nothrow;
using std::cerr;
using std::endl;
using namespace std;
//-----------------------------------------------------------------------------
//----------------------------Functions Section--------------------------------
//-----------------------------------------------------------------------------
struct Node
{
    int _data;
    struct Node *_left,
                *_right;
};
 
struct Node * BuildTheBST();
void InsertIntoTheBST(struct Node **point_to_root,int num);
struct Node * AllocateNewNode(int num);
int TheLongestBranch( const struct Node *root,double &branch);
void FreeTheSpace(struct Node *&root);
//-----------------------------------------------------------------------------
//------------------------------Main Section-----------------------------------
//-----------------------------------------------------------------------------
int main()
{
    struct Node * root = NULL;
 
    double branch = 0;
 
    root = BuildTheBST();
    TheLongestBranch(root,branch);
    cout << branch;
 
 
    FreeTheSpace(root);
    return(EXIT_SUCCESS);
}
//-----------------------------------------------------------------------------
//-----------Function that reads the numbers into BST--------------------------
//-----------------------------------------------------------------------------
struct Node * BuildTheBST()
{
    struct Node * root = NULL;
    int num;
 
    cin >> num;
    while(!cin.eof())
    {
        InsertIntoTheBST(&root,num);
        cin >> num;
    }
 
    return (root);
}
//-----------------------------------------------------------------------------
//-----------Function that inserts numbers into BST----------------------------
//-----------------------------------------------------------------------------
void InsertIntoTheBST(struct Node **point_to_root,int num)
{
    while(*point_to_root != NULL)
        if (num <= (*point_to_root)->_data)
            point_to_root = &((*point_to_root)->_left);
        else
            point_to_root = &((*point_to_root)->_right);
 
    (*point_to_root) = AllocateNewNode(num);
}
//-----------------------------------------------------------------------------
//-----------Function that allocates new nodes---------------------------------
//-----------------------------------------------------------------------------
struct Node * AllocateNewNode(int num)
{
    struct Node * NewNode = NULL;
 
    NewNode = new(nothrow) struct Node;
 
    if(NewNode == NULL)
    {
        cerr <<"Can't allocate memory\n";
        exit(EXIT_FAILURE);
    }
 
 
    NewNode->_data = num;
    NewNode->_right =NULL;
    NewNode->_left = NULL;
 
    return (NewNode);
}
//-----------------------------------------------------------------------------
//-----------Function that finds the min_depth_leaf----------------------------
//-----------------------------------------------------------------------------
int TheLongestBranch(const struct Node *root,double &branch)
{
    const struct Node *point_to_node=root;
    if (point_to_node==NULL)
        return (0);
 
    if (point_to_node->_left!=NULL && point_to_node->_right!=NULL)
    {
        if ((point_to_node->_left==NULL && point_to_node->_right!=NULL)||(point_to_node->_left!=NULL && point_to_node->_right==NULL))
        {
            TheLongestBranch(point_to_node->_left,++branch);
            TheLongestBranch(point_to_node->_right,++branch);
        }
        else
        {
 
            TheLongestBranch(point_to_node->_left,branch);
            TheLongestBranch(point_to_node->_right,branch);
        }
 
    }
 
    if (point_to_node->_left==NULL && point_to_node->_right==NULL)
    return (branch);
 
}
//-----------------------------------------------------------------------------
//-----------Function that frees space-----------------------------------------
//-----------------------------------------------------------------------------
void FreeTheSpace(struct Node *& root)
{
    if(root == NULL)
        return;
 
    FreeTheSpace(root->_left);
    FreeTheSpace(root->_right);
 
    delete root;
}