Exemplo n.º 1
0
        private void ConsultaC()
        {
            ArbolGeneral <DatosJugada> minimaxAux = new ArbolGeneral <DatosJugada>(null);

            minimaxAux = computer.getMinimax();
            Console.WriteLine();
            Console.WriteLine("Indique una profundidad");
            string rta = Console.ReadLine();
            bool   aux = false;

            while (aux == false)                        //Se comprueba que haya ingresado un valor coherente
            {
                try
                {
                    Int32.Parse(rta);
                    aux = true;             //Si puede parsear el valor sale del while e imprime en dicha profundidad
                }
                catch (Exception)
                {
                    Console.WriteLine("El valor no es correcto. Intente de nuevo");
                    rta = Console.ReadLine();
                }
            }
            Console.WriteLine("Se mostraran las cartas en el nivel " + rta + ". Oprima cualquier tecla para continuar");
            Console.ReadKey();
            computer.imprimirNivel(Int32.Parse(rta), minimaxAux);
        }
Exemplo n.º 2
0
 public void recoridoPorNiveles(Cola <ArbolGeneral <int> > cola, Cola <ArbolGeneral <int> > colaRepe, int nivel)
 {
     if (cola.esVacia() == true)
     {
         Console.WriteLine("Se termino");
     }
     if (cola.esVacia() == false)
     {
         while (cola.esVacia() == false)
         {
             ArbolGeneral <int> arboli = cola.desencolar();
             Console.Write(arboli.getDatoRaiz() + ", ");
             colaRepe.encolar(arboli);
         }
         while (colaRepe.esVacia() == false)
         {
             ArbolGeneral <int> arbolito = colaRepe.desencolar();
             foreach (ArbolGeneral <int> hijos in arbolito.getHijos())
             {
                 cola.encolar(hijos);
             }
         }
         if (nivel % 2 == 1)
         {
             Console.WriteLine("Usuario");
         }
         if (nivel % 2 == 0)
         {
             Console.WriteLine("Computer");
         }
         nivel++;
         recoridoPorNiveles(cola, colaRepe, nivel);
     }
 }
 public ArbolGeneral <int> InstalacionHeuristica(ArbolGeneral <int> ArbolMiniMax, bool Turno, int limite)
 {
     //Si mi funcion Heuristica, es decir si la base de mi ABGeneral tiene "getDatoRaiz=-1" gana Usuario
     //si tiene "getDatoRaiz=-2" gana Maquina...
     if (limite < 0)
     {
         //En el nodo de mi arbol que se sobrepase el limite se corta y se debe poner como hijo de este el dato heuristico (-1 gano maquina,-2 gano usuario)
         //dependiendo de quien sea el turno.
         if (Turno == true)
         {
             ArbolMiniMax.ConvertirEnHoja();                     //El nodo en el que se alcanza el limite se convierte en Hoja y en este se agrega el dato heuristico
             ArbolGeneral <int> Heuristic = new ArbolGeneral <int>(-1);
             ArbolMiniMax.agregarHijo(Heuristic);
         }
         else
         {
             ArbolMiniMax.ConvertirEnHoja();
             ArbolGeneral <int> Heuristic = new ArbolGeneral <int>(-2);
             ArbolMiniMax.agregarHijo(Heuristic);
         }
     }
     //Mientras no se supere el limite recorro los hijos de mi nodo
     else
     {
         foreach (var hijo in ArbolMiniMax.getHijos())
         {
             int LimiteAux = limite - hijo.getDatoRaiz();
             InstalacionHeuristica(hijo, !Turno, LimiteAux);
         }
     }
     return(ArbolMiniMax);
 }
Exemplo n.º 4
0
        public void ImprimirHojas(ArbolGeneral <DatosJugada> arbol)
        {
            Cola <ArbolGeneral <DatosJugada> > c = new Cola <ArbolGeneral <DatosJugada> >();
            ArbolGeneral <DatosJugada>         aux;

            c.encolar(arbol);  //encola minimax
            while (!c.esVacia())
            {
                aux = c.desencolar();
                if (!aux.esHoja())
                {
                    foreach (var nodo in aux.getHijos())
                    {
                        c.encolar(nodo);
                    }
                }
                if (aux.esHoja() && aux.getDatoRaiz().valorDeConveniencia == 1)
                {
                    Console.Write("|(" + aux.getDatoRaiz().carta + ")[Pierde]|, ");
                }
                if (aux.esHoja() && aux.getDatoRaiz().valorDeConveniencia == -1)
                {
                    Console.Write("|(" + aux.getDatoRaiz().carta + ")[Gana], ");
                }
            }
        }
