Проблема в коде для B дерева 5 порядка

#include <iostream>
#include <cstdlib>
#include <string>
 
 
using namespace std;
 
const int ORDER_TREE = 5; //Порядок дерева
 
template < class T, class U >
class element {
public:
    T key;
    U val;
 
    element(T x, U y) {
        key = x;
        val = y;
    }
 
    element() {}
 
    bool operator <(element y) {
        return key < y.key;
    }
 
    bool operator >(element y) {
        return key > y.key;
    }
 
    element< T, U > operator =(element< T, U > y) {
        key = y.key;
        val = y.val;
        return y;
    }
 
    friend ostream& operator <<(ostream& os, const element< T, U >& x) {
        return os << x.key;
    }
 
};
 
//вершина дерева
template < class T, class U, int SIZE >
class bt_vertex {
public:
    element < T, U > el[SIZE];//масив елементів
    bt_vertex< T, U, SIZE >* child[SIZE];//масив вказівників на дітей
    bt_vertex< T, U, SIZE >* parent;//вказівник на батька
    long long active_size;
    bt_vertex() {
        active_size = 0;
        parent = NULL;
    }
    void split();
    void insert(element< T, U > newbie, int pos);
    int LKP_print(int x, int y);
    void delete_elem(int pos);
    void merge(element< T, U >* x, bt_vertex< T, U, SIZE >* y);
    bt_vertex< T, U, SIZE >* find(int& pos, T key);
    void repair();
    void make_new_array(bt_vertex< T, U, SIZE >* new_vertex, int bord);
};
 
//Б-Дерево ключ-значення
template < class T, class U, int SIZE >
class btree {
private:
    bt_vertex < T, U, SIZE >* root;
public:
    btree() {
        root = NULL;
    }
 
    void insert(T x, U y);
    void print(int x);
    void delete_elem(T x);
    bool find(T key);
};
 
//Друкувати "ключ(значення)" в ЛКП обході
template < class T, class U, int SIZE >
int bt_vertex< T, U, SIZE >::LKP_print(int x, int y) {
    int t = 0;
    el[t] = el[0];
    for (long long tmp = 0; tmp < active_size; tmp++) {
 
        if (child[tmp])
            child[tmp]->LKP_print(x + 1, el[tmp].key);
        for (int i = 0; i < x; i++)
            cout << "    ";
        cout << el[tmp] << "(" << el[tmp].val << ")   ";
        cout << '\n';
        if (el[t] > el[tmp])
        {
            el[t] = el[tmp];
        }
        return el[t];
    }
    if (child[active_size])
        child[active_size]->LKP_print(x + 1, 0);
 
 
}
 
/*  Пошук, повертає вказівник на вершину, де зберігається елемент
Якщо його нема, то той листок, в який його потрібно було б помістити
в pos записуєтся порядковый номер в масиві, якщо елемента нема, то записує
ту позицію, перед якою потрібно вставити елемент*/
template < class T, class U, int SIZE >
bt_vertex< T, U, SIZE >* bt_vertex< T, U, SIZE >::find(int& pos, T key) {
    pos = 0;
    while (pos < active_size && el[pos].key < key) {
        if (child[pos])
            child[pos]->parent = this;
        pos++;
    }
    if (pos == active_size && child[pos])
        child[pos]->parent = this;
    if (pos < active_size && el[pos].key == key)
        return this;
    if (child[pos])
        return child[pos]->find(pos, key);
    return this;
}
 
//Пошук в дереві
template < class T, class U, int SIZE >
bool btree< T, U, SIZE >::find(T key) {
    int pos;
    if (!root)
        return false;
    bt_vertex< T, U, SIZE >* tmp = root->find(pos, key);
    if (tmp && tmp->el[pos].key == key)
        return true;
    return false;
}
 
//ЛКП друк дерева
template < class T, class U, int SIZE >
void btree< T, U, SIZE >::print(int x) {
    int mas[11];
    if (root)
        mas[1] = root->LKP_print(x, 0);
 
    else
        cout << "Tree is empty\n";
}
 
