public void InsertarNodo(NodoArbolB <T> Nodo, T valor) { if (Raiz.ID == 0) { Raiz = new NodoArbolB <T>(); Raiz.ObtenerGrado(Raiz, 3); Raiz.ListaRegistros.Add(valor); Raiz.ID = 1; Nodo = Raiz; } //ES HOJA else if (TieneHijos(Nodo) == false) //Cambiar a Nodo.Hijos.Count != 0 Borrar el metodo para ver si tiene hijos { ValorAgregadoOrdenado(valor, Nodo); } //NO ES HOJA else if (TieneHijos(Nodo) == true) { var NodoHijo = new NodoArbolB <T>(); NodoHijo = Nodo.Hijos[IndiceHijo(Nodo, valor)]; //BUSCA POSICION CORRESPONDIENTE InsertarNodo(NodoHijo, valor); } if (TieneEspacio(Nodo) == false) { DividirEnNodos(Nodo); } }
public void MoverValor(NodoArbolB <T> hijoEmisor, int posicionvalorpadre, NodoArbolB <T> padre, NodoArbolB <T> nodoReceptor) { //NODO HERMANO IZQUIERDO: Si debo de pasar el ultimo dato if (hijoEmisor.ListaRegistros[hijoEmisor.ListaRegistros.Count - 1].CompareTo(padre.ListaRegistros[posicionvalorpadre]) < 0) //Hijo a la izquierda { padre.ListaRegistros.Add(hijoEmisor.ListaRegistros[hijoEmisor.ListaRegistros.Count - 1]); //Subir valor hijoEmisor.ListaRegistros.Remove(hijoEmisor.ListaRegistros[hijoEmisor.ListaRegistros.Count - 1]); //quita valor que se paso a padre nodoReceptor.ListaRegistros.Add(padre.ListaRegistros[posicionvalorpadre]); //bajar valor de padre padre.ListaRegistros.Remove(padre.ListaRegistros[posicionvalorpadre]); nodoReceptor.ListaRegistros.Sort((x, y) => x.CompareTo(y)); // ordenar hijo que recibe //hijoEmisor.Valores.RemoveAt(hijoEmisor.Valores.Count - 1); padre.ListaRegistros.Sort((x, y) => x.CompareTo(y)); } //HIJO A LA DERECHA: Si debo de pasar el primer dato else if (hijoEmisor.ListaRegistros[0].CompareTo(padre.ListaRegistros[posicionvalorpadre]) > 0) { padre.ListaRegistros.Add(hijoEmisor.ListaRegistros[0]); nodoReceptor.ListaRegistros.Add(padre.ListaRegistros[posicionvalorpadre]); nodoReceptor.ListaRegistros.Sort((x, y) => x.CompareTo(y)); hijoEmisor.ListaRegistros.Remove(hijoEmisor.ListaRegistros[0]); padre.ListaRegistros.Remove(padre.ListaRegistros[posicionvalorpadre]); padre.ListaRegistros.Sort((x, y) => x.CompareTo(y)); } }
public int IndiceHijo(NodoArbolB <T> Nodo, T valor) { if (Nodo.ListaRegistros.Count == 1) //Solo tiene un valor { if (valor.CompareTo(Nodo.ListaRegistros[0]) < 0) //si es menor que el existente { return(0); //Indice es 0 } else //Si es mayor que el existente { return(1); //Indice es 1 } } else //Si tiene mas de un valor { for (int i = 0; i < Nodo.ListaRegistros.Count - 1; i++) //Recorre las posicions de la lista { if (valor.CompareTo(Nodo.ListaRegistros[i]) < 0) //Si llega a ser menor en algun momento, retorna este indice { return(i); } else if (valor.CompareTo(Nodo.ListaRegistros[i]) > 0 && valor.CompareTo(Nodo.ListaRegistros[i + 1]) < 0) { return(i + 1); //Si esta entre dos valores, retorna el indice del mayor para "correr" el arreglo } } return(Nodo.ListaRegistros.Count); } }
public T BuscarNodo(T Valbuscar, NodoArbolB <T> Nodo) { bool Encontrado = false; foreach (var item in Nodo.ListaRegistros) //Recorre en los valores del nodo { if (item.CompareTo(Valbuscar) == 0) { Encontrar = item; Encontrado = true; break; } } if (Encontrado == false && Nodo.Hijos.Count > 0) { NodoArbolB <T> NodoHijo = new NodoArbolB <T>(); NodoHijo = Nodo.Hijos[IndiceHijo(Nodo, Valbuscar)]; return(BuscarNodo(Valbuscar, NodoHijo)); //Busca en hijo } else if (Encontrado == true) { return(Encontrar); } else if (Nodo.Hijos.Count == 0) { throw new NotImplementedException(); } else { return(Encontrar); } }
public void CrearNodo(NodoArbolB <T> nuevo, NodoArbolB <T> nodo) { nuevo.Maximo = nodo.Maximo; nuevo.Minimo = nodo.Minimo; nuevo.ID = Siguiente; Siguiente++; }
public bool TieneEspacio(NodoArbolB <T> Nodo) { if (Nodo.ListaRegistros.Count <= Nodo.Maximo) { return(true); } else { return(false); } }
public void HijosHijo(NodoArbolB <T> Nodo, NodoArbolB <T> NodoH, int Inicio, int Final) { for (int i = Inicio; i <= Final; i++) { NodoH.Hijos.Add(Nodo.Hijos[i]); } foreach (var item in NodoH.Hijos) { item.Padre = NodoH; } }
public bool CantidadMenor(NodoArbolB <T> Nodo) //Revisa si tiene la cantidad minima de valores del nodo { if (Nodo.ListaRegistros.Count < Nodo.Minimo) { return(true); } else { return(false); } }
public bool TieneHijos(NodoArbolB <T> Nodo) { if (Nodo.Hijos.Count == 0) { return(false); } else { return(true); } }
public void Eliminar(T valor, NodoArbolB <T> Nodo) { int Indice = 0; bool Inicial = false; bool Encontrado = false; for (int i = 0; i < Nodo.ListaRegistros.Count; i++) { if (Nodo.ListaRegistros[i].CompareTo(valor) == 0) { Encontrado = true; if (TieneHijos(Nodo) == true) { Indice = i; //Posicion de valor a sustituir Cambiar = Nodo; //Nodo a sustituir Cont++; //revisar para que se usa Inicial = true; Dar = ValorMasIzquierdodeDerecha(Indice, Nodo, false); Cambiar.ListaRegistros.Add(Dar.ListaRegistros[0]); Cambiar.ListaRegistros.RemoveAt(Indice); Dar.ListaRegistros.RemoveAt(0); Cambiar.ListaRegistros.Sort((x, y) => x.CompareTo(y)); if (CantidadMenor(Dar) == true) { PrestarDeHermano(Dar.Padre, Dar); //Ver si hermano puede prestar } } else { Nodo.ListaRegistros.RemoveAt(i); } if (Inicial == true) { Nodo = Cambiar; } if (CantidadMenor(Nodo) == true) { PrestarDeHermano(Nodo.Padre, Nodo); //Ver si hermano puede prestar } } } if (Encontrado == false && Nodo.Hijos.Count > 0) { NodoArbolB <T> NodoHijo = new NodoArbolB <T>(); NodoHijo = Nodo.Hijos[IndiceHijo(Nodo, valor)]; Eliminar(valor, NodoHijo); } }
public NodoArbolB <T> ValorMasIzquierdodeDerecha(int IndiceValor, NodoArbolB <T> Nodo, bool IrDerecha) { if (IrDerecha == false && Nodo.Hijos.Count > 0) { IrDerecha = true; return(ValorMasIzquierdodeDerecha(IndiceValor, Nodo.Hijos[IndiceValor + 1], IrDerecha)); } else if (IrDerecha == true && Nodo.Hijos.Count > 0) { return(ValorMasIzquierdodeDerecha(IndiceValor, Nodo.Hijos[0], IrDerecha)); } else if (IrDerecha == true && Nodo.Hijos.Count == 0) { return(Nodo); } else { return(Nodo); } }
public void Unir(NodoArbolB <T> padre, int posicionvalorpadre, NodoArbolB <T> hijo, NodoArbolB <T> hermano) { if (hijo.ListaRegistros[0].CompareTo(padre.ListaRegistros[padre.ListaRegistros.Count - 1]) > 0) //HIJO A LA DERECHA: Si es el ultimo nodo { hermano = padre.Hijos[posicionvalorpadre]; for (int i = 0; i < hermano.ListaRegistros.Count; i++) { hijo.ListaRegistros.Add(hermano.ListaRegistros[i]); } if (TieneHijos(hijo) == true) { for (int i = 0; i < hermano.Hijos.Count; i++) { hijo.Hijos.Add(hermano.Hijos[i]); } } padre.Hijos.RemoveAt(posicionvalorpadre); //Elimina el nodo hermano hijo.ListaRegistros.Add(padre.ListaRegistros[posicionvalorpadre]); //Manda valor de raiz hijo.ListaRegistros.Sort((x, y) => x.CompareTo(y)); padre.ListaRegistros.Remove(padre.ListaRegistros[posicionvalorpadre]); if (padre.ListaRegistros.Count < padre.Minimo) { PrestarDeHermano(padre.Padre, padre); } } else if (hijo.ListaRegistros[hijo.ListaRegistros.Count - 1].CompareTo(padre.ListaRegistros[0]) < 0) //HIJO A LA IZQUIERDA DEL PADRE { hermano = padre.Hijos[posicionvalorpadre + 1]; for (int i = 0; i < hermano.ListaRegistros.Count; i++) { hijo.ListaRegistros.Add(hermano.ListaRegistros[i]); } if (TieneHijos(hijo) == true) { for (int i = 0; i < hermano.Hijos.Count; i++) { hijo.Hijos.Add(hermano.Hijos[i]); } } padre.Hijos.RemoveAt(posicionvalorpadre + 1); //Elimina el nodo hermano hijo.ListaRegistros.Add(padre.ListaRegistros[0]); //Manda valor de raiz hijo.ListaRegistros.Sort((x, y) => x.CompareTo(y)); padre.ListaRegistros.Remove(padre.ListaRegistros[0]); if (padre.ListaRegistros.Count < padre.Minimo && padre.Padre != null) { PrestarDeHermano(padre.Padre, padre); } } else if (hijo.ListaRegistros[0].CompareTo(padre.ListaRegistros[0]) > 0 && hijo.ListaRegistros[hijo.ListaRegistros.Count - 1].CompareTo(padre.ListaRegistros[padre.ListaRegistros.Count - 1]) < 0) //Si es uno de enmedio { if (hijo.ListaRegistros[0].CompareTo(padre.ListaRegistros[posicionvalorpadre]) > 0) { hermano = padre.Hijos[posicionvalorpadre]; for (int i = 0; i < hermano.ListaRegistros.Count; i++) { hijo.ListaRegistros.Add(hermano.ListaRegistros[i]); } if (TieneHijos(hijo) == true) { for (int i = 0; i < hermano.Hijos.Count; i++) { hijo.Hijos.Add(hermano.Hijos[i]); } } padre.Hijos.RemoveAt(posicionvalorpadre); //Elimina el nodo hermano hijo.ListaRegistros.Add(padre.ListaRegistros[padre.ListaRegistros.Count - 1]); //Manda valor de raiz hijo.ListaRegistros.Sort((x, y) => x.CompareTo(y)); } else { hermano = padre.Hijos[posicionvalorpadre + 1]; for (int i = 0; i < hermano.ListaRegistros.Count; i++) { hijo.ListaRegistros.Add(hermano.ListaRegistros[i]); } if (TieneHijos(hijo) == true) { for (int i = 0; i < hermano.Hijos.Count; i++) { hijo.Hijos.Add(hermano.Hijos[i]); } } padre.Hijos.RemoveAt(posicionvalorpadre + 1); //Elimina el nodo hermano hijo.ListaRegistros.Add(padre.ListaRegistros[posicionvalorpadre]); //Manda valor de raiz padre.ListaRegistros.RemoveAt(posicionvalorpadre); hijo.ListaRegistros.Sort((x, y) => x.CompareTo(y)); } } }
public void PrestarDeHermano(NodoArbolB <T> Padre, NodoArbolB <T> Nodo) { NodoArbolB <T> Hermano = new NodoArbolB <T>(); int PosicionPadre = 0; for (int i = 0; i < Padre.Hijos.Count; i++) { //Hermano derecho puede prestar if (Padre.Hijos[i] == Nodo && i == 0 && Padre.Hijos[i + 1].ListaRegistros.Count > Padre.Minimo) { Hermano = Padre.Hijos[i + 1]; PosicionPadre = i; break; } //Hermano izquierdo puede prestar else if (Padre.Hijos[i] == Nodo && i == (Padre.Hijos.Count - 1) && Padre.Hijos[i - 1].ListaRegistros.Count > Padre.Minimo) { Hermano = Padre.Hijos[i - 1]; PosicionPadre = i - 1; break; } //Nodo intermedio y presta del hermano izquierdo else if (Padre.Hijos[i] == Nodo && i > 0 && i <Padre.Hijos.Count - 1 && Padre.Hijos[i - 1].ListaRegistros.Count> Padre.Minimo) { Hermano = Padre.Hijos[i - 1]; PosicionPadre = i - 1; break; } //Nodo intermedio y presta del hermano derecho else if (Padre.Hijos[i] == Nodo && i > 0 && i <Padre.Hijos.Count - 1 && Padre.Hijos[i + 1].ListaRegistros.Count> Padre.Minimo) { Hermano = Padre.Hijos[i + 1]; PosicionPadre = i; break; } } if (Hermano.Padre == null)//Si ningun hermano puede prestar valor { for (int i = 0; i < Padre.Hijos.Count; i++) { //SI NO SE PUEDEN PRESTAR VALORES SOLO PASA LA POSICION DEL PADRE //Si el primer nodo tiene menor cantidad a Minimo if (Padre.Hijos[i] == Nodo && i == 0) { PosicionPadre = i; Hermano = Padre.Hijos[PosicionPadre + 1]; break; } //Si el ultimo nodo tiene menor cantidad a Minimo else if (Padre.Hijos[i] == Nodo && i == (Padre.Hijos.Count - 1)) { PosicionPadre = i - 1; Hermano = Padre.Hijos[PosicionPadre]; break; } //Si un nodo medio tiene menor cantidad a Minimo else if (Padre.Hijos[i] == Nodo && i > 0 && i < Padre.Hijos.Count - 1) { PosicionPadre = i; if (Padre.Hijos[PosicionPadre + 1].ListaRegistros.Count > Padre.Hijos[PosicionPadre - 1].ListaRegistros.Count) { Hermano = Padre.Hijos[PosicionPadre + 1]; } else if (Padre.Hijos[PosicionPadre + 1].ListaRegistros.Count < Padre.Hijos[PosicionPadre - 1].ListaRegistros.Count) { Hermano = Padre.Hijos[PosicionPadre - 1]; } else { Hermano = Padre.Hijos[PosicionPadre + 1]; } break; } } Unir(Padre, PosicionPadre, Nodo, Hermano); } //Encontro valor solo se mueve else { MoverValor(Hermano, PosicionPadre, Padre, Nodo); } }
public void ValorAgregadoOrdenado(T Valor, NodoArbolB <T> NodoAOrdenar) //Agrega valor en el nodo y ordena la lista de valores { NodoAOrdenar.ListaRegistros.Add(Valor); NodoAOrdenar.ListaRegistros.Sort((a, b) => a.CompareTo(b)); }
} // Lista de atributos public ArbolB() { Raiz = new NodoArbolB <T>(); Siguiente = 2; NombreVariables = new List <string>(); }
public void EnlacePadreHijo(NodoArbolB <T> Papa, NodoArbolB <T> Hijo) { Hijo.Padre = Papa; Papa.Hijos.Add(Hijo); }
public void DividirEnNodos(NodoArbolB <T> Nodo) { NodoArbolB <T> Izquierdo = new NodoArbolB <T>(); NodoArbolB <T> AuxiliarP = new NodoArbolB <T>(); NodoArbolB <T> Derecho = new NodoArbolB <T>(); CrearNodo(Izquierdo, Nodo); CrearNodo(Derecho, Izquierdo); for (int i = 0; i < Nodo.Minimo; i++) { Izquierdo.ListaRegistros.Add(Nodo.ListaRegistros[i]); } for (int i = Nodo.Minimo + 1; i <= Nodo.Maximo; i++) { Derecho.ListaRegistros.Add(Nodo.ListaRegistros[i]); } if (Nodo.Padre != null) //Si es cualquier hijo { EnlacePadreHijo(Nodo.Padre, Izquierdo); EnlacePadreHijo(Nodo.Padre, Derecho); Nodo.Padre.ListaRegistros.Add(Nodo.ListaRegistros[Nodo.Minimo]); Nodo.Padre.ListaRegistros.Sort((x, y) => x.CompareTo(y)); int indice = 0; for (int i = 0; i < Nodo.Padre.Hijos.Count; i++) { if (Nodo.Padre.Hijos[i].ListaRegistros.Count > 4) { indice = i; break; } } if (Nodo.Hijos.Count > 0) { HijosHijo(Nodo, Izquierdo, 0, Nodo.Minimo); HijosHijo(Nodo, Derecho, Nodo.Minimo + 1, Nodo.Maximo + 1); } Nodo.Padre.Hijos.RemoveAt(indice); Nodo.Padre.Hijos.Sort((x, y) => x.CompareTo(y)); Nodo = null; }//Si es la raiz y aun caben valores en el nodo else if (Nodo.Padre == null && Nodo.Hijos.Count < 5) { AuxiliarP.ListaRegistros.Add(Nodo.ListaRegistros[Nodo.Minimo]); EnlacePadreHijo(Nodo, Izquierdo); EnlacePadreHijo(Nodo, Derecho); Nodo.ListaRegistros.Sort((x, y) => x.CompareTo(y)); Nodo.ListaRegistros = AuxiliarP.ListaRegistros; }//Si es raiz y no caben valores else if (Nodo.Padre == null && Nodo.Hijos.Count >= 5) { T val = Nodo.ListaRegistros[Nodo.Minimo]; HijosHijo(Nodo, Izquierdo, 0, Nodo.Minimo); HijosHijo(Nodo, Derecho, Nodo.Minimo + 1, Nodo.Maximo + 1); Nodo.Hijos.Clear(); EnlacePadreHijo(Nodo, Izquierdo); EnlacePadreHijo(Nodo, Derecho); Nodo.ListaRegistros.Clear(); Nodo.ListaRegistros.Add(val); } }
public void ObtenerGrado(NodoArbolB <T> Tmp, int Grado) { Tmp.Minimo = (Grado - 1) / 2; Tmp.Maximo = Grado - 1; }