Exemplo n.º 5
0
        public override int descartarUnaCarta()
        {
            int cartaJugada = 0;

            //la primera vez referencia es null(recien arranca el arbol minimax)
            foreach (ArbolGeneral <DatosJugada> cartas in referencia.getHijos())         //itera el nivel de cartas del humano (cuando referencia es el nivel de cartas de cumputer,
                                                                                         //referencia.getHijos sera de nuevo un nivel de cartas del humano)
            {
                if (cartas.getDatoRaiz().carta == UltimaCartaHumano)                     //busca la arbol que tenga como dato la carta que tiro el humano y se poseciona ahí
                {
                    referencia = cartas;                                                 //Nos ubicamos en los hijos del arbol correspondiente a la carta que tiro el humano
                    foreach (ArbolGeneral <DatosJugada> cartatirar in cartas.getHijos()) //itera el nivel de cartas de computer que corresponde al arbol de la carta que tiro el humano.
                    {
                        if (cartatirar.getDatoRaiz().valorDeConveniencia == 1)
                        {
                            referencia  = cartatirar;           //deja ubicado el arbol en el nivel de computer
                            cartaJugada = cartatirar.getDatoRaiz().carta;

                            return(cartaJugada);
                        }
                        else
                        {
                            //Si no encuentra con valor 1 tirara la primera que encuentre
                        }
                        {
                            referencia  = cartatirar;  //deja ubicado el arbol en el nivel de computer
                            cartaJugada = cartatirar.getDatoRaiz().carta;
                        }
                    }
                }
            }
            //referencia.porNiveles();

            return(cartaJugada);
        }
        public ArbolGeneral <int> CompletarRama(ArbolGeneral <int> Hijo, List <int> CartasUsuario, List <int> CartasMaquina, bool Turno, int limite)
        {
            //Empieza Jugando Usuario->Turno=true(Juega Usuario)->Turno=false(Juega Maquina)
            List <int> cartas = new List <int>();

            if (Turno == true)
            {
                cartas.AddRange(CartasUsuario);                 //Si Juega Usuario guardo todas las cartas de este en la variable "cartas"
            }
            else
            {
                cartas.AddRange(CartasMaquina);                          //Si Juega Maquina guardo todas las cartas de este en la variable "cartas"
            }
            foreach (int carta in cartas)                                //Recorre la lista de cartas Correspondiente al Jugador
            {
                ArbolGeneral <int> hijo = new ArbolGeneral <int>(carta); //Realiza una instancia de ArbolGeneral con DatoRaiz carta
                Hijo.agregarHijo(hijo);                                  //Agrega al Arbol la instancia hijo creada anteriormente
                int        limiteaAux      = limite - carta;             //Decrementa el limite en base a el dato de la carta
                List <int> cartasrestantes = new List <int>();
                cartasrestantes.AddRange(cartas);                        //Guardo todas las cartas en lista cartas restantes
                cartasrestantes.Remove(carta);                           // y elimino la carta que se esta recorriendo de la lista "cartas".
                if (limite >= 0)                                         //Si limite es menor a cero empieza a armar la siguiente rama
                {
                    if (Turno == true)
                    {
                        CompletarRama(hijo, cartasrestantes, CartasMaquina, !Turno, limiteaAux);                 //Hace llamada recursiva cambia el turno, envia la lista con
                    }                                                                                            //la carta eliminada y el limite reducido
                    else
                    {
                        CompletarRama(hijo, CartasUsuario, cartasrestantes, !Turno, limiteaAux);
                    }
                }
            }
            return(Hijo);
        }
Exemplo n.º 7
0
        public void PorNiveles()
        {
            Cola <ArbolGeneral <T> > cola = new Cola <ArbolGeneral <T> >();

            cola.encolar(this);
            while (!cola.esVacia())
            {
                int n = cola.cantidad();

                while (n > 0)
                {
                    ArbolGeneral <T> p = cola.tope();

                    cola.desencolar();

                    Console.Write(p.getDatoRaiz() + " ");

                    foreach (var v in p.getHijos())
                    {
                        cola.encolar(v);
                    }

                    n--;
                }


                Console.WriteLine();
                Console.WriteLine();
            }
        }
