Exemplo n.º 1
0
        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);
            }
        }
Exemplo n.º 2
0
        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));
            }
        }
Exemplo n.º 3
0
 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);
     }
 }
Exemplo n.º 4
0
        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);
            }
        }
Exemplo n.º 5
0
 public void CrearNodo(NodoArbolB <T> nuevo, NodoArbolB <T> nodo)
 {
     nuevo.Maximo = nodo.Maximo;
     nuevo.Minimo = nodo.Minimo;
     nuevo.ID     = Siguiente;
     Siguiente++;
 }
Exemplo n.º 6
0
 public bool TieneEspacio(NodoArbolB <T> Nodo)
 {
     if (Nodo.ListaRegistros.Count <= Nodo.Maximo)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Exemplo n.º 7
0
 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;
     }
 }
Exemplo n.º 8
0
 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);
     }
 }
Exemplo n.º 9
0
 public bool TieneHijos(NodoArbolB <T> Nodo)
 {
     if (Nodo.Hijos.Count == 0)
     {
         return(false);
     }
     else
     {
         return(true);
     }
 }
Exemplo n.º 10
0
        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);
            }
        }
Exemplo n.º 11
0
 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);
     }
 }
Exemplo n.º 12
0
        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));
                }
            }
        }
Exemplo n.º 13
0
        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);
            }
        }
Exemplo n.º 14
0
 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));
 }
Exemplo n.º 15
0
 }                                                 // Lista de atributos
 public ArbolB()
 {
     Raiz            = new NodoArbolB <T>();
     Siguiente       = 2;
     NombreVariables = new List <string>();
 }
Exemplo n.º 16
0
 public void EnlacePadreHijo(NodoArbolB <T> Papa, NodoArbolB <T> Hijo)
 {
     Hijo.Padre = Papa;
     Papa.Hijos.Add(Hijo);
 }
Exemplo n.º 17
0
        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);
            }
        }
Exemplo n.º 18
0
 public void ObtenerGrado(NodoArbolB <T> Tmp, int Grado)
 {
     Tmp.Minimo = (Grado - 1) / 2;   Tmp.Maximo = Grado - 1;
 }