b tree bugged

#include <iostream>

class Node {
public:
    int *key_;
    Node **children_;
    bool is_leaf_;
    int size_;

    Node();

    explicit Node(int, bool);

    ~Node();

    size_t countSize();

    int64_t countSum();

    bool find(int);
};

class BTree {
public:
    explicit BTree(int);

    ~BTree();

    void insert(int);

    size_t size() const;

    int64_t sum() const;

private:
    int t_;
    Node *head_;

    void insertInFreeNode(int, Node *);

    void splitChild(int, Node *) const;
};

Node::Node(int times, bool is_leaf) {
    is_leaf_ = is_leaf;
    key_ = new int[2 * times - 1];
    children_ = new Node *[2 * times];
    for (int i = 0; i < 2 * times; ++i) {
        children_[i] = nullptr;
    }
    size_ = 0;
}

Node::Node() {
    key_ = nullptr;
    children_ = nullptr;
}

Node::~Node() {
    delete[] key_;
    delete[] children_;
}

size_t Node::countSize() {
    size_t sz = 1;
    if (!is_leaf_) {
        for (int i = 0; i < size_ + 1; ++i) {
            sz += children_[i]->countSize();
        }
    }
    return sz;
}

int64_t Node::countSum() {
    int64_t sum = 0;
    for (int i = 0; i < size_; ++i) {
        if (!is_leaf_) {
            sum += children_[i]->countSum();
        }
        sum += key_[i];
    }
    if (!is_leaf_) {
        sum += children_[size_]->countSum();
    }
    return sum;
}

bool Node::find(int key) {
    if (this == nullptr) {
        return false;
    }
    int index = 0;
    while (index < size_ && key > key_[index]) {
        index++;
    }
    if (index < size_ && key_[index] == key) {
        return true;
    }
    if (is_leaf_) {
        return false;
    }
    return children_[index]->find(key);
}

BTree::BTree(int times) {
    t_ = times;
    head_ = nullptr;
}

BTree::~BTree() {
    delete head_;
}

void BTree::splitChild(int child_index, Node *node) const {
    Node *child = node->children_[child_index];
    Node *new_child = new Node(t_, child->is_leaf_);
    new_child->size_ = t_ - 1;
    child->size_ = t_ - 1;
    for (int i = 0; i < t_ - 1; ++i) {
        new_child->key_[i] = child->key_[i + t_];
    }
    for (int i = 0; i < t_; ++i) {
        new_child->children_[i] = child->children_[i + t_];
        child->children_[i + t_] = nullptr;
    }
    for (int i = node->size_; i > child_index; --i) {
        node->children_[i + 1] = node->children_[i];
        node->children_[i] = nullptr;
    }
    node->children_[child_index + 1] = new_child;
    for (int i = node->size_ - 1; i > child_index - 1; --i) {
        node->key_[i + 1] = node->key_[i];
    }
    node->key_[child_index] = child->key_[t_ - 1];
    node->size_++;
}

void BTree::insertInFreeNode(int key, Node *node) {
    int last_index = node->size_ - 1;
    if (node->is_leaf_) {
        while (last_index >= 0 && node->key_[last_index] > key) {
            node->key_[last_index + 1] = node->key_[last_index];
            last_index--;
        }
        node->key_[last_index + 1] = key;
        node->size_++;
    } else {
        while (last_index >= 0 && node->key_[last_index] > key) {
            last_index--;
        }
        if (node->children_[last_index + 1]->size_ == 2 * t_ - 1) {
            splitChild(last_index + 1, node);
            if (node->key_[last_index + 1] < key) {
                last_index++;
            }
        }
        insertInFreeNode(key, node->children_[last_index + 1]);
    }
}

void BTree::insert(int key) {
    if (head_ == nullptr) {
        head_ = new Node(t_, true);
        head_->key_[0] = key;
        head_->size_ = 1;
        return;
    }
    if (head_->find(key)) {
        return;
    }
    if (head_->size_ < 2 * t_ - 1) {
        insertInFreeNode(key, head_);
    } else {
        Node *new_root = new Node(t_, false);
        new_root->children_[0] = head_;
        splitChild(0, new_root);
        if (key < new_root->key_[0]) {
            insertInFreeNode(key, new_root->children_[0]);
        } else {
            insertInFreeNode(key, new_root->children_[1]);
        }
        head_ = new_root;
    }
}

size_t BTree::size() const {
    size_t size = 0;
    if (head_ != nullptr) {
        size += head_->countSize();
    }
    return size;
}

int64_t BTree::sum() const {
    int64_t sum = 0;
    if (head_ != nullptr) {
        sum += head_->countSum();
    }
    return sum;
}