Exemplo n.º 8
0
        public void generarArbol(ArbolGeneral <Jugada> nodoCarta, List <int> cartasPropias, List <int> cartasOponente, int limite)
        {
            List <int> cartasPropiasSinJugar = new List <int>(cartasPropias);

            cartasPropiasSinJugar.Remove(nodoCarta.getDatoRaiz().carta);
            int limiteActualizado = nodoCarta.getDatoRaiz().limiteActual - nodoCarta.getDatoRaiz().carta;

            if (limiteActualizado < 0)
            {
                if (nodoCarta.getDatoRaiz().miAI)
                {
                    nodoCarta.getDatoRaiz().ganadas = -1;
                }
                else
                {
                    nodoCarta.getDatoRaiz().ganadas = 1;
                }
            }
            else
            {
                foreach (int cartaOponente in cartasOponente)
                {
                    Jugada movimientoOponente = new Jugada(cartaOponente, limiteActualizado, 0, nodoCarta.getDatoRaiz().miAI);
                    ArbolGeneral <Jugada> nodoCartaOponente = new ArbolGeneral <Jugada>(movimientoOponente);
                    generarArbol(nodoCartaOponente, cartasOponente, cartasPropiasSinJugar, limiteActualizado);
                    nodoCarta.agregarHijo(nodoCartaOponente);
                    nodoCarta.getDatoRaiz().ganadas += nodoCartaOponente.getDatoRaiz().ganadas;
                }
            }
        }
Exemplo n.º 9
0
        public void encolarParaRecorrer(ArbolGeneral <int> arbol)
        {
            Cola <ArbolGeneral <int> > cola      = new Cola <ArbolGeneral <int> >();
            Cola <ArbolGeneral <int> > colaVacia = new Cola <ArbolGeneral <int> >();

            cola.encolar(arbol);
            recoridoPorNiveles(cola, colaVacia, 0);
        }
        //Método inicializar crea árbol general con todos los estados posibles
        public override void  incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
        {
            this.raiz   = new ArbolGeneral <int>(0);
            this.estado = raiz;
            bool turnoH = true;

            _inicializar(cartasPropias, cartasOponente, limite, turnoH, this.raiz);
        }
        //Funcion para armar el arbol MiniMax, a partir del estadoInicial

        private ArbolGeneral <Dupla> ArmarArbolMinimax(Estatus estado)
        {
            ArbolGeneral <Dupla> nuevo = new ArbolGeneral <Dupla>(new Dupla(0, 0));

            ArmarArbolMinimaxAux(estado, nuevo);

            return(nuevo);
        }
Exemplo n.º 12
0
        public override void  incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
        {
            bool turnoHumano = true;

            estado = new Estado(cartasPropias, cartasOponente, limite, turnoHumano);
            createArbol(estado, miniMax);
            jugadaActual = miniMax;
            consulta.setJugadaActual(jugadaActual);
        }
Exemplo n.º 13
0
        public override void  incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
        {
            Jugada comienzo = new Jugada(-1, limite, 0, true);

            arbol = new ArbolGeneral <Jugada>(comienzo);

            generarArbol(this.arbol, cartasPropias, cartasOponente, limite);
            Console.WriteLine(this.arbol.getHijos().Count);
        }
 private void setEstado(int carta)
 {
     foreach (var nodo in estado.getHijos())
     {
         if (nodo.getDatoRaiz() == carta)
         {
             estado = nodo;
         }
     }
 }
 public override void cartaDelOponente(int carta)
 {
     foreach (var nodo in this.estado.getHijos())
     {
         if (nodo.getDatoRaiz() == carta)
         {
             this.estado = nodo;
         }
     }
 }
