private void CambiarValores(BNode <TKey, T> NodoHojaNo, int eliminarPosi, BNode <TKey, T> HojaNodo)
{
TKey pivoteTKey = NodoHojaNo.Llave[eliminarPosi];
T pivoteT = NodoHojaNo.Datos[eliminarPosi];
NodoHojaNo.Llave[eliminarPosi] = HojaNodo.Llave[HojaNodo.LlaveCon() - 1];
NodoHojaNo.Datos[eliminarPosi] = HojaNodo.Datos[HojaNodo.DatoCon() - 1];
HojaNodo.Llave[HojaNodo.LlaveCon() - 1] = pivoteTKey;
HojaNodo.Datos[HojaNodo.DatoCon() - 1] = pivoteT;
archivoArbol.InsertarNodo(HojaNodo, nombreArchivo, true);
archivoArbol.InsertarNodo(NodoHojaNo, nombreArchivo, true);
}
public override void Eliminar(T eliminaDato)
{
BNode <TKey, T> escogido = Buscar(eliminaDato);
int eliminarPosi = ObtenerPosicionEliminada(escogido, eliminaDato);
if (!Hoja(escogido))
{
CambiarValores(escogido, eliminarPosi, DerEnIz(escogido, eliminarPosi));
escogido = DerEnIz(escogido, eliminarPosi);
eliminarPosi = escogido.LlaveCon() - 1;
}
escogido.Llave.RemoveAt(eliminarPosi);
escogido.Datos.RemoveAt(eliminarPosi);
archivoArbol.InsertarNodo(escogido, nombreArchivo, true);
if (UnderFlow(escogido))
{
ResolverUF(escogido, eliminarPosi);
}
while (EliminarPadre.Count != 0)
{
int posiPadre = EliminarPadre.Dequeue();
int posiIndex = EliminarIndex.Dequeue();
BNode <TKey, T> PadreAfectado = archivoArbol.ConvertirLinea(nombreArchivo, posiPadre, grado);
if (UnderFlow(PadreAfectado))
{
ResolverUF(PadreAfectado, posiIndex);
}
}
}
private bool UnderFlow(BNode <TKey, T> escogido)
{
if (escogido.LlaveCon() <= (this.grado - 1) / 2 - 1)
{
return(true);
}
return(false);
}
private void ResolverUF(BNode <TKey, T> corriente, int eliminarPosi)
{
BNode <TKey, T> HermanoNodo = CambiarHemano(corriente);
if (HermanoNodo.LlaveCon() <= (this.grado - 1) / 2)
{
Mezcla(corriente, HermanoNodo);
}
else
{
Prestamo(corriente, HermanoNodo, eliminarPosi);
}
}
private int ObtenerHermanoExtremo(BNode <TKey, T> corriente, BNode <TKey, T> hermanoNodo)
{
int corrient = ObtenerNumeroHijosPadres(corriente.Posi, archivoArbol.ConvertirLinea(nombreArchivo, corriente.Padre, grado));
int hermano = ObtenerNumeroHijosPadres(hermanoNodo.Posi, archivoArbol.ConvertirLinea(nombreArchivo, hermanoNodo.Padre, grado));
int extremoApropiado = -1;
if (corrient > hermano)
{
extremoApropiado = hermanoNodo.LlaveCon() - 1;
}
else
{
extremoApropiado = 0;
}
return(extremoApropiado);
}
private void EliminarNodo(T eliminarValor, BNode <TKey, T> corriente)
{
BNode <TKey, T> escogido = corriente;
int eliminarPosi = ObtenerPosicionEliminada(escogido, eliminarValor);
if (!Hoja(escogido))
{
CambiarValores(escogido, eliminarPosi, DerEnIz(escogido, eliminarPosi));
escogido = DerEnIz(escogido, eliminarPosi);
eliminarPosi = escogido.LlaveCon() - 1;
}
escogido.Llave.RemoveAt(eliminarPosi);
escogido.Datos.RemoveAt(eliminarPosi);
if (UnderFlow(escogido))
{
ResolverUF(escogido, eliminarPosi);
}
}
private int ObtenerPosicionEliminada(BNode <TKey, T> escogido, T eliminarValor)
{
int pos = -1;
try
{
for (int i = 0; i < escogido.LlaveCon(); i++)
{
if (escogido.Datos[i].CompareTo(eliminarValor) == 0)
{
return(i);
}
}
return(pos);
}
catch
{
return(pos);
}
}
private BNode <TKey, T> CrearMezcla(int corriente, int hermanoNodo, int espacioPadre, BNode <TKey, T> padrel)
{
BNode <TKey, T> nuevoNodo;
// Eliminar al padre del que ya se eliminio
if (corriente < hermanoNodo)
{
nuevoNodo = archivoArbol.ConvertirLinea(nombreArchivo, padrel.ApuntaHijo[corriente], grado);
nuevoNodo.Llave[nuevoNodo.LlaveCon()] = padrel.Llave[espacioPadre];
nuevoNodo.Datos[nuevoNodo.DatoCon()] = padrel.Datos[espacioPadre];
EliminarIndex.Enqueue(espacioPadre);
EliminarPadre.Enqueue(padrel.Posi);
EliminarUnder(padrel, espacioPadre);
BNode <TKey, T> hermano = archivoArbol.ConvertirLinea(nombreArchivo, padrel.ApuntaHijo[hermanoNodo], grado);
for (int i = 0; i < hermano.LlaveCon(); i++)
{
nuevoNodo.Llave[nuevoNodo.LlaveCon()] = hermano.Llave[i];
nuevoNodo.Datos[nuevoNodo.DatoCon()] = hermano.Datos[i];
}
for (int j = 0; j < hermano.HijoCon(); j++)
{
nuevoNodo.ApuntaHijo[nuevoNodo.HijoCon()] = hermano.ApuntaHijo[j];
}
BNode <TKey, T> padre = archivoArbol.ConvertirLinea(nombreArchivo, hermano.Padre, grado);
padre.ApuntaHijo.Remove(hermano.Posi);
padre.ApuntaHijo[padre.HijoCon()] = nuevoNodo.Posi;
archivoArbol.InsertarNodo(padre, nombreArchivo, true);
hermano.Padre = -2147483648;
archivoArbol.InsertarNodo(hermano, nombreArchivo, true);
}
else
{
nuevoNodo = archivoArbol.ConvertirLinea(nombreArchivo, padrel.ApuntaHijo[hermanoNodo], grado);
nuevoNodo.Llave[nuevoNodo.LlaveCon()] = (padrel.Llave[espacioPadre]);
nuevoNodo.Datos[nuevoNodo.LlaveCon()] = (padrel.Datos[espacioPadre]);
EliminarIndex.Enqueue(espacioPadre);
EliminarPadre.Enqueue(padrel.Posi);
EliminarUnder(padrel, espacioPadre);
BNode <TKey, T> corrient = archivoArbol.ConvertirLinea(nombreArchivo, padrel.ApuntaHijo[corriente], grado);
for (int i = 0; i < corrient.LlaveCon(); i++)
{
nuevoNodo.Llave[nuevoNodo.LlaveCon()] = corrient.Llave[i];
nuevoNodo.Datos[nuevoNodo.LlaveCon()] = corrient.Datos[i];
}
for (int j = 0; j < corrient.HijoCon(); j++)
{
nuevoNodo.ApuntaHijo[nuevoNodo.HijoCon()] = corrient.ApuntaHijo[j];
}
BNode <TKey, T> padrelo = archivoArbol.ConvertirLinea(nombreArchivo, corrient.Padre, grado);
padrelo.ApuntaHijo.Remove(corrient.Posi);
padrelo.ApuntaHijo[padrelo.HijoCon()] = nuevoNodo.Posi;
archivoArbol.InsertarNodo(padrelo, nombreArchivo, true);
corrient.Padre = -2147483648;
archivoArbol.InsertarNodo(corrient, nombreArchivo, true);
}
List <int> hijoCorrecto = new List <int>();
for (int i = 0; i < nuevoNodo.ApuntaHijo.Count; i++)
{
if (nuevoNodo.ApuntaHijo[i] > -2147483648)
{
hijoCorrecto.Add(nuevoNodo.ApuntaHijo[i]);
}
}
nuevoNodo.ApuntaHijo = hijoCorrecto;
return(nuevoNodo);
}
