Реализовать алгоритм организации и обработки информации с помощью В-деревьев

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace ipr2
{
    
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        // Структура дерева
        public struct BTree
        {
            public int  t;      // минимальная степень дерева
            public Node root;   // указатель на корень дерева
        }
        
        // Структура узла
        public struct Node
        {
            public bool leaf;  // является ли узел листом
            public int n;      // количество ключей узла
            public int[] key;  // ключи узла
            public Node[] c;   // указатели на детей узла
        }
 
        // Создание пустого дерева
        public void Creat()
        {
            // Создаю узел
            BTree X = new BTree();
            X.root.leaf = true;
            X.root.n = 0;
            // Делаю узел корнем
            BTree T = new BTree();
            T.t = 2;
            T.root = X.root;
        }
 
        /* Метод Split получает в качестве входного параметра незаполненный внутренний узел X  
        * и  ин*декс i, такой, что узел X.Ci является заполненным дочерним узлом X.
        * Метод разбивает дочерний узел на два и со*ответствующим образом обновляет поля X, внося в него  
        * информацию о новом дочернем узле. Для разбиения заполненного корневого узла сначала делаем 
        * корень дочерним узлом нового пустого корневого узла, после чего можем исполь*зовать вызов Split.
        * При этом высота дерева увеличивается на 1.*/
        public void Split(BTree X, int i)
        {
            Node Z = new Node();
            Node Y = new Node();
            Y = X.root.c[i];
            Z.leaf = Y.leaf;
            Z.n = X.t-1;
            for (int j = 1; j < (X.t - 1); j++)
            {
                Z.key[j] = Y.key[j + X.t];
            }
            if (Y.leaf == false)
            {
                for (int j = 1; j < X.t; j++)
                {
                    Z.c[j] = Y.c[j + X.t];
                }
                Y.n = X.t - 1;
            }
            for (int j = X.root.n; j < i + 1; j--)
            {
                X.root.c[j + 1] = X.root.c[j];
            }
            X.root.c[i + 1] = Z;
            for (int j=X.root.n; j<i; j--)
            {
                X.root.key[j + 1] = X.root.key[j];
            }
            X.root.key[i] = Y.key[X.t];
            X.root.n = X.root.n + 1;
        }
 
        /* Вставка ключа k в дерево Т. Метод Insert использу*ет метод SPLIT для гарантии того, что
         * рекурсия никогда не столкнется с заполненным узлом.*/
        public void Insert(BTree T, int k)
        {
            BTree R = new BTree();
            R.root = T.root;
            if (R.root.n==(2*T.t-1))
            {
                BTree S = new BTree();
                T.root = S.root;
                S.root.leaf = false;
                S.root.n = 0;
                S.root.c[1] = R.root;
                Split(S, 1);
                InsertN(S, k);
                InsertN(R, k);
            }
        }
 
        /* Вспомогательный рекурсивный метод InsertN  вставля*ет  ключ  k в  узел  X, 
         * который при вызове метода должен быть незаполнен*ным.  
         * Операции Insert и InsertN гарантируют, что это условие незаполненности будет выполнено.*/
        public void InsertN(BTree X, int k)
        {
            int i = X.root.n;
            if (X.root.leaf == true)
            {
                while ((i >= 1) & (k < X.root.key[i]))
                {
                    X.root.key[i + 1] = X.root.key[i];
                    i--;
                }
                X.root.key[i + 1] = k;
                X.root.n++;
 
            }
            else
            {
                while ((i >= 1) & (k < X.root.key[i]))
                {
                    i--;
                }
                i++;
                if (X.root.c[j].n == 2 * X.t - 1)
                {
                    Split(X, i);
                    if (k > X.root.key[i])
                    {
                        i++;
                    }
                    InsertN(X, k); //!!!
                }
            }
        }
 
 
    }
}