public static void Children_Order(Nodo <T> nodo_actual, List <Nodo <T> > list)
{
//Ordenar los hijos
List <Nodo <T> > list_aux = new List <Nodo <T> >(); //lista auxiliar para guardar hijos actuales
List <T> list_aux_valores = new List <T>(); //lista auxiliar para guardar el primer valor de cada hijo
for (int x = 0; x < nodo_actual.Children.Length; x++)
{
if (nodo_actual.Children[x] != null)
{
list_aux.Add(nodo_actual.Children[x]);
list_aux_valores.Add(nodo_actual.Children[x].Values[0]);
}
}
for (int x = 0; x < list.Count; x++)
{
list_aux.Add(list[x]);
list_aux_valores.Add(list[x].Values[0]);
}
//Ordenamos los primeros valores de cada hijo
var sortedList1 = GenericComparation <T> .SortedList(list_aux_valores.ToArray(), Soda.CompareByName);
//Ya ordenados los valores guardamos los hijos en su nueva posicion
for (int x = 0; x < sortedList1.Length; x++)
{
for (int y = 0; y < list_aux.Count; y++)
{
if (list_aux[y].Values[0].Equals(sortedList1[x]))
{
nodo_actual.Children[x] = list_aux[y];
nodo_actual.Children[x].father = nodo_actual;
}
}
}
}
public static Nodo <T> Insert_NewFather(Nodo <T> nodo_actual, T[] sortedList, int medio, List <Nodo <T> > list)
{
Nodo <T> actual_father = new Nodo <T>();
actual_father.Values[0] = sortedList[medio];
Nodo <T> nodo_aux = new Nodo <T>();
for (int x = 0; x < medio; x++)
{
nodo_aux.Values[x] = sortedList[x];
}
Nodo <T> nodo_aux1 = new Nodo <T>();
int x_aux = 0;
for (int x = medio + 1; x < sortedList.Length; x++)
{
nodo_aux1.Values[x_aux] = sortedList[x];
x_aux++;
}
//ORdenar hijos si la lista no es vacia
if (list != null)
{
//Ordenar los hijos
List <Nodo <T> > list_aux = new List <Nodo <T> >(); //lista auxiliar para guardar hijos actuales
List <T> list_aux_valores = new List <T>(); //lista auxiliar para guardar el primer valor de cada hijo
for (int x = 0; x < nodo_actual.Children.Length; x++)
{
if (nodo_actual.Children[x] != null)
{
list_aux.Add(nodo_actual.Children[x]);
list_aux_valores.Add(nodo_actual.Children[x].Values[0]);
}
}
for (int x = 0; x < list.Count; x++)
{
list_aux.Add(list[x]);
list_aux_valores.Add(list[x].Values[0]);
}
//Ordenamos los primeros valores de cada hijo
var sortedList1 = GenericComparation <T> .SortedList(list_aux_valores.ToArray(), Soda.CompareByName);
nodo_aux.Children = new Nodo <T> [m];
//asignamos los hijos de nodo_aux
int hijos = sortedList1.Length / 2;
for (int x = 0; x < hijos; x++)
{
for (int y = 0; y < list_aux.Count; y++)
{
if (list_aux[y].Values[0].Equals(sortedList1[x]))
{
nodo_aux.Children[x] = list_aux[x];
nodo_aux.Children[x].father = nodo_aux;
}
}
}
nodo_aux1.Children = new Nodo <T> [m];
//asignamos los hijos de nodo_aux1
for (int x = hijos; x < sortedList1.Length; x++)
{
for (int y = 0; y < list_aux.Count; y++)
{
if (list_aux[y].Equals(sortedList1[x]))
{
nodo_aux1.Children[x] = list_aux[x];
nodo_aux1.Children[x].father = nodo_aux1;
}
}
}
}
nodo_aux.father = actual_father;
nodo_aux1.father = actual_father;
actual_father.Children[0] = nodo_aux;
actual_father.Children[1] = nodo_aux1;
actual_father.father = null;
return(actual_father);
}
public void Insert(Nodo <T> nodo_actual, T value, List <Nodo <T> > list)
{
if (object.Equals(nodo_actual.Children[0], default(T)) && object.Equals(nodo_actual.Children[1], default(T))) //El nodo es hoja
{
if (object.Equals(nodo_actual.Values[Nodo <T> .m - 2], default(T))) //Hay espacio en el nodo hoja
{
nodo_actual.Insert_Aux(value);
var sortedList = GenericComparation <T> .SortedList(nodo_actual.Values, Soda.CompareByName);
for (int x = 0; x < sortedList.Length; x++)
{
nodo_actual.Values[x] = sortedList[x]; //Inserto los valores ordenados por burbuja en el vector
}
}
else //no hay espacio en el nodo hoja
{
int medio = Nodo <T> .m / 2;
T[] aux = new T[Nodo <T> .m];
for (int x = 0; x < aux.Length - 1; x++) //Inserto los valores que ya tengo en un arreglo auxiliar
{
aux[x] = nodo_actual.Values[x];
}
aux[aux.Length - 1] = value;
var sortedList = GenericComparation <T> .SortedList(aux, Soda.CompareByName);
if (object.Equals(nodo_actual.father, default(T)))
{ //No existe padre
Nodo <T> actual_father = Nodo <T> .Insert_NewFather(nodo_actual, sortedList, medio, null);
raiz = actual_father;
}
else
{ //Si existe padre
Nodo <T> nodo_aux = new Nodo <T>();
for (int x = 0; x < medio; x++)
{
nodo_aux.Values[x] = sortedList[x];
}
Nodo <T> nodo_aux1 = new Nodo <T>();
int x_aux = 0;
for (int x = medio + 1; x < sortedList.Length; x++)
{
nodo_aux1.Values[x_aux] = sortedList[x];
x_aux++;
}
List <Nodo <T> > list1 = new List <Nodo <T> >();
list1.Add(nodo_aux);
list1.Add(nodo_aux1);
//Eliminamos el nodo en la lista de Nodos del padre
int eliminar = nodo_actual.father.Delete_Nodo_InList(nodo_actual);
if (eliminar != -1)
{
nodo_actual.father.Children[eliminar] = null;
}
Insert(nodo_actual.father, sortedList[medio], list1); //enviamos valores nuevos para ingresar
}
}
}
else //El nodo no es hoja
{
if (list != null) //El nodo ya trae hijos si no trae hijos es porque es un valor nuevo
{
if (object.Equals(nodo_actual.Values[Nodo <T> .m - 2], default(T))) //Hay espacio en el nodo
{
nodo_actual.Insert_Aux(value);
var sortedList = GenericComparation <T> .SortedList(nodo_actual.Values, Soda.CompareByName);
for (int x = 0; x < sortedList.Length; x++)
{
nodo_actual.Values[x] = sortedList[x]; //Inserto los valores ordenados por burbuja en el vector
}
//Ordenar los hijos
Nodo <T> .Children_Order(nodo_actual, list);
}
else //No hay espacio en el nodo
{
int medio = Nodo <T> .m / 2;
T[] aux = new T[Nodo <T> .m];
for (int x = 0; x < Nodo <T> .m - 1; x++) //Inserto los valores que ya tengo en un arreglo auxiliar
{
aux[x] = nodo_actual.Values[x];
}
aux[aux.Length - 1] = value;
var sortedList = GenericComparation <T> .SortedList(aux, Soda.CompareByName);
if (object.Equals(nodo_actual.father, default(T)))
{ //No existe padre
Nodo <T> actual_father = Nodo <T> .Insert_NewFather(nodo_actual, sortedList, medio, list);
raiz = actual_father;
//unir todos los hijos de los hijos del padre
}
else
{ //Si existe padre
Nodo <T> nodo_aux = new Nodo <T>();
for (int x = 0; x < medio - 1; x++)
{
nodo_aux.Values[x] = sortedList[x];
}
Nodo <T> nodo_aux1 = new Nodo <T>();
int x_aux = 0;
for (int x = medio; x < sortedList.Length; x++)
{
nodo_aux1.Values[x_aux] = sortedList[x];
x_aux++;
}
list.Add(nodo_aux);
list.Add(nodo_aux1);
//Eliminamos el nodo en la lista de Nodos del padre
int eliminar = nodo_actual.father.Delete_Nodo_InList(nodo_actual);
if (eliminar != -1)
{
nodo_actual.father.Children[eliminar] = null;
}
//reordenar hijos de los nodos
Insert(nodo_actual.father, sortedList[medio - 1], list); //enviamos valores nuevos para ingresar
}
}
}
else
{
int pos = GenericComparation <T> .Position(nodo_actual.Values, Soda.CompareByName, value);
Insert(nodo_actual.Children[pos], value, null);
}
}
}
