示例#1
0
        internal void SeparacionNodo(T _data, int derecho, Nodo <T> Nodo, T SubirData, ICreateFixedSizeText <T> createFixedSizeText)
        {
            int medio = 0;

            if (Padre.Equals(MetodosNecesarios.NullPointer))
            {
                Data.Add(_data);
                Hijos.Add(MetodosNecesarios.NullPointer);

                InsertarDatos(_data, derecho, false);

                medio = Data.Count / 2;

                SubirData   = Data[medio];
                Data[medio] = createFixedSizeText.CreateNull();

                int j = 0;
                for (int i = medio + 1; i < Data.Count; i++)
                {
                    Nodo.Data[j] = Data[i];
                    Data[i]      = createFixedSizeText.CreateNull();
                    j++;
                }
                j = 0;
                for (int i = medio + 1; i < Hijos.Count; i++)
                {
                    Nodo.Hijos[j] = Hijos[i];
                    Hijos[j]      = MetodosNecesarios.NullPointer;
                    j++;
                }
                Data.RemoveAt(Data.Count - 1);
                Hijos.RemoveAt(Hijos.Count - 1);
            }
            else
            {
                Data.Add(_data);
                Hijos.Add(MetodosNecesarios.NullPointer);

                InsertarDatos(_data, derecho, false);

                medio = Data.Count / 2;

                SubirData   = Data[medio];
                Data[medio] = createFixedSizeText.CreateNull();

                int j = 0;
                for (int i = medio + 1; i < Hijos.Count; i++)
                {
                    Nodo.Data[j] = Data[i];
                    Data[i]      = createFixedSizeText.CreateNull();
                    j++;
                }

                j = 0;
                for (int i = medio + 1; i < Hijos.Count; i++)
                {
                    Nodo.Hijos[j] = Hijos[i];
                    Hijos[i]      = MetodosNecesarios.NullPointer;
                    j++;
                }
                Data.RemoveAt(Data.Count - 1);
                Hijos.RemoveAt(Hijos.Count - 1);
            }
        }
        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);
            }
        }
示例#3
0
        internal Nodo <T> LecturaNodo(string Ruta, int Order, int Raiz, int ID, ICreateFixedSizeText <T> createFixedSizeText)
        {
            int Padre = 0;

            if (ID == Raiz)
            {
                Padre = MetodosNecesarios.NullPointer;
            }
            Nodo <T> nodo             = new Nodo <T>(Order, ID, Padre, createFixedSizeText);
            int      TamanoEncabezado = Encabezado.tamanoAjustado;

            byte[] buffer;
            if (ID <= Raiz)
            {
                buffer = new byte[nodo.TamanoCorregido(nodo.Padre)];
                using (var _FileStream = new FileStream(Ruta, FileMode.OpenOrCreate))
                {
                    _FileStream.Seek((TamanoEncabezado + (Raiz - 1) * nodo.TamanoCorregido(nodo.Padre)), SeekOrigin.Begin);
                    _FileStream.Read(buffer, 0, nodo.TamanoCorregido(nodo.Padre));
                }
            }
            buffer = new byte[nodo.TamanoCorregido(nodo.Padre)];
            using (var _FileStream = new FileStream(Ruta, FileMode.OpenOrCreate))
            {
                _FileStream.Seek((TamanoEncabezado + ((Raiz - 1) * nodo.TamanoCorregido(nodo.Padre)) + nodo.TamanoCorregido(MetodosNecesarios.NullPointer)), SeekOrigin.Begin);
                _FileStream.Read(buffer, 0, nodo.TamanoCorregido(nodo.Padre));
            }
            var CadenaNodo = GeneradorData.ConvertToString(buffer);
            var valor      = CadenaNodo.Split(MetodosNecesarios.Separador);

            nodo.Padre = Convert.ToInt32(valor[1]);

            int LimitacionData = Order;

            if (nodo.Padre.Equals(MetodosNecesarios.NullPointer))
            {
                LimitacionData = (4 * (Order - 1)) / 3;
                int j = 0;
                for (int i = 2; i < LimitacionData + 2; i++)
                {
                    nodo.Data[j] = createFixedSizeText.Create(valor[i]);
                    j++;
                }
                j = 0;
                int LimitacionInicial = nodo.Data.Count + 2;
                for (int i = LimitacionInicial; i < valor.Length; i++)
                {
                    nodo.Hijos[j] = Convert.ToInt32(valor[i]);
                    j++;
                }
            }
            else
            {
                int j = 0;
                for (int i = 2; i < LimitacionData + 1; i++)
                {
                    nodo.Data[j] = createFixedSizeText.Create(valor[i]);
                    j++;
                }
                j = 0;
                int LimiteInicial = nodo.Data.Count + 2;
                for (int i = LimiteInicial; i < valor.Length; i++)
                {
                    nodo.Hijos[i] = Convert.ToInt32(valor[i]);
                    j++;
                }
            }
            return(nodo);
        }