public void insertarNodo(nodo cl)
        {
            Pagina temp = ArbolB.raiz;

            insertar(ref temp, cl);
            ArbolB.raiz = temp;
        }
        public nodo buscarTransaccion(ref Pagina raiz, string transactionID)
        {
            nodo temp = null;

            for (int i = 0; i < 5; i++)
            {
                if (raiz.claves[i] != null && raiz.claves[i].transactionID.Equals(transactionID))
                {
                    temp = raiz.claves[i];
                    if (temp != null)
                    {
                        return(temp);
                    }
                }

                if (raiz.ramas[i] != null)
                {
                    temp = buscarTransaccion(ref raiz.ramas[i], transactionID);
                    if (temp != null)
                    {
                        return(temp);
                    }
                }
            }

            return(temp);
        }
        public void meterHoja(ref Pagina actual, ref nodo cl, ref Pagina rd, int k)
        {
            int i;

            for (i = actual.cuenta; i >= k + 1; i--)
            {
                actual.claves[i + 1] = actual.claves[i];
                actual.ramas[i + 1]  = actual.ramas[i];

                actual.claves[i] = null;
                actual.ramas[i]  = null;
            }
            actual.claves[k + 1] = cl;
            actual.ramas[i + 1]  = rd;
            actual.cuenta++;
        }
        public void insertar(ref Pagina raiz, nodo cl)
        {
            bool   subeArriba = false;
            nodo   mediana = null;
            Pagina p, nd = null;

            empujar(ref raiz, cl, ref subeArriba, ref mediana, ref nd);

            if (subeArriba)
            {
                p           = new Pagina(this.orden);
                p.cuenta    = 1;
                p.claves[1] = mediana;
                p.ramas[0]  = raiz;
                p.ramas[1]  = nd;
                raiz        = p;
            }
        }
        public void eliminar(ref Pagina raiz, nodo cl)
        {
            bool encontrado = false;

            eliminarRegistro(ref raiz, cl, ref encontrado);
            if (encontrado)
            {
                System.Console.WriteLine("Clave %s eliminada\n", cl.transactionID);
                if (raiz.cuenta == 0)
                {
                    Pagina p = raiz;
                    raiz = raiz.ramas[0];
                }
            }
            else
            {
                System.Console.WriteLine("La clave no se encuentra en el arbol\n");
            }
        }
        public bool buscarNodo(ref Pagina actual, nodo cl, ref int k)
        {
            bool encontrado;

            if (strcmp(cl.transactionID, actual.claves[1].transactionID) < 0)
            {
                encontrado = false;
                k          = 0;
            }
            else
            {
                k = actual.cuenta;
                while (actual.claves[k].transactionID != null && (strcmp(cl.transactionID, actual.claves[k].transactionID) < 0) && (k > 1))
                {
                    (k)--;
                }

                encontrado = (strcmp(cl.transactionID, actual.claves[k].transactionID) == 0);
            }
            return(encontrado);
        }
        public void empujar(ref Pagina actual, nodo cl, ref bool subeArriba, ref nodo mediana, ref Pagina nuevo)
        {
            int k = 0;

            if (actual == null)
            {
                subeArriba = true;
                mediana    = cl;
                nuevo      = null;
            }
            else
            {
                bool esta;
                esta = buscarNodo(ref actual, cl, ref k);

                if (esta)
                {
                    System.Console.WriteLine("\nClave duplicada");
                    subeArriba = false;
                    return;
                }

                empujar(ref actual.ramas[k], cl, ref subeArriba, ref mediana, ref nuevo);


                if (subeArriba)
                {
                    if (nodoLLeno(actual))
                    {
                        dividirNodo(ref actual, ref mediana, ref nuevo, k, ref mediana, ref nuevo);
                    }
                    else
                    {
                        subeArriba = false;
                        meterHoja(ref actual, ref mediana, ref nuevo, k);
                    }
                }
            }
        }
        public void dividirNodo(ref Pagina actual, ref nodo cl, ref Pagina rd, int k, ref nodo mediana, ref Pagina nuevo)
        {
            int i, claveMedia;

            claveMedia = (k <= this.orden / 2) ? this.orden / 2 : this.orden / 2 + 1;
            if (nuevo == null)
            {
                nuevo = new Pagina(5);
            }

            for (i = claveMedia + 1; i < this.orden; i++)
            {
                nuevo.claves[i - claveMedia] = actual.claves[i];
                nuevo.ramas[i - claveMedia]  = actual.ramas[i];

                actual.claves[i] = null;
                actual.ramas[i]  = null;
            }
            nuevo.cuenta  = (this.orden - 1) - claveMedia;
            actual.cuenta = claveMedia;

            Pagina nula = null;

            if (k <= this.orden / 2)
            {
                meterHoja(ref actual, ref cl, ref nula, k);
            }
            else
            {
                meterHoja(ref nuevo, ref cl, ref nula, k - claveMedia);
            }


            mediana        = actual.claves[actual.cuenta];
            nuevo.ramas[0] = actual.ramas[actual.cuenta];
            actual.ramas[actual.cuenta]  = null;
            actual.claves[actual.cuenta] = null;
            actual.cuenta--;
        }
        public void eliminarRegistro(ref Pagina actual, nodo cl, ref bool encontrado)
        {
            int k = 0;

            if (actual != null)
            {
                encontrado = buscarNodo(ref actual, cl, ref k);
                if (encontrado)
                {
                    if (actual.ramas[k - 1] == null)
                    {
                        quitar(ref actual, k);
                    }
                    else
                    {
                        sucesor(ref actual, k);
                        eliminarRegistro(ref actual.ramas[k], actual.claves[k], ref encontrado);
                    }
                }
                else
                {
                    eliminarRegistro(ref actual.ramas[k], cl, ref encontrado);
                }

                if (actual.ramas[k] != null)
                {
                    if (actual.ramas[k].cuenta < this.orden / 2)
                    {
                        restablecer(ref actual, k);
                    }
                }
            }
            else
            {
                encontrado = false;
            }
        }
 public Pagina(int orden)
 {
     this.orden = orden;
     claves     = new nodo[this.orden];
     ramas      = new Pagina[this.orden];
 }