public void Insert(TKey newKey, TData newData)
{
cerrarArchivo();
archivoArbol = File.Open(rutaArchivo, FileMode.Open);
if (Raiz == null)
{
nodoB <TKey, TData> newnodoB = NewnodoB();
newnodoB.insertar(newKey, newData);
Raiz = newnodoB;
archivoArbol.Seek(saltarEncabezado(), SeekOrigin.Begin);
archivoArbol.Write(ConvertStringTo_ByteChain(mostrar(Raiz)), 0, mostrar(Raiz).Length);
Cuenta++;
Altura++;
}
else
{
insertarRecursivamente(newKey, newData, Raiz);
}
archivoArbol.Seek(0, SeekOrigin.Begin);
if (Raiz == null)
{
Encabezado = Generador.armarEncabezado(Generador.hacerNulo().ToString(), Generador.tamanioPosicionesFijas(ultimaPosicion), Orden, Altura);
}
else
{
Encabezado = Generador.armarEncabezado(Generador.tamanioPosicionesFijas(Raiz.posicionPrincipal), Generador.tamanioPosicionesFijas(ultimaPosicion), Orden, Altura);
}
archivoArbol.Write(ConvertStringTo_ByteChain(Encabezado), 0, Encabezado.Length);
cerrarArchivo();
}
private void insertarRecursivamente(TKey newKey, TData newData, nodoB <TKey, TData> Current)
{
if (Current.esHoja())
{
if (!Current.estaLleno()) /*Insertará si y solo si es hoja y está vacío*/
{
Current.insertar(newKey, newData);
actaulizarNodo(Current);
}
else
{
//Esto indica que donde se iba a inseratr está lleno
nodoB <TKey, TData> aux = AccessTonodoB(Current.Padre);
InsertPop(Current, newData, newKey, posicionPrincipal(aux, newKey));
}
}
else
{
//Se moviliza hacia otro nodo
if (newKey.CompareTo(Current.nodoLlaves[0]) == -1)
{
insertarRecursivamente(newKey, newData, AccessTonodoB(Current.Hijos[0]));
}
else if (newKey.CompareTo(Current.nodoLlaves[0]) == 1)
{
int index = obtenerIndiceParaInsertar(Current, newKey);
insertarRecursivamente(newKey, newData, AccessTonodoB(Current.Hijos[index]));
}
else
{
Cuenta--;
}
}
}
private nodoB <TKey, TData> InsertPop(nodoB <TKey, TData> Actual, TData DataPop, TKey KeyPop, int posicionI)
{
if (Actual.estaLleno())
{
Actual.insertar(KeyPop, DataPop);
DataPop = Actual.nivelSuperior(ref KeyPop);
nodoB <TKey, TData> Hermano = NewnodoB();
nodoB <TKey, TData> Padre = AccessTonodoB(Actual.Padre);
Hermano.Padre = Actual.Padre;
actaulizarNodo(Hermano);
actaulizarNodo(Actual);
if (Padre == null)
{
nodoB <TKey, TData> newRaiz = NewnodoB();
newRaiz.insertar(KeyPop, DataPop);
newRaiz.insertarHijos(0, Actual.posicionPrincipal);
newRaiz.insertarHijos(1, Hermano.posicionPrincipal);
Raiz = newRaiz;
Actual.Padre = newRaiz.posicionPrincipal;
Hermano.Padre = newRaiz.posicionPrincipal;
actaulizarNodo(Raiz);
actaulizarNodo(Actual);
actaulizarNodo(Hermano);
Altura++;
if (posicionI < 0)
{
List <int> leftSon = new List <int>();
List <TData> nData = new List <TData>();
Hermano.nodoLlaves = Actual.HijosAndValuesToBrother(KeyPop, ref nData, ref leftSon);
Hermano.datosNodo = nData;
actualizarGrupoHijos(Actual, Actual.Hijos);
actualizarGrupoHijos(Hermano, leftSon);
actaulizarNodo(Actual);
actaulizarNodo(Hermano);
return(Actual);
}
else
{
List <int> leftSon = new List <int>();
List <TData> nData = new List <TData>();
Hermano.nodoLlaves = Actual.hijosyvaloresActuales(KeyPop, ref nData, ref leftSon);
Hermano.datosNodo = nData;
actualizarGrupoHijos(Actual, Actual.Hijos);
actualizarGrupoHijos(Hermano, leftSon);
actaulizarNodo(Actual);
actaulizarNodo(Hermano);
return(Hermano);
}
}
else
{
List <int> leftSon = new List <int>();
List <TData> nData = new List <TData>();
nodoB <TKey, TData> auxPadre = InsertPop(Padre, DataPop, KeyPop, posicionPrincipal(Padre, KeyPop));
int aproximateposicionPrincipal = auxPadre.posicionAproximada(KeyPop);
auxPadre.insertarHijos(aproximateposicionPrincipal, Hermano.posicionPrincipal);
Hermano.Padre = auxPadre.posicionPrincipal;
Actual = AccessTonodoB(Actual.posicionPrincipal);
Padre = AccessTonodoB(Padre.posicionPrincipal);
if (posicionI < 0)
{
Hermano.nodoLlaves = Actual.HijosAndValuesToBrother(KeyPop, ref nData, ref leftSon);
Hermano.datosNodo = nData;
actualizarGrupoHijos(Hermano, leftSon);
actaulizarNodo(auxPadre);
actaulizarNodo(Actual);
actaulizarNodo(Hermano);
actaulizarNodo(Padre);
actualizarGrupoHijos(Padre, Padre.Hijos);
actualizarGrupoHijos(auxPadre, auxPadre.Hijos);
return(Actual);
}
else if (posicionI > 0)
{
Hermano.nodoLlaves = Actual.hijosyvaloresActuales(KeyPop, ref nData, ref leftSon);
Hermano.datosNodo = nData;
actualizarGrupoHijos(Hermano, leftSon);
Hermano.Padre = auxPadre.posicionPrincipal;
actaulizarNodo(auxPadre);
actaulizarNodo(Actual);
actaulizarNodo(Hermano);
actaulizarNodo(Padre);
actualizarGrupoHijos(Padre, Padre.Hijos);
actualizarGrupoHijos(auxPadre, auxPadre.Hijos);
auxPadre = AccessTonodoB(auxPadre.posicionPrincipal);
Actual = AccessTonodoB(Actual.posicionPrincipal);
Hermano = AccessTonodoB(Hermano.posicionPrincipal);
Padre = AccessTonodoB(Padre.posicionPrincipal);
return(Hermano);
}
else
{
Hermano.nodoLlaves = Actual.hijosyvaloresActuales(KeyPop, ref nData, ref leftSon);
Hermano.datosNodo = nData;
actualizarGrupoHijos(Hermano, leftSon);
actaulizarNodo(auxPadre);
actaulizarNodo(Actual);
actaulizarNodo(Hermano);
actaulizarNodo(Padre);
actualizarGrupoHijos(Padre, Padre.Hijos);
actualizarGrupoHijos(auxPadre, auxPadre.Hijos);
return(Hermano);
}
}
}
else
{
Actual.insertar(KeyPop, DataPop);
actaulizarNodo(Actual);
if (Actual.posicionPrincipal == Raiz.posicionPrincipal)
{
Raiz = Actual;
}
return(Actual);
}
}