//Дебавлення елемента в дерево
template < class T, class U, int SIZE >
void btree< T, U, SIZE >::insert(T key, U val) {
    //створюємо обєкт, який будемо закидувати в масив значень
    element< T, U > newbie(key, val);
    //якцо дерево пусте, то створюємо вершину и додаємо в список елементів
    if (root == NULL) {
        root = new bt_vertex< T, U, SIZE >;
        root->el[root->active_size] = newbie;
        root->child[root->active_size] = NULL;
        root->child[root->active_size + 1] = NULL;
        root->active_size++;
    }
    else {
        //Шукаємо ключ, якщо такий є, то просто перезаписуємо значення
        //Якщо нема, то просто добавляємо в потрібну пзицію наш ключ
        //викликаємо split якщо потрібно всередині insert
        int pos;
        bt_vertex< T, U, SIZE >* tmp = root->find(pos, key);
        if (tmp->el[pos].key == key)
            tmp->el[pos].val = val;
        else
            tmp->insert(newbie, pos);
        //Якщо в процесі розділення вершин створили новый корінь, то міняемо вказівинк
        if (root->parent)
            root = root->parent;
    }
}
 
//Виділяє з el эелементи після el[bord]
template < class T, class U, int SIZE >
void bt_vertex< T, U, SIZE >::make_new_array(bt_vertex< T, U, SIZE >* new_vertex, int bord) {
    el[bord].key = 0;
    for (int i = bord + 1; i <= active_size; i++) {
        new_vertex->el[i - bord - 1] = el[i];
        new_vertex->child[i - bord - 1] = child[i];
        if (child[i])
            child[i]->parent = new_vertex;
    }
    new_vertex->active_size = bord;
    active_size = bord;
}
 
 
template < class T, class U, int SIZE >
void bt_vertex< T, U, SIZE >::split() {
    //bord - межа розділу
    int bord = active_size / 2;
    bt_vertex< T, U, SIZE >* new_vertex = new bt_vertex< T, U, SIZE >;
    element< T, U > new_el = el[bord];
    make_new_array(new_vertex, bord);
    //Якщо переповнений корінь, то створюємо новий
    if (!parent) {
        bt_vertex< T, U, SIZE >* newroot = new bt_vertex< T, U, SIZE >;
        newroot->active_size = 1;
        newroot->el[0] = new_el;
        newroot->child[0] = this;
        newroot->child[1] = new_vertex;
        newroot->parent = NULL;
        parent = newroot;
        new_vertex->parent = newroot;
        return;
    }
    //pos - позиция куди виштовхуємо новий елемент, до нього прикріпляємо this,
    //а до наступного new_vertex
    int pos = 0;
    while (pos < parent->active_size && new_el > parent->el[pos])
        pos++;
    for (int i = SIZE - 1; i > pos; i--) {
        parent->el[i] = parent->el[i - 1];
        parent->child[i] = parent->child[i - 1];
    }
    parent->el[pos] = new_el;
    parent->child[pos] = this;
    parent->child[pos + 1] = new_vertex;
    parent->active_size++;
    if (SIZE - parent->active_size == 1)
        parent->split();
}
 
//Додавання в вершину дерева
template < class T, class U, int SIZE >
void bt_vertex< T, U, SIZE >::insert(element< T, U > newbie, int pos) {
 
    for (int i = SIZE - 1; i > pos; i--) {
        el[i] = el[i - 1];
        child[i] = child[i - 1];
    }
    child[pos] = NULL;
    el[pos] = newbie;
    active_size++;
    if (SIZE - active_size == 1)
        split();
}
 
//Видалення по ключу з дерева
template < class T, class U, int SIZE >
void btree< T, U, SIZE >::delete_elem(T x) {
    int pos;
    bt_vertex< T, U, SIZE >* tmp = root->find(pos, x);
 
    if (tmp && tmp->el[pos].key == x)
        tmp->delete_elem(pos);
 
    if (root && root->child[0]) {
        if (root->active_size == 0) {
            root = root->child[0];
            delete root->parent;
            root->parent = NULL;
            return;
        }
    }
    else {
        if (root->active_size == 0) {
            delete root;
            root = NULL;
            return;
        }
    }
 
}
 
//Видалення по ключу з вершини
template < class T, class U, int SIZE >
void bt_vertex< T, U, SIZE >::delete_elem(int pos) {
    if (!child[pos]) {
        //Ми в листку => видаляємо і викликаємо repair дерева
        active_size--;
        for (int i = pos; i < active_size; i++)
            el[i] = el[i + 1];
 
        if (parent || active_size)
            repair();
    }
    else {
        //шукаємо в child, найстаршим в піддерві заміняемо наш елемент, видаляємо його
        child[pos]->parent = this;
        bt_vertex< U, T, SIZE >* tmp;
        tmp = child[pos];
        while (tmp->child[0]) {
            tmp->child[tmp->active_size]->parent = tmp;
            tmp = tmp->child[tmp->active_size];
        }
        el[pos] = tmp->el[tmp->active_size - 1];
        tmp->delete_elem(tmp->active_size - 1);
    }
}
 
