private void Busqueda(int PosicionActual, T data, T Ndata)
        {
            if (PosicionActual == MetodosNecesarios.NullPointer)
            {
                return;
            }
            Nodo <T> nodo = new Nodo <T>();

            nodo = nodo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
            for (int i = 0; i < nodo.Data.Count; i++)
            {
                ObtenerNodo(nodo.Hijos[i]);
                if (nodo.Data[i].ToString() == data.ToString())
                {
                    nodo.Data[i] = Ndata;
                    nodo.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                }
            }
        }
        private void UpData(Nodo <T> node, T data, int Derecho)
        {
            if (node.CapacidadMax && node.Padre != MetodosNecesarios.NullPointer)
            {
                Nodo <T> nPadre = new Nodo <T>();
                nPadre.ID = node.Padre;
                nPadre    = nPadre.LecturaNodo(this.Ruta, this.Orden, this.Raiz, node.Padre, createFixedSizeText);
                int posicion = 0;
                for (int i = 0; i < nPadre.Hijos.Count(); i++)
                {
                    if (nPadre.Hijos[i] == node.ID)
                    {
                        posicion = i;
                        break;
                    }
                }
                Nodo <T> TemporalNode = new Nodo <T>();
                if (nPadre.Hijos[posicion + 1] != MetodosNecesarios.NullPointer)
                {
                    TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion + 1], createFixedSizeText);
                    if (!TemporalNode.CapacidadMax)
                    {
                        node.Data.Add(data);
                        node.Data.Sort();
                        T TemporalData = node.Data[node.Data.Count() - 1];
                        node.Data.Remove(TemporalData);
                        node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                        T TemporalData2 = nPadre.Data[posicion - 1];
                        nPadre.Data.Insert(posicion - 1, TemporalData2);
                        TemporalNode.Data.Add(data);
                        TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                    }
                }
                if (posicion > 0)
                {
                    TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion - 1], createFixedSizeText);
                    if (!TemporalNode.CapacidadMax)
                    {
                        node.Data.Add(data);
                        node.Data.Sort();
                        T TemporalData = node.Data[0];
                        node.Data.Remove(TemporalData);
                        node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                        T TemporalData2 = nPadre.Data[posicion - 1];
                        nPadre.Data.Insert(posicion - 1, TemporalData2);
                        TemporalNode.Data.Add(data);
                        TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                        return;
                    }
                }
                List <T> SNodo = new List <T>();
                foreach (var item in node.Data)
                {
                    SNodo.Add(item);
                }
                if (nPadre.Hijos[posicion + 1] != MetodosNecesarios.NullPointer)
                {
                    SNodo.Add(nPadre.Data[posicion]);
                    TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion + 1], createFixedSizeText);
                }
                else if (posicion > 0)
                {
                    SNodo.Add(nPadre.Data[posicion - 1]);
                    TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion - 1], createFixedSizeText);
                }

                foreach (var item in TemporalNode.Data)
                {
                    SNodo.Add(item);
                }
                SNodo.Add(data);
                SNodo.Sort();

                int min = (2 * (this.Orden - 1)) / 3;
                node.Data.Clear();
                TemporalNode.Data.Clear();
                int contador = 0;
                for (int i = 0; i < this.Orden - 1; i++)
                {
                    if (contador < min)
                    {
                        node.Data.Add(SNodo[i]);
                    }
                    else
                    {
                        node.Data.Add(createFixedSizeText.CreateNull());
                    }
                    contador++;
                }
                nPadre.Data.Insert(posicion, SNodo[min]);
                nPadre.Data.Insert(posicion + 1, SNodo[(min * 2) + 1]);
                contador = 0;
                for (int i = 0; i < this.Orden - 1; i++)
                {
                    if (contador < min)
                    {
                        TemporalNode.Data.Add(SNodo[i + min + 1]);
                    }
                    else
                    {
                        TemporalNode.Data.Add(createFixedSizeText.CreateNull());
                    }
                    contador++;
                }
                contador = 0;
                Nodo <T> NNode = new Nodo <T>();
                NNode.Padre = nPadre.ID;
                NNode.ID    = UltimaPosicion;
                NNode.Data  = new List <T>();
                NNode.Hijos = new List <int>();
                UltimaPosicion++;
                for (int i = 0; i < this.Orden - 1; i++)
                {
                    if (contador < min)
                    {
                        NNode.Data.Add(SNodo[i + (2 * min) + 2]);
                    }
                    else
                    {
                        NNode.Data.Add(createFixedSizeText.CreateNull());
                    }
                }
                for (int i = 0; i < this.Orden; i++)
                {
                    NNode.Hijos.Add(MetodosNecesarios.NullPointer);
                }
                node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                nPadre.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                EscrituraEncabezado();
            }
            else if (true)
            {
                node.InsertarDatos(data);
                node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                return;
            }
            Nodo <T> _NNode = new Nodo <T>(this.Orden, this.UltimaPosicion, node.Padre, createFixedSizeText);

            this.UltimaPosicion++;
            T TUData = createFixedSizeText.CreateNull();

            node.SeparacionNodo(data, Derecho, _NNode, TUData, createFixedSizeText);
            Nodo <T> NodoHijo = new Nodo <T>();

            for (int i = 0; i < _NNode.Hijos.Count; i++)
            {
                if (_NNode.Hijos[i] != MetodosNecesarios.NullPointer)
                {
                    NodoHijo       = NodoHijo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, _NNode.Hijos[i], createFixedSizeText);
                    NodoHijo.Padre = _NNode.ID;
                    NodoHijo.EscrituraEnDiscoNodo(Ruta, this.Raiz);
                }
                else
                {
                    break;
                }
            }
            if (node.Padre == MetodosNecesarios.NullPointer)
            {
                Nodo <T> NRaiz = new Nodo <T>(this.Orden, this.UltimaPosicion, MetodosNecesarios.NullPointer, createFixedSizeText);
                this.UltimaPosicion++;
                NRaiz.Hijos[0] = node.ID;
                NRaiz.Hijos[1] = _NNode.ID;
                NRaiz.InsertarDatos(data, _NNode.ID);

                node.Padre   = NRaiz.ID;
                NRaiz.Padre  = MetodosNecesarios.NullPointer;
                _NNode.Padre = NRaiz.ID;
                this.Raiz    = NRaiz.ID;

                node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                _NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                NRaiz.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
            }
            else
            {
                node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                _NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
                Nodo <T> Padre = new Nodo <T>();
                Padre = Padre.LecturaNodo(this.Ruta, this.Orden, this.Raiz, node.Padre, createFixedSizeText);
                UpData(Padre, data, _NNode.ID);
            }
        }