static void Main(string[] args)
{
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
// Keep the console window open in debug mode.
Console.WriteLine("Indique el número de discos que va a utilizar: ");
string key = Console.ReadLine();
int cuantos = 0;
while (!Int32.TryParse(key, out cuantos) || Int32.Parse(key) < 0)
{
Console.WriteLine("Inténtelo de nuevo");
key = Console.ReadLine();
}
for (int i = cuantos; i > 0; i--)
{
Disco disco = new Disco();
disco.Valor = i;
ini.push(disco);
}
int pasos = Hanoi.iterativo(cuantos, ini, fin, aux);
int pasosRecursivo = Hanoi.recursivo(cuantos, ini, aux, fin);
Console.WriteLine("-----------------------------------");
Console.WriteLine("Pasos realizados con iterativo: " + pasos);
Console.WriteLine("Pasos realizados con recursivo: " + pasosRecursivo);
Console.WriteLine("Pasos mínimos: " + (Math.Pow(2, cuantos) - 1));
Console.WriteLine("-----------------------------------");
}
public Disco pop()
{
Disco extraido = null;
if (Size == 0)
{
Top = 0;
}
else
{
extraido = Elementos[Size - 1];
Elementos.RemoveAt(Size - 1);
if (Size == 0)
{
Top = 0;
}
else
{
Top = Elementos[Size - 1].Valor;
}
}
return(extraido);
}
public int Push(Disco disco)
{
if (!EstaLleno())
{
if (!EstaVacio())
{
if (pila[contador - 1].GetTamanio() > disco.GetTamanio())
{
pila[contador] = disco;
this.Parent.Controls.Add(disco);
disco.Location = new System.Drawing.Point(this.Location.X - (disco.Width / 2) + (this.Width / 2), 225 - (20 * (contador + 1)));
disco.BringToFront();
disco.Refresh();
contador++;
return(0);
}
}
else
{
pila[contador] = disco;
this.Parent.Controls.Add(disco);
disco.Location = new System.Drawing.Point(this.Location.X - (disco.Width / 2) + (this.Width / 2), 225 - (20 * (contador + 1)));
disco.BringToFront();
disco.Refresh();
contador++;
return(0);
}
}
return(1);
}
int movimientos = 0;//variable que se utiliza para saber los movimientos totales
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (a.isEmpty() == true)//si a esta vacio
{
Disco enMovimiento = b.pop();
Console.WriteLine("mov si a es vacio");//guardamos b enMovimiento
a.push(enMovimiento);
}
else if (b.isEmpty() == true) //si b esta vacio
{
Disco enMovimiento = a.pop(); //guardamos a enMovimiento
Console.WriteLine("mov si b es vacio");
b.push(enMovimiento);
}
else if (a.elementos[a.elementos.Count - 1].Valor > b.elementos[b.elementos.Count - 1].Valor) //si el elemento a> b
{
Disco enMovimiento = b.pop(); //guardamos b enMovimiento
Console.WriteLine("mov si a > que b ");
a.push(enMovimiento);
}
else
{
Disco enMovimiento = a.pop();//guardamos a enMovimiento
Console.WriteLine("mov si a < que b ");
b.push(enMovimiento);
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (b.isEmpty())
{
Disco discoA = a.pop();
b.push(discoA);
Console.WriteLine("Moviendo de A a B");
}
else if (a.isEmpty())
{
Disco discoB = b.pop();
a.push(discoB);
Console.WriteLine("Moviendo de B a A");
}
else
{
if (a.Top.Valor < b.Top.Valor)
{
Disco discoA = a.pop();
b.push(discoA);
Console.WriteLine("Moviendo de A a B");
}
else if (b.Top.Valor < a.Top.Valor)
{
Disco discoB = b.pop();
a.push(discoB);
Console.WriteLine("Moviendo de B a A");
}
}
}
static void Main(string[] args)
{
Pila INI = new Pila();
Pila AUX = new Pila();
Pila FIN = new Pila();
Console.WriteLine("¿Con cuantos discos deseas jugar?");
int numeroDiscos = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i < numeroDiscos; i++)
{
Disco d = new Disco();
d.Valor = i + 1;
INI.push(d);
INI.Top = d.Valor;
}
Console.WriteLine("Inicio.");
Hanoi hanoi = new Hanoi();
hanoi.iterativo(numeroDiscos, INI, AUX, FIN);
Console.WriteLine("Inicio Algoritmo.");
hanoi.recursivo(numeroDiscos, INI, AUX, FIN);
Console.WriteLine("Presione cualquier tecla para salir.");
Console.ReadKey();
}
public void push(Disco d)
{
listaDiscos.Add(d);
Console.WriteLine("Metiendo en: " + nombrePila + "\n");
ultimoDisco = d.getTamanyo();
numDiscos++;
}
public Disco pop()
{
if (Size > 0)
{
Disco disco = Top;
Elementos.Remove(Top);
if (this.isEmpty())
{
Top = new Disco(0);
Size = 0;
}
else
{
Top = this.Elementos.Last();
Size--;
}
return(disco);
}
else
{
//Caso imposible, sacar un disco de una pila vacía
Console.WriteLine("ERROR: Sacar un disco de una pila Vacía");
return(new Disco(0));
}
}
//Mueve el top de la primera pila dada a la segunda, si no se puede,
//hace lo contrario: de la segunda a la primera.
public void mover_disco(Pila a, Pila b)
{
if (a.Top > b.Top)
{
if (b.isEmpty())
{
Disco d = a.pop();
b.push(d);
}
else
{
Disco d = b.pop();
a.push(d);
}
}
else if (a.Top < b.Top)
{
if (a.isEmpty())
{
Disco d = b.pop();
a.push(d);
}
else
{
Disco d = a.pop();
b.push(d);
}
}
}
public void registrarMovimiento(Pila a, Pila b)
{
Disco tmp = a.pop();
Console.WriteLine("Se ha movido el disco: " + tmp.Valor);
b.push(tmp);
}
static TestDisco()
{
/*---------------------------------------------*/
/* TESTING:
* Creació de discos */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Creació de discos ");
Disco disco_1 = new Disco();
disco_1.ValorInt = 1;
int Valor_1 = disco_1.ValorInt;
Disco disco_2 = new Disco();
disco_2.ValorInt = 2;
int Valor_2 = disco_2.ValorInt;
Disco disco_3 = new Disco();
disco_3.ValorInt = 3;
int Valor_3 = disco_3.ValorInt;
Console.WriteLine("Disco 1 Creat amb valor: " + Valor_1.ToString());
Console.WriteLine("Disco 2 Creat amb valor: " + Valor_2.ToString());
Console.WriteLine("Disco 3 Creat amb valor: " + Valor_3.ToString());
Console.WriteLine();
}
/*TODO: Implementar métodos*/
public void mover_disco(ref Pila a, ref Pila b)
{
if ((b.Top == 0) || (a.Top == 0))
{
if (b.Top == 0)
{
Disco disco = a.pop();
b.push(disco);
}
else
{
Disco disco = b.pop();
a.push(disco);
}
}
else
{
if (a.Top > b.Top)
{
Disco disco = b.pop();
a.push(disco);
}
else
{
Disco disco = a.pop();
b.push(disco);
}
}
}
public Disco pop()
{
Disco disco = Elementos[Elementos.Count - 1];
Elementos.RemoveAt(Elementos.Count - 1);
Size--;
return(disco);
}
//Aumenta la cantidad de discos en la pila y el disco que está arriba
public void push(Disco d)
{
if (Size == 0 || d.Valor < Elementos.Last().Valor)
{
Elementos.Add(d);
Size = Elementos.Count;
Top = Elementos.Last().Valor;
}
}
static void Main(string[] args)
{
//==============================================================================
//Inicializamos las pilas
//==============================================================================
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
//==============================================================================
//Preguntamos al usuario
//==============================================================================
Console.WriteLine(" Indique el número de discos que va a utilizar: ");
string key = Console.ReadLine();
int cuantos = 0;
while (!Int32.TryParse(key, out cuantos) || Int32.Parse(key) < 0)
{
Console.WriteLine("Inténtelo de nuevo");
key = Console.ReadLine();
}
for (int i = cuantos; i > 0; i--)
{
Disco disco = new Disco(); //Crea un disco vacio
disco.Valor = i; //Le asigna el valor o el tanyo al disco creado
ini.push(disco); //Mete el disco creado en la pila inicial
}
//==============================================================================
//Llamamos a la clase Hanoi y guardamos los movimientos
//==============================================================================
int movimientos = Hanoi.iterativo(cuantos, ini, fin, aux);
int movimientosRecursivo = Hanoi.recursivo(cuantos, ini, fin, aux);
Console.WriteLine(" Movimientos realizados iterativo = " + movimientos);
Console.WriteLine(" Movimientos realizados recursivo = " + movimientosRecursivo);
//==============================================================================
//Calculo de la formula de movimientos minimos
//==============================================================================
Console.WriteLine(" Minimo numero de movimientos = " + (Math.Pow(2, cuantos) - 1));
}
//que permitirá extraer el disco de la parte superior de la pila
public Disco pop()
{
Disco discoAdevolver = this.Elementos[(this.Elementos.Count - 1)];
if ((this.Elementos.Count - 2) >= 0)
{
this.Top = this.Elementos[(this.Elementos.Count - 2)].Valor;
}
this.Elementos.RemoveAt((this.Elementos.Count - 1));
this.Size--;
return(discoAdevolver);
}
//==============================================================================
// Mover disco
//==============================================================================
public static void mover_disco(Pila a, Pila b)
{
Disco discoMover = new Disco();
//==============================================================================
// Si las pilas estan vacias
//==============================================================================
if (a.isEmpty() == true)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de B a A");
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
else if (b.isEmpty() == true)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
//==============================================================================
// Mira que elemento superior de las pilas es mayor
//==============================================================================
else if (a.Top > b.Top)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de B a A");
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
else if (b.Top > a.Top)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
}
public Disco pop()
{
if (!isEmpty())
{
Disco last = Elementos[--Size];
Elementos.RemoveAt(Size);
Top = !isEmpty() ? Elementos[Size - 1].Valor : 0;
return(last);
}
return(null);
}
public Disco Pop()
{
Disco disco = null;
if (!EstaVacio())
{
contador--;
disco = pila[contador];
pila[contador] = null;
//return pila[contador];
}
return(disco);
}
public void push(Disco d)
{
//Introducimos dos condiciones si tamaño es 0 o
//el valor introducido es menor al valor mas alto de la pila registrado
if (Size == 0 || d.Valor < Top)
{
Size++;
Elementos.Add(d);
Top = d.Valor;
}
}
public Pila(uint n)
{
Elementos = new List <Disco>();
Disco iter;
for (int i = (int)n; i >= 1; --i)
{
iter = new Disco(i);
Elementos.Add(iter);
Top = iter.Valor;
Size++;
}
}
static void Main(string[] args)
{
Console.WriteLine("Introduzca la cantidad de discos:");
int valorNumerico;
String numeroDiscos = Console.ReadLine().ToString();
while (!Int32.TryParse(numeroDiscos.ToString(), out valorNumerico) || valorNumerico <= 0)
{
Console.WriteLine("Introduzca la cantidad de discos,el número ha de ser mayor a 0:");
numeroDiscos = Console.ReadLine().ToString();
}
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
for (int i = valorNumerico; i > 0; i--)
{
Disco d = new Disco();
d.Valor = i;
ini.push(d);
}
Hanoi hanoi = new Hanoi();
Console.WriteLine("Seleccione la opcion para resolver la torre\na)Iterativo\nb)Recursivo");
ConsoleKey tecla = Console.ReadKey().Key;
while (tecla != ConsoleKey.A && tecla != ConsoleKey.B)
{
Console.WriteLine("\nSeleccione la opcion para resolver la torre\na)Iterativo\nb)Recursivo");
tecla = Console.ReadKey().Key;
}
if (tecla == ConsoleKey.A)
{
Console.WriteLine("\nIterativo: Movimientos realizados: " + hanoi.iterativo(valorNumerico, ini, fin, aux));
}
else if (tecla == ConsoleKey.B)
{
Console.WriteLine("\nRecursivo: Movimientos realizados: " + hanoi.algoritmoRecursivo(valorNumerico, ini, fin, aux));
}
Console.WriteLine("Mínimo de movimientos: " + (Math.Pow(2, valorNumerico) - 1));
Console.WriteLine("Torre Fin -> " + fin.toString());
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
//Funcion para generar dinamicamente la cantidad de discos
//que se desee
public void generarDiscos(int numDiscos)
{
List <Disco> discos = new List <Disco>();
for (int i = n; i >= 1; i--)
{
Disco disco = new Disco(i);
Console.WriteLine(disco.getTamanyo());
discos.Add(disco);
}
for (int i = 0; i < discos.Count; i++)
{
asignarDiscosPilaIni(discos[i]);
}
}
int movimientos = 0; // Variable global movimientos inicializada en 0 que almacena la cantidad de movimientos que se realiza
public void mover_disco(Pila a, Pila b) // Método mover_disco que se le pasan dos pilas que es a las que se va a hacer el movimiento
{
if (a.Top < b.Top) // Si el disco superior de la pila a es menor que el de la b el movimiento se hace de a a b
{
Disco d = a.pop();
b.push(d); // Aquí se hace el movimiento con los métodos push y pop de la clase pila
Console.WriteLine("El disco " + d.valor + " se mueve de la " + a.nombre + " a la " + b.nombre);
}
else // En caso de que el disco superior de b sea menor que el de a, el movimiento se hace de la pila a b la pila a
{
Disco d = b.pop();
a.push(d); // Aquí se hace el movimiento con los métodos push y pop de la clase pila
Console.WriteLine("El disco " + d.valor + " se mueve de la " + b.nombre + " a la " + a.nombre);
}
}
public bool rellenarPila(int n)
{
if (n != 0)
{
for (int i = 0; i < n; i++)
{
Disco disco = new Disco();
disco.Valor = i;
this.push(disco);
}
return(true);
}
return(false);
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{//Mover disco de 'a' a 'b' o de 'b' a 'a'
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/
Disco aux = new Disco();
if (a.isEmpty() && b.isEmpty())
{
return;
}
if (a.Top > b.Top)
{// Si el disco top de a es mayor que el de b, entonces solo se podra mover de b hacia a
if (b.isEmpty())
{
aux = a.pop();
b.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/ return;
}
aux = b.pop();
a.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/}
else
{// sino se movera de 'a' a 'b'
if (a.isEmpty())
{
aux = b.pop();
a.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/return;
}
aux = a.pop();
b.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/ }
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
Disco mover = new Disco(0); //var donde almacenamos los discos que vamos a mover
//si en la pila a hay discos
if (a.isEmpty().Equals(false))
{
if (b.isEmpty().Equals(true))
{ //si la pila b esta vacia
mover = a.pop(); //get y borrar el ultimo disco de la pila
b.push(mover); //mover a la pila b
}
else // si en la pila b hay discos
{
if (a.Top < b.Top) //si el ultimo disco de a es mas pequenyo que el disco de b.
{
mover = a.pop(); //get y borrar el ultimo disco de la pila
b.push(mover); //mover a la pila b
}
else
{
mover = b.pop(); //get y borrar el ultimo disco de la pila b
a.push(mover); //mover b la pila a
}
}
}
else if (b.isEmpty().Equals(false))
{
if (a.isEmpty().Equals(true))
{
mover = b.pop(); //get y borrar el ultimo disco de la pila
a.push(mover); //mover a la pila a
}
else
{ //si en la pila a hay discos
if (b.Top < a.Top) //comprobamos si podemos mover el disco
{
mover = b.pop(); //get y borrar el ultimo disco de la pila
a.push(mover); //mover b la pila a
}
else
{
mover = a.pop(); //get y borrar el ultimo disco de la pila b
b.push(mover); //mover a la pila b
}
}
}
}
public Disco pop()//para quitar un disco
{
if (isEmpty() == true)
{
return(null);
}
else
{
//variable tipo disco
Disco variable = elementos[elementos.Count - 1];//donde guardamos en la variable el ultimo elemento de la lista
elementos.RemoveAt(elementos.Count - 1);
Size--;
return(variable);
}
}
public Disco pop()
{
Disco discoExtraido = elementos.Last();
elementos.Remove(discoExtraido);
// si al borrar el disco esta vacio el top = -1
if (!isEmpty())
{
top = elementos.Last().Valor;
}
else
{
top = -1;
}
return(discoExtraido);
}
public Disco pop()
{
Disco discoEliminado = this.Elementos[0];
this.Elementos.RemoveAt(0);
this.Size = this.Elementos.Count;
if (isEmpty() == true)
{
this.Top = 99;
}
if (isEmpty() == false)
{
this.Top = this.Elementos[0].Valor;
}
return(discoEliminado);
}