//Ставши на вершину виправляємо дерево
template < class T, class U, int SIZE >
void bt_vertex< T, U, SIZE >::repair() {
 
    //Якщо размір this влаштовує або ми в корені, то виходимо
    if (!parent || active_size >= (SIZE - 2) / 2)
        return;
    else {
        //Вершина нас не влаштовує => пробуємо перемістити з сусідів (розмір батька не зачіпається)
        //Якщо не можна цього зробити, то зливаємо з сусідом, чиним батька
 
        //знаходимо позицію this в батька
        int pos = 0;
        for (int i = 0; i <= parent->active_size; i++)
            if (parent->child[i] == this) {
                pos = i;
                break;
            }
        //пробуємо перемістити з наступної, потім з попередньої
        if (pos != parent->active_size)
            //дивимося на розмір, якщо він влаштовує, то додаємо наш елемент в список
            //останньою дитиною робимо першу дитину наступного 
            if (parent->child[pos + 1]->active_size > (SIZE - 2) / 2) {
                el[active_size] = parent->el[pos];
                active_size++;
                child[active_size] = parent->child[pos + 1]->child[0];
                parent->el[pos] = parent->child[pos + 1]->el[0];
                for (int i = 0; i < parent->child[pos + 1]->active_size; i++) {
                    parent->child[pos + 1]->el[i] = parent->child[pos + 1]->el[i + 1];
                    parent->child[pos + 1]->child[i] = parent->child[pos + 1]->child[i + 1];
                }
                parent->child[pos + 1]->active_size--;
                return;
            }
        if (pos != 0)
            //Якщо розмір дозволяє, то беремо батька сусіда і додаємо в початок,
            //Його дитиною стає права дитина сусіда, а останній в сусіді стає його батьком
            if (parent->child[pos - 1]->active_size > (SIZE - 2) / 2) {
                active_size++;
                for (int i = active_size; i > 0; i--) {
                    el[i] = el[i - 1];
                    child[i] = child[i - 1];
                }
                el[0] = parent->el[pos - 1];
                child[0] = parent->child[pos - 1]->child[parent->child[pos - 1]->active_size];
                parent->child[pos - 1]->active_size--;
                parent->el[pos - 1] = parent->child[pos - 1]->el[parent->child[pos - 1]->active_size];
                return;
            }
 
 
        //Починаємо ремонт дерева, зливаючи вершини
        //Якщо ми останній в батьку, то як би чинимо останнього в батьку
        if (pos == parent->active_size) {
            pos--;
        }
        //Нашим родителем становится батько наступного
        //Наступного просто видаляємо
 
        //Опускаємо поточного батька вниз, його сусід стає батьком
        parent->child[pos]->el[parent->child[pos]->active_size] = parent->el[pos];
        parent->child[pos]->active_size++;
        parent->el[pos] = parent->el[pos + 1];
        //вливаємо наступного в поточний
        for (int i = 0; i <= parent->child[pos + 1]->active_size; i++) {
            parent->child[pos]->el[parent->child[pos]->active_size] = parent->child[pos + 1]->el[i];
            parent->child[pos]->child[parent->child[pos]->active_size] = parent->child[pos + 1]->child[i];
            parent->child[pos]->active_size++;
        }
        parent->child[pos]->active_size--;
        //видаляємо наступний
        delete parent->child[pos + 1];
        //зрушуємо все в батьку
        for (int i = pos + 1; i <= parent->active_size; i++) {
            parent->el[i] = parent->el[i + 1];
            parent->child[i] = parent->child[i + 1];
        }
        parent->active_size--;
        //Ми змінили розмір батька, чинимо його
        if (parent)
            parent->repair();
        return;
    }
}
 
int main() {
    setlocale(0, "Ukr");
    int  key;
    int val = 1;//Значение в вершині буде відображати порядковий номер при добавленні(видалені не враховуються)
    btree<int, int, ORDER_TREE + 1 > x;
 
    for (int i = 1; i <= 5; i++)
    {
        cin >> key;
        x.insert(key, val++);
    }
 
    x.print(0);
    cout << "Видалення " << endl;
    for (int i = 1; i <= 4; i++)
    {
        cout << "---------------" << endl;
        cin >> key;
        x.delete_elem(key);
        x.print(0);
        cout << "---------------" << endl;
    }
    system("pause");
    return 0;
}