Очистка памяти, выделенной под небинарное дерево

class Node {
public:
    int index_from; //индекс клетки, откуда ходили
    int index_to; //индекс клетки, куда сходили
    MatrixXd table; //новая доска
    vector<Node*> next_move; //возможные ходы из этой клетки
    Node* last_move; //предыдущий ход
    bool eating; //был ли сделан съедобный ход
 
    //начальный ход
    Node(int ind_from, int ind_to, MatrixXd tab, bool eat = false) {
        table = MatrixXd::Constant(1, 32, 0);
        this->index_from = ind_from;
        this->index_to = ind_to;
        this->table = tab;
        this->last_move = nullptr;
        this->eating = eat;
    }
    //промежуточный ход
    Node(int ind_from, int ind_to, MatrixXd tab, Node* last) {
        MatrixXd::Constant(1, 32, 0);
        this->index_from = ind_from;
        this->index_to = ind_to;
        this->table = tab;
        last_move = last;
    }
    //для каждого дочернего узла указать родительский
    void add_parent(vector<Node*>& children) {
        for (int i = 0; i < children.size(); i++) {
            (*children[i]).last_move = this;
        }
        next_move = children;
    }
    //найти родителя
    Node* find_parent() {
        if (this->last_move == nullptr) return nullptr;
        else {
            Node* parent = this->last_move;
            if (parent->last_move == nullptr) return parent;
            else return parent->find_parent();
        }
    }
    
    
};
 
void clear(Node*& node);

void clear(Node* &node) {
    //if (node->last_move != NULL) clear(node->last_move);
    for (int i = 0; i < node->next_move.size(); i++) {
        if(node->next_move[i] != NULL) clear(node->next_move[i]);
    }
    delete node;
    node = nullptr;
}
 
//модель делает ход
int model_make_move(MatrixXd& table, Model* model, bool& eating) {
    //модель находит все ходы
    vector<Node*> all_moves = find_moves(table);
    //модель оценивает каждый последний ход
    if (all_moves.size()== 0) return -1;
    int ind = 0;
    double max = 0;
    for (int i = 0; i < all_moves.size(); i++) {
        double score = ((*model).forward((*all_moves[i]).table))(0, 0);
        //если этот ход самый лучший, запомним
        if (score > max) {
            ind = i;
            max = score;
        }
    }
    //находим родителя
    
    Node* parent = (*all_moves[ind]).find_parent();
    //модель делает ход
    table = (*parent).table;
    //запоминаем, был ли ход съедобным
    eating = (*parent).eating;
    //номер шашки, которой ходила модель
    int out = parent->index_to;
    vector<Node*> parents;
    //очистка памяти
    for (int i = 0; i < all_moves.size(); i++) {
        //if (all_moves[i] != NULL)clear(all_moves[i]);
        Node* parent = all_moves[i]->find_parent();
        if (find(parents.begin(), parents.end(), parent) == parents.end()) 
            parents.push_back(parent);
    }
    for (int i = 0; i < parents.size(); i++) {
        if (parents[i] != NULL) clear(parents[i]);
    }
 
    return out;
}

vector<double> sizes = { 32, 40, 10, 1 };
population.new_population(population_size, sizes);
 
fstream fout("evolution_info.txt", ios_base::app);
 
    map<int, double> index_score;
    int i = 0;
    auto begin = chrono::steady_clock::now(); //начало отсчета
    auto end = chrono::steady_clock::now(); // конец отсчета
    auto duration = chrono::duration_cast<chrono::milliseconds>(end - begin); //время в заданной степени секунд
    double max = 0;
    int ind = 0;
    BeginWaitCursor();
        do {
                        
            index_score = population.evolution(0,0);
            bool update = false;
 
            for (int j = 0; j < population_size; j++) {
 
                if (index_score[j] > max)
                {
                    max = index_score[j];
                    ind = j;
                    update = true;
                }
            }
            
            fout << "Поколение №" << i << " Прошло " << duration.count() / 1000. << " секунд" << endl;
            fout << "Лучший рейтинг " << max << " Средний рейтинг " << population.fitness[population.fitness.size() - 1] << endl;
            end = chrono::steady_clock::now(); // конец отсчета
            duration = chrono::duration_cast<chrono::milliseconds>(end - begin); //время в заданной степени секунд
            population.save_model(ind);
            i++;
 
        } while (duration.count() / 1000 < evolve_time);
 
            //evolve_time - время в секундах
 
        EndWaitCursor();
        end = chrono::steady_clock::now(); // конец отсчета
        duration = chrono::duration_cast<chrono::milliseconds>(end - begin); //время в заданной степени секунд
        fout << "Эволюция закончена за " << duration.count() / 1000. << " секунд" << endl << endl;
        fout.close();

vector<Node*> avaliable_model_move(MatrixXd& table, bool& eating)

vector<Node*> tree_moves;
........
if(eating == can_eat_all){
                //добавим новую вершину дерева
                //для каждой позиции сохраним следующий ход
                for (int j = 0; j < moves_2d.size(); j++) {
                    vector<vector<int>> board_new = make_move(board, row, col, moves_2d[j][0], moves_2d[j][1]);
                    MatrixXd table_new = make_board_for_model(board_new);
                    Node* node_next = new Node(i, moves_2d[j][0]*4+ moves_2d[j][1]/2, table_new, can_eat_all);
                    tree_moves.push_back(node_next);
                }
                
            }
.......
return tree_moves;

vector<Node*> eat_while_can_eat(MatrixXd& table)

vector<Node*> moves = avaliable_model_move(table, can_eat); 
if (!can_eat) {
        moves.clear();
        return moves;
    }

vector<Node*> avaliable_model_move(MatrixXd& table, bool& eating)