Бинарные деревья C++

/*
 * Вершины дерева вещественные числа. Описать функцию, которая:
 * a) вычисляет среднее арифметическое всех вершин дерева;
 * b) добавляет в дерево вершину со значением, вычисленным в предыдущей функции.
*/
// a) - double arithmetic_average(const TBTree& tree);
// b) - void Add_ar(TBTree& tree);
#include <iostream>
#include <utility>
#include <iomanip>
 
using namespace std;
struct TNode{
    double  data{};
    TNode*  left  = nullptr;
    TNode*  right = nullptr;
    TNode() = default;
    TNode(double data):data{data}{};
    ~TNode(){
        if (left) delete left;
        if (right) delete right;
    };
};
 
struct TBTree{
    TNode* root      = nullptr;   // корень дерева
    unsigned deep_level_max = 0;
    unsigned deep_level_min = 0;
};
using NLp_t = pair<TNode*, unsigned>;
using SCp_t = pair<double, unsigned>;
SCp_t& operator+=(SCp_t& left, const SCp_t& right){
    left.first += right.first;
    left.second += right.second;
    return left;
}
 
NLp_t Find_free_top(TNode* node, unsigned level);
void Add_node(TBTree& tree, double data);
void Print_tree(const TNode* node, unsigned level);
void Print_tree(const TBTree & tree);
SCp_t Calc_sum(const TNode * node);
double arithmetic_average(const TNode * node);
double arithmetic_average(const TBTree& tree);
void Add_ar(TBTree& tree);
 
int main()
{
    TBTree tree;
    Add_node(tree, 1.0);
    Add_node(tree, 4.0);
    Add_node(tree, 4.0);
    Add_node(tree, 5.0);
    Add_node(tree, 6.0);
    Print_tree(tree);
    cout << endl << endl;
    Add_ar(tree);
    Add_node(tree, 5.0);
    Add_ar(tree);
    Add_node(tree, 5.0);
    Add_ar(tree);
    Print_tree(tree);
    return 0;
}
 
// feunctions body
void Add_ar(TBTree& tree){
    Add_node(tree, arithmetic_average(tree));
}
 
double arithmetic_average(const TBTree& tree){
    return arithmetic_average(tree.root);
}
// ----------------------------------------------------------------------------
 
NLp_t Find_free_top(TNode* node, unsigned level){
    if (!node->left || !node->right){
        return make_pair(node, level);
    }
    NLp_t res_l = Find_free_top(node->left, level+1);
    NLp_t res_r = Find_free_top(node->right, level+1);
    if (res_l.second < res_r.second)
        return res_l;
    return res_r;
}
void Add_node(TBTree& tree, double data){
    if (!tree.root)
        tree.root = new TNode(data);
    else{
        TNode* free_node = Find_free_top(tree.root, 0).first;
        if (!free_node->left)
            free_node->left = new TNode(data);
        else
            free_node->right = new TNode(data);
    }
}
void Print_tree(const TNode* node, unsigned level = 0){
    if (node) {
        Print_tree(node->left, level + 1);
        for (unsigned i = 0; i < level; i++)
            cout << "    ";
        cout << fixed << setprecision(2) << node->data << endl;
        Print_tree(node->right, level + 1);
    }
}
void Print_tree(const TBTree & tree){
    Print_tree(tree.root);
}
SCp_t Calc_sum(const TNode * node){
    if (!node)
        return make_pair(0.0, 0);
    SCp_t res(node->data, 1);
    res += Calc_sum(node->left);
    res += Calc_sum(node->right);
    return res;
}
double arithmetic_average(const TNode * node){
    SCp_t sum = Calc_sum(node);
    return sum.first / sum.second;
}