Exemplo n.º 16
0
        public void imprimirNivel(int nivel, ArbolGeneral <DatosJugada> arbol)
        {
            Cola <ArbolGeneral <DatosJugada> > c = new Cola <ArbolGeneral <DatosJugada> >();
            //ArbolGeneral<DatosJugada> aux;

            int  contador        = 0;
            bool NivelEncontrado = false;

            c.encolar(referencia);
            c.encolar(null);
            while (!c.esVacia())
            {
                arbol = c.desencolar();
                if (arbol != null)

                {
                    if (contador == nivel)
                    {
                        NivelEncontrado = true;
                        if (arbol.getDatoRaiz().valorDeConveniencia == 1)
                        {
                            Console.Write(arbol.getDatoRaiz().carta + " " + "[Pierde], ");
                        }
                        if (arbol.getDatoRaiz().valorDeConveniencia == -1)
                        {
                            Console.Write(arbol.getDatoRaiz().carta + " " + "[Gana], ");
                        }
                    }
                }
                if (arbol == null)
                {
                    if (!c.esVacia())
                    {
                        c.encolar(null);
                    }
                    contador++;
                }
                else
                {
                    if (!referencia.esHoja())
                    {
                        foreach (var hijo in arbol.getHijos())
                        {
                            c.encolar(hijo);
                        }
                    }
                }
            }
            if (NivelEncontrado == false)
            {
                Console.WriteLine("No se encontro la profunidad. Regresando al juego....");
            }
        }
Exemplo n.º 17
0
        public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
        {
            DatosJugada datosJugada = new DatosJugada(0, limite, true);

            minimax = new ArbolGeneral <DatosJugada>(datosJugada);
            bool turno = true; //esta variable se debe declarar como atributo de clase

            naipes = cartasPropias;

            crearArbol(cartasPropias, cartasOponente, limite, turno, minimax);
            Console.WriteLine(minimax.getHijos().Count);
        }
        public override void cartaDelOponente(int carta)
        {
            //lo que hay que hacer es elegir al hijo que corresponde a esa carta

            //implementar

            foreach (ArbolGeneral <DatosJugadas> hijo in this.arbol.getHijos())
            {
                if (hijo.getDatoRaiz().Carta == carta)
                {
                    this.arbol = hijo;
                    return;
                }
            }
        }
Exemplo n.º 19
0
        public override void cartaDelOponente(int carta)
        {
            ArbolGeneral <int> mejor = new ArbolGeneral <int>(0);


            foreach (ArbolGeneral <int> NuevaRaiz in arbol.getHijos())
            {
                if (NuevaRaiz.getDatoRaiz() == carta)
                {
                    arbol.setRaiz(NuevaRaiz.Raiz);
                }
            }

            limite = limite - carta;
        }
Exemplo n.º 20
0
        public override void cartaDelOponente(int cartaH)
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.Write("\nEl humano ha descartado la carta: " + cartaH.ToString() + "\n");
            Console.ResetColor();

            foreach (ArbolGeneral <Carta> hijo in jugadaActual.getHijos())
            {
                if (hijo.getDatoRaiz().getCarta() == cartaH)
                {
                    jugadaActual = hijo; // jugada actual apunta a la carta que tiro el humano
                    break;
                }
            }
            consulta.setJugadaActual(jugadaActual);
        }
Exemplo n.º 21
0
        public void recorridoEntreNiveles(int a, int b)
        {
            if (esVacio())
            {
                return;
            }

            Cola <ArbolGeneral <T> > cola = new Cola <ArbolGeneral <T> >();

            cola.encolar(this);
            int nivel = 0;

            while (!cola.esVacia())
            {
                nivel++;

                int n = cola.cantidad();

                while (n > 0)
                {
                    ArbolGeneral <T> p = cola.tope();

                    cola.desencolar();

                    if (nivel >= a && nivel <= b)
                    {
                        Console.Write(p.getDatoRaiz() + " ");
                    }


                    if (!p.esVacio())
                    {
                        foreach (var v in p.getHijos())
                        {
                            cola.encolar(v);
                        }
                    }

                    n--;
                }

                if (nivel >= a && nivel <= b)
                {
                    Console.WriteLine();
                }
            }
        }
