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], ");
}
}
}
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();
}
}
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 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);
}
private List <ArbolGeneral <Carta> > _consultaC(int nivel)
{
if (jugadaActual.esHoja())
{
camino.Add(jugadaActual);
}
else
{
Cola <ArbolGeneral <Carta> > c = new Cola <ArbolGeneral <Carta> >(); // Instanciamos cola
ArbolGeneral <Carta> arbolAux;
int contNivel = 0;
c.encolar(jugadaActual); // se encola el arbol
c.encolar(null); // se encola el separador
while (!c.esVacia())
{
arbolAux = c.desencolar();
if (arbolAux != null)
{
if (nivel == contNivel) // Si la profundidad elegida es igual a la profundidad recorrida
{
if ((contNivel % 2) == 0) // Si es par, se procesan las cartas de la IA
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.Write("(" + arbolAux.getDatoRaiz().getCarta() + ", " + arbolAux.getDatoRaiz().getFuncHeursitica() + ")");
Console.ResetColor();
}
else // Si no del humano
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("(" + arbolAux.getDatoRaiz().getCarta() + ", " + arbolAux.getDatoRaiz().getFuncHeursitica() + ")");
Console.ResetColor();
}
}
// Se encolan los hijos (si tiene)
foreach (ArbolGeneral <Carta> hijo in arbolAux.getHijos())
{
c.encolar(hijo);
}
}
// Si desencolamos null (separador):
else
{
contNivel++; // se incrementa el contador de nivel.
if (!c.esVacia()) // Si la cola no se vacio,
{
c.encolar(null); // se encola null (separador)
}
}
}
}
return(camino);
}
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....");
}
}
public void consultaNiveles()
{
Cola <NodoGeneral <T> > cola = new Cola <NodoGeneral <T> >();
cola.encolar(this.getRaiz);
while (!cola.esVacia())
{
cola.desencolar();
Console.WriteLine(" " + raiz.getDato);
List <NodoGeneral <T> > nodos = raiz.getHijos();
foreach (NodoGeneral <T> nodo in nodos)
{
cola.encolar(nodo);
}
}
}
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();
}
}
}
public int ancho()
{
Cola <ArbolGeneral <T> > c = new Cola <ArbolGeneral <T> >();
ArbolGeneral <T> arbolAux;
int contArboles = 0, anchoMax = 0;
c.encolar(this);
c.encolar(null);
anchoMax = 1;
while (!c.esVacia())
{
arbolAux = c.desencolar();
if (arbolAux == null)
{
if (!c.esVacia())
{
c.encolar(null);
}
if (contArboles > anchoMax)
{
anchoMax = contArboles;
}
contArboles = 0;
}
else
{
// Incrementamos el contador de arboles por nivel
contArboles++;
// Encolamos hijos
if (!this.esHoja())
{
foreach (var hijo in arbolAux.getHijos())
{
c.encolar(hijo);
}
}
}
}
return(anchoMax);
}
public void profundidad(int n, int profundidad)
{
//Este metodo permite realizar la consulta de los datos de los nodos que se encuentran entre dos niveles
//si los parametros n=profundidad obtenemos los datos que se encuentran en un determinado nivel. Si los
//decrementamos el nivel en uno obtenemos los datos en una determinada profundidad
var cola = new Cola <NodoGeneral <T> >();
cola.encolar(this.getRaiz());
cola.encolar(null); //Encola null para marcar la finalizacion un nivel.
int nivel = 1; //Cuando finaliza un nivel y comienza uno nuevo la variable nivel incrementa en 1.
string datos = "";
while (!cola.esVacia())
{
NodoGeneral <T> aux = cola.desencolar();
if (aux == null)
{
cola.encolar(null);
nivel++;
if (cola.tope() == aux) //Esta estructura condicional permite evitar un bucle infinito, ya que cuando desencolo un null encolo otro para finalizar un nivel
{ //Cuando consultamos con el metodo tope no estamos desencolando sino preguntando si el siguiente dato a desencolar sera nulo o no. Si
cola.desencolar(); //este dato siguiente es nulo lo desencolo y no encolo nada. De esta forma evito que se encolen nulls infinitos.
}
}
else
{
if (nivel >= n && nivel <= profundidad) //Si el nivel coincide con la profundidad, es decir nivel=n=profundidad agrega a mi variable "datos" el dato del nodo que
{ //se encuentra en dicha profundidad.
Console.Write("[" + aux.getDato() + "]"); //Esta impresion elabora una candena con los datos de los nodos que se encuentran en la misma profundidad
datos = datos + aux.getDato();
}
if (!this.esHoja())
{
foreach (var hijo in aux.getHijos())
{
cola.encolar(hijo);
}
}
}
}
}
public void porNiveles()
{
Cola <ArbolGeneral <T> > c = new Cola <ArbolGeneral <T> >();
ArbolGeneral <T> arbolAux;
c.encolar(this);
while (!c.esVacia())
{
arbolAux = c.desencolar();
Console.Write(arbolAux.getDatoRaiz() + " ");
if (!this.esHoja())
{
foreach (var hijo in arbolAux.getHijos())
{
c.encolar(hijo);
}
}
}
}
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========================================================================================================================");
}
public void porNiveles()
{
Cola <ArbolGeneral <DatosJugada> > c = new Cola <ArbolGeneral <DatosJugada> >();
ArbolGeneral <DatosJugada> arbolAux;
int contador = 0;
c.encolar(minimax);
c.encolar(null);
while (!c.esVacia())
{
arbolAux = c.desencolar();
if (arbolAux != null)
{
Console.Write(arbolAux.getDatoRaiz().carta + " "); //Modificado para mostrrar niveles. B V
Console.Write("[" + arbolAux.getDatoRaiz().limiteActual + "]" + " ");
}
if (arbolAux == null)
{
if (!c.esVacia())
{
contador++;
Console.WriteLine();
Console.WriteLine("*****Nivel ******");
c.encolar(null);
}
}
else
{
if (!minimax.esHoja())
{
foreach (var hijo in arbolAux.getHijos())
{
c.encolar(hijo);
}
}
}
}
}
public ArbolGeneral <T> CortarArbol(int UltimaCartaUsuario)
{
Cola <ArbolGeneral <T> > c = new Cola <ArbolGeneral <T> >();
ArbolGeneral <T> arbolAux = new ArbolGeneral <T>(null);
c.encolar(this);
while (!c.esVacia())
{
arbolAux = c.desencolar();
if (Convert.ToInt32(arbolAux.getDatoRaiz()) == UltimaCartaUsuario)
{
return(arbolAux);
}
if (!this.esHoja())
{
foreach (var hijo in arbolAux.getHijos())
{
c.encolar(hijo);
}
}
}
return(arbolAux);
}
