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); } } }