Exemplo n.º 22
0
        public override int descartarUnaCarta()
        {
            int mejoropcion = -1;
            ArbolGeneral <int> nueopcion = null;

            foreach (ArbolGeneral <int> opciones in arbol.getHijos())
            {
                if (opciones.Raiz.Datpri > mejoropcion)
                {
                    nueopcion   = opciones;
                    mejoropcion = opciones.Raiz.Datpri;
                }
            }
            arbol.setRaiz(nueopcion.Raiz);
            Console.WriteLine("La maquina escogio la carta " + nueopcion.getDatoRaiz());
            return(nueopcion.getDatoRaiz());
        }
        public override int descartarUnaCarta()
        {
            Console.Write("Naipes disponibles (Maquina):");
            for (int i = 0; i < naipesComputer.Count; i++)
            {
                Console.Write("[" + naipesComputer[i].ToString() + "]");              //Muestra las cartas que tiene disponible la Maquina
            }
            Console.WriteLine();
            ArbolGeneral <int> NuevoArbol = ArbolEuristico.CortarArbol(UltimaCartaUsuario);          //Corta el arbol en la ultima jugada que realizo el Usuario

            ArbolEuristico = NuevoArbol;
            List <int> SiguienteJugada = NuevoArbol.BuscarJugada(new List <int>());               //En el arbol cortado busca el camino que tenga como dato Heuristico -2

            //y lo guarda en la lista SiguienteJugada
            Console.WriteLine("Carta de La Maquina:         " + "[" + SiguienteJugada[1] + "]");
            //Devuelve la carta a jugar. Esta seria la carta que se ecuentra en la
            return(SiguienteJugada[1]);;                                                      //posicion 1 de mi lista que guardo el camino que tiene el dato Heuristico -2.
        }
Exemplo n.º 24
0
        private int _descartarUnaCarta(ArbolGeneral <Carta> raiz)
        {
            // Con el siguiente algoritmo se guardan las cartas donde la IA tiene una jugada aseguarada para ganar el juego.

            Random random = new Random();
            List <ArbolGeneral <Carta> > opciones = new List <ArbolGeneral <Carta> >(); // Lista que almacena todas las posibilidades de victoria.
            int i = 0;

            // Se crea la lista de opciones de cartas donde la IA tiene asegurada una victoria.
            foreach (var hijo in raiz.getHijos())
            {
                if (hijo.getDatoRaiz().getFuncHeursitica() == 1) // Si tiene un hijo con FH +1, entonces se lo agrega a la lista de opciones.
                {
                    opciones.Add(hijo);
                }
            }

            if (opciones.Count == 0) // Si la IA no tiene una jugada asegurada de victoria, entonces tira la última carta.
            {
                foreach (var hijo in raiz.getHijos())
                {
                    if (hijo.getDatoRaiz().getFuncHeursitica() == -1)
                    {
                        jugadaActual = hijo;
                    }
                }
            }
            else // Si la IA tiene opciones aseguradas para ganar.
            {
                int opcion = random.Next(1, opciones.Count); // Se crea un valor random entre 1 y la cantidad de opciones que haya.
                foreach (var o in opciones) // Se recorren todas las opciones.
                {
                    i++;                    // Se incrementa el contador a medida que se recorren las opciones.

                    if (i == opcion)        // Si el contador es igual a el número de opción aleatoria.
                    {
                        jugadaActual = o;   // Entonces, jugadaActual apunta a esa opción.
                        break;
                    }
                }
            }
            return(jugadaActual.getDatoRaiz().getCarta()); // Se retorna la carta elegida.
        }
        public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
        {
            bool       Turno   = true;   //comienza tirando el usuario!
            List <int> usuario = new List <int>()
            {
                1, 2, 3
            };
            List <int> maquina = new List <int>()
            {
                4, 5, 6
            };

            naipesComputer = maquina;
            ArbolGeneral <int> ArbolCompleto = CompletarRama(new ArbolGeneral <int>(0), usuario, maquina, Turno, limite);
            ArbolGeneral <int> Arbol         = InstalacionHeuristica(ArbolCompleto, Turno, 7);

            ArbolEuristico = Arbol;            //Guarda el Arbol Heuristico en el Campo de la clase base llamado "ArbolEuristico" para que todas las
                                               //clases que hereden de esta clase base tambien tengan disponible este dato.
        }
