public Nodo InsertNodo(string lineaALeer, string ruta)
{
LecRaiz = Leer(lineaALeer);
return(LecRaiz);
}
private void InsertarNoLleno(Nodo actual, Soda dato)
{
var i = actual.tamaño - 1;
var m = actual.tamaño;
//Cuando inserto en rama y si tiene hijos
if (!actual.esHoja)
{
while (i >= 0 && dato.nombre.CompareTo(actual.Llaves[i].nombre) == -1)
{
actual.Llaves[i + 1] = actual.Llaves[i];
actual.hijos[i + 2] = actual.hijos[i + 1];
i--;
}
}
else
{
while (i >= 0 && dato.nombre.CompareTo(actual.Llaves[i].nombre) == -1)
{
actual.Llaves[i + 1] = actual.Llaves[i];
i--;
}
}
actual.Llaves[i + 1] = dato;
actual.tamaño++;
//Mover hijo si no es hoja
if (!actual.esHoja)
{
var x = i + 1;
var c = i + 2;
actual.hijos[c] = actual.hijos[x];
actual.hijos[x] = new Nodo(tamanioMax);
int j = 0;
for (; actual.hijos[c].Llaves[j].nombre.CompareTo(dato.nombre) == -1; j++)
{
actual.hijos[x].Llaves[j] = actual.hijos[c].Llaves[j];
if (!actual.hijos[c].esHoja)
{
actual.hijos[x].hijos[j] = actual.hijos[c].hijos[j];
}
actual.hijos[c].tamaño--;
actual.hijos[x].tamaño++;
}
int k;
for (k = j; k < m; k++)
{
actual.hijos[c].Llaves[k - j] = actual.hijos[c].Llaves[k];
actual.hijos[c].Llaves[k] = null;
if (!actual.hijos[c].esHoja)
{
actual.hijos[c].hijos[k - j] = actual.hijos[c].hijos[k];
actual.hijos[c].hijos[k] = null;
}
}
if (!actual.hijos[c].esHoja)
{
actual.hijos[c].hijos[actual.hijos[c].tamaño] = actual.hijos[c].hijos[k - j];
}
if (actual.tamaño == tamanioMax - 1)
{
actual.estaLleno = true;
}
}
}
private void PartirEn23(Nodo padre, int indexHijoLleno, Soda dato, bool hermanoIzquierdo)
{
//Si el tiene un padre, el no es raiz
int indexLadoIzquierdo = hermanoIzquierdo ? (indexHijoLleno - 1) : indexHijoLleno;
int indexLadoDerecho = hermanoIzquierdo ? (indexHijoLleno) : indexHijoLleno + 1;
int dosTercios = (tamanioMax * 2) / 3;
int indexLlavePadre = hermanoIzquierdo ? (indexHijoLleno - 1) : (indexHijoLleno);
int tamañoMaxNodo = tamanioMax - 1;
bool esHoja = padre.hijos[indexHijoLleno].esHoja;
int j = 0;
var arr = new Soda[tamanioMax * 2];
var hijos = new Nodo[tamanioMax * 2];
for (int i = 0; i < tamañoMaxNodo; i++)
{
arr[j++] = padre.hijos[indexLadoIzquierdo].Llaves[i];
arr[j++] = padre.hijos[indexLadoDerecho].Llaves[i];
}
arr[j++] = dato;
arr[j++] = padre.Llaves[indexLlavePadre];
if (!esHoja)
{
int x = 0;
for (int i = 0; i < tamanioMax; i++)
{
hijos[x++] = padre.hijos[indexLadoIzquierdo].hijos[i];
}
for (int i = 0; i < tamanioMax; i++)
{
hijos[x++] = padre.hijos[indexLadoDerecho].hijos[i];
}
}
j = 0;
int k;
for (k = 0; k < dosTercios; k++)
{
padre.hijos[indexLadoIzquierdo].Llaves[k] = arr[j++];
}
while (k < tamañoMaxNodo)
{
padre.hijos[indexLadoIzquierdo].Llaves[k++] = null;
padre.hijos[indexLadoIzquierdo].tamaño--;
}
padre.hijos[indexLadoIzquierdo].estaLleno = false;
Soda padre1 = arr[j++];
padre.Llaves[indexLlavePadre] = padre1;
for (k = 0; k < dosTercios; k++)
{
padre.hijos[indexLadoDerecho].Llaves[k] = arr[j++];
}
while (k < tamañoMaxNodo)
{
padre.hijos[indexLadoDerecho].Llaves[k++] = null;
padre.hijos[indexLadoDerecho].tamaño--;
}
padre.hijos[indexLadoDerecho].estaLleno = false;
Soda padre2 = arr[j++];
var nuevoNodo = new Nodo(tamanioMax);
for (k = 0; j < tamanioMax * 2; k++)
{
nuevoNodo.Llaves[k] = arr[j++];
nuevoNodo.tamaño++;
}
var nodoDerecho = padre.hijos[indexLadoDerecho];
if (padre.estaLleno)
{
if (padre.Padre == null)
{
partirRaiz(padre);
}
else
{
InsertarEnHoja(padre.Padre, padre.indiceHijoDePadre, padre2);
}
}
else
{
int m = nodoDerecho.Padre.tamaño - 1;
for (; m > indexLlavePadre; m--)
{
nodoDerecho.Padre.hijos[m + 1] = nodoDerecho.Padre.hijos[m + 1];
}
nodoDerecho.Padre.Llaves[m + 1] = padre2;
nodoDerecho.Padre.hijos[m + 2] = nuevoNodo;
nodoDerecho.Padre.tamaño++;
nuevoNodo.Padre = nodoDerecho.Padre;
nuevoNodo.esHoja = esHoja;
}
if (nodoDerecho.Padre.tamaño == tamanioMax - 1)
{
nodoDerecho.Padre.estaLleno = true;
}
}