Exemplo n.º 26
0
        public override int descartarUnaCarta()
        {
            int mejoropcion = -1;
            ArbolGeneral <int> nueopcion = null;

            foreach (ArbolGeneral <int> opciones in arbolMiniMax.getHijos())
            {
                if (opciones.Raiz.cuantasVecesPerdio > mejoropcion)
                {
                    nueopcion   = opciones;
                    mejoropcion = opciones.Raiz.CuantasVecesPerdio;
                }
            }
            arbolMiniMax.Raiz = nueopcion.Raiz;
            Console.WriteLine("La maquina escogio la carta " + nueopcion.getDatoRaiz());
            return(nueopcion.getDatoRaiz());

            encolarParaRecorrer(arbolMiniMax);
        }
        private ArbolGeneral <Carta> _consultaB(ArbolGeneral <Carta> jugadaActual)
        {
            Console.Write("Ingrese una secuencia de cartas separadas por comas: ");
            string numeros = Console.ReadLine();

            string[]             cartas = numeros.Split(',');                    // se Splitea las cartas que haya escrito el usuario en la secuencia
            ArbolGeneral <Carta> aux    = jugadaActual;                          // aux apunta a la jugada actual

            foreach (string carta in cartas)                                     // se recorre carta de la secuencia
            {
                foreach (ArbolGeneral <Carta> hijo in aux.getHijos())            //se reccoren los hijos del arbol aux
                {
                    if (hijo.getDatoRaiz().getCarta() == Convert.ToInt32(carta)) // si existe
                    {
                        aux = hijo;                                              // Aux apunta a la carta actual
                        break;
                    }
                }
            }
            return(aux);
        }
        private List <ArbolGeneral <Carta> > _consultaA(ArbolGeneral <Carta> jugadaActual)
        {
            camino.Add(jugadaActual);

            if (jugadaActual.esHoja()) // Si se encuentra un nodo hoja, se lo agrega y se agrega un separador.
            {
                // camino.Add(new ArbolGeneral<Carta>(new Carta(0, 0)));
                imprimir(camino);
                Console.WriteLine();
            }
            else
            {
                foreach (ArbolGeneral <Carta> hijo in jugadaActual.getHijos())
                {
                    _consultaA(hijo);
                    camino.Remove(hijo);
                }
            }

            return(camino);
        }
Exemplo n.º 29
0
        public void recorreHijos(ArbolGeneral <int> arbol)
        {
//			foreach (ArbolGeneral<int> hijos in arbol.getHijos())
//			{
//				if(hijos.esHoja()==true)
//				{
//					if(hijos.Raiz.PerdioUsuario==1)
//					{
//						return 1;
//					}
//					else
//					{
//						return 0;
//					}
//				}
//				else
//				{
//				return recorreHijos(hijos);
//				}
//			}
        }
Exemplo n.º 30
0
        public void PorNivelesMarcadoFin()
        {
            Cola <ArbolGeneral <T> > cola = new Cola <ArbolGeneral <T> >();        //Intancia una cola vacia

            cola.encolar(this);                                                    //Obtiene el Nodo Raiz y lo encola
            cola.encolar(null);                                                    //Encola null (para determinar cuando empieza el nuevo nivel)
            int nivel = 1;

            Console.WriteLine("=======================================================================================================================");
            Console.Write("[Nivel-" + nivel + "]: ");
            while (cola.esVacia() != true)
            {
                ArbolGeneral <T> NodoDesencolado = cola.desencolar();                  //Quita de la cola el dato(cola[0]) y lo almacena en la variable
                if (NodoDesencolado == null)
                {
                    cola.encolar(null);                                                   //Si el dato es NULL, encola NULL para señalar el comienzo de un nuevo nivel
                    if (cola.tope() == NodoDesencolado)
                    {
                        cola.desencolar();                                                    //Si el dato en la cola, anterior a el dato NodoDesencolado, es tambien NULL se desencola
                        //pero no se almacena en ninguna variable temporal.
                    }
                    else
                    {
                        nivel++;                                                              //Si el dato no es NULL, es nodo, nivel incrementa y se comienza a imprimir el nuevo nivel
                        Console.Write("\n========================================================================================================================");
                        Console.Write("[Nivel-" + nivel + "]: ");
                    }
                }
                else                                                                  //Si el dato desencolado es un NODO se encola e imprimen los hijos de este
                {
                    foreach (var Nodo in NodoDesencolado.getHijos())
                    {
                        cola.encolar(Nodo);
                    }
                    Console.Write("[" + NodoDesencolado.getDatoRaiz() + "]");
                }
            }
            Console.Write("\n========================================================================================================================");
        }