public static void mover_disco(Pila a, Pila b)
{
Disco discoMover;
// Compruebo si las dos pilas estan vacias
if (a.isEmpty() && b.isEmpty())
{
return;
}
// Compruebo si b esta vacia o si b tiene un disco de mayor tamaño que a (todas estas condiciones requieren que a no este vacia)
else if (b.isEmpty() || b.Top > a.Top && a.isEmpty() == false)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco de tamaño " + discoMover.Valor.ToString() + " de " + a.Nombre + " a " + b.Nombre);
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
// Compruebo si a esta vacia o si a tiene un disco de mayor tamaño que b (todas estas condiciones requieren que b no este vacia)
else if (a.isEmpty() || a.Top > b.Top && b.isEmpty() == false)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco de tamaño " + discoMover.Valor.ToString() + " de " + b.Nombre + " a " + a.Nombre);
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int m = 0;
if (n % 2 == 0)
{
while (ini.isEmpty() == false && aux.isEmpty() == false)
{
mover_disco(ini, fin);
mover_disco(ini, aux);
mover_disco(aux, fin);
m = m + 3;
}
}
else
{
while (ini.isEmpty() == false && aux.isEmpty() == false)
{
mover_disco(ini, aux);
mover_disco(ini, fin);
mover_disco(aux, fin);
m = m + 3;
}
}
return(m);
}
/*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
}
}
}
}
/*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);
*/ }
}
public void mover_disco(Pila a, Pila b)
{
if (a.Top == b.Top) // Edge case (both are empty)
{
return;
}
else if (a.Top > b.Top)
{
if (b.isEmpty())
{
b.push(a.pop());
}
else
{
a.push(b.pop());
}
}
else
{
if (a.isEmpty())
{
a.push(b.pop());
}
else
{
b.push(a.pop());
}
}
movements++;
}
/*TODO: Implementar métodos*/
public static void mover_disco(Pila a, Pila b)
{/*
* if (a.isEmpty() && !b.isEmpty())
* {
* // Si una pila esta vacía y la otra no saco un disco y la pongo en la vacía
* a.push(b.pop());
* }
* else if (b.isEmpty() && !a.isEmpty())
* {
* b.push(a.pop());
* }
* else
* {*/
// Si ambas pilas tienen discos muevo el disco mas pequeño
// y lo pongo encima del grande
if (!a.isEmpty() || !b.isEmpty())
{
// Si a tiene un disco mas pequeño que b muevo el disco de a => b
if (a.isMyTopSmaller(b))
{
a.push(b.pop());
}
// Si b tiene un disco mas pequeño que a muevo el disco de b => a
else
{
b.push(a.pop());
}
}
}
//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);
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (a.Top < b.Top) // Comprobamos si a es menor a b
{
if (a.isEmpty()) // Comprobamos si a está vacia
{
a.push(b.pop()); // En caso de que esté vacia significa que a no es menor a b, sino que a es 0
}
else
{
b.push(a.pop()); // Sino a si que es menor a b
}
}
else
{
if (a.Top > b.Top) // Comprobamos si b es menor a a
{
if (b.isEmpty()) // Comprobamos si b está vacia
{
b.push(a.pop()); // En ese caso b no es menor a a
}
else
{
a.push(b.pop()); // Si está llena b es menor a a
}
}
}
}
/*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");
}
}
}
//Comprobar el ultimoDisco de cada una de las pilas y si el movimiento a->b es posible segun las reglas
//o si por el contrario el movimiento correcto es b->a
public String comprobarMovimiento(Pila a, Pila b)
{
if (pilaFIN.getNumDiscos() != n)
{
if (a.isEmpty())
{
return("B");
}
else if (b.isEmpty())
{
return("A");
}
if (a.getUltimoDisco() > b.getUltimoDisco())
{
return("B");
}
else
{
return("A");
}
}
else
{
return("C");
}
}
//implementem el mover_disco()
public void mover_disco(Pila a, Pila b)
{
Disco d;
//si el disco de dalt de la pila a és més xicotet que el de la pila b; o la pila b està buida;
//i si la pila a conté discos:
if (((a.Top < b.Top) || (b.isEmpty() == true)) && (a.isEmpty() == false))
{
//si hi ha disco, que l'agafe de dalt de a i l'afegisca a la pila b.
d = a.pop();
if (d != null)
{
b.push(d);
}
}
//si no: si hi ha, que agafe el disco de dalt de b i l'afegisca a la pila a.
else
{
d = b.pop();
if (d != null)
{
a.push(d);
}
}
}
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);
}
}
public void mover_disco(Pila a, Pila b)
{
bool mov_a_b;
bool mov_b_a;
if (b.isEmpty() == true)
{
mov_b_a = false;
mov_a_b = true;
Console.WriteLine("Muevo el disco " + a.Top + " desde " + a.Name + " hasta " + b.Name);
}
else if (a.isEmpty() == true)
{
mov_a_b = false;
mov_b_a = true;
Console.WriteLine("Muevo el disco " + b.Top + " desde " + b.Name + " hasta " + a.Name);
}
else if (a.Top < b.Top && b.isEmpty() == false)
{
mov_b_a = false;
mov_a_b = true;
Console.WriteLine("Muevo el disco " + a.Top + " desde " + a.Name + " hasta " + b.Name);
}
else if (a.Top > b.Top && a.isEmpty() == false)
{
mov_a_b = false;
mov_b_a = true;
Console.WriteLine("Muevo el disco " + b.Top + " desde " + b.Name + " hasta " + a.Name);
}
else
{
mov_b_a = false;
mov_a_b = false;
Console.WriteLine("No Puedo mover");
}
if (mov_a_b == true && mov_b_a == false)
{
b.push(a.Elementos[a.Size - 1]);
a.pop();
}
else if (mov_b_a == true && mov_a_b == false)
{
a.push(b.Elementos[b.Size - 1]);
b.pop();
}
}
//TODO: Implementar métodos
public void mover_disco(Pila a, Pila b)
{
//si hay algun disco en la pila
if (a.isEmpty().Equals(false)) // si en la a pila hay algun disco
{
if (b.isEmpty().Equals(true)) //se observa tambien si en la pila b hay alguno
{
Disco disco = a.pop(); //lo quitamos de la pila a
b.push(disco); //y a continuacion lo ponemos en b
}
else //si no se da el caso anterior
{
if (a.Top > b.Top) // si el ultimo disco de la pila a > ultimo disco de la pila b
{
Disco disco = b.pop(); //se quita en b
a.push(disco); //se anyade en a
}
else
{
Disco disco = a.pop(); //se quita de a
b.push(disco); //se pone en b
}
}
}
else if (b.isEmpty().Equals(false)) //en la pila b esta llena
{
if (a.isEmpty().Equals(true)) //y en la pila a esta vacia
{
Disco disco = b.pop(); //cambiamos de la pila b a la a el disco
a.push(disco);
}
else//igual que en el caso anterior coprobamos si el disco de mas arriba es mayor al disco de a
{
if (b.Top > a.Top)
{
Disco disco = a.pop();
b.push(disco);
}
else
{
Disco disco = b.pop();
a.push(disco);
}
}
}
}
public bool isMyTopSmaller(Pila otherPile)
{
if (this.isEmpty() && !otherPile.isEmpty())
{
return(true);
}
else if (!this.isEmpty() && otherPile.isEmpty())
{
return(false);
}
else if (this.Top < otherPile.Top)
{
return(true);
}
else
{
return(false);
}
}
//==============================================================================
// 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 void mostrarPila(Pila aux)
{
if (aux.isEmpty())
{
Console.WriteLine("Torre " + aux.nombre + " : " + "-----" + "Vacia");
return;
}
for (int i = 0; i <= aux.Size - 1; i++)
{
Console.WriteLine("Torre " + aux.nombre + " : " + aux.Elementos[i].Valor);
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
//por si hay una pila vacia
if (a.isEmpty() && b.Top != 0)
{
Disco discoMovido = b.pop();
a.push(discoMovido);
//Console.WriteLine("discoMovido" + discoMovido.Valor);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
else if (!a.isEmpty() && b.isEmpty())
{
Disco discoMovido = a.pop();
b.push(discoMovido);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
else
{
//por si estan las dos llenas se realiza una comparación
int inicio = a.Top;
int final = b.Top;
if (inicio > final)
{
//de b a a
Disco discoMovido = b.pop();
a.push(discoMovido);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
else
{
//de a a b
Disco discoMovido = a.pop();
b.push(discoMovido);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
}
}
public void mover_disco(Pila a, Pila b)
{
if (a.isEmpty() && !b.isEmpty())
{
// mover de B a A
Disco dB = b.pop(); //quitar de B
a.push(dB); // poner en A
Console.WriteLine("Se mueve: " + dB.Valor + " de " + b.Nombre + " a " + a.Nombre);
}
else if (!a.isEmpty() && b.isEmpty())
{
// mover de A a B
Disco dA = a.pop(); //quitar de A
b.push(dA); // poner en B
Console.WriteLine("Se mueve: " + dA.Valor + " de " + a.Nombre + " a " + b.Nombre);
}
else
{
int topA = a.Top;
int topB = b.Top;
if (topA > topB)
{
// si a tiene una ficha mas grande se tendrá que mover de B a A
// mover de B a A
Disco dB = b.pop(); //quitar de B
a.push(dB); // poner en A
Console.WriteLine("Se mueve: " + dB.Valor + " de " + b.Nombre + " a " + a.Nombre);
}
else
{
// mover de A a B
Disco dA = a.pop(); //quitar de A
b.push(dA); // poner en B
Console.WriteLine("Se mueve: " + dA.Valor + " de " + a.Nombre + " a " + b.Nombre);
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if(b.isEmpty(){
b[0]=a[a.getSize()-1];
a.pop();
}
else if(a[a.getSize()-1].getValor() < b[b.getSize()-1].getValor(){
b[b.getSize()-1]=a[a.getSize()-1];
a.pop();
}
else{
return 0;
}
}
/*TODO: Implementar métodos*/
public static void mover_disco(Pila a, Pila b)
{
Disco discoMover = new Disco();
if (a.isEmpty())
{
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())
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
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 void mover_disco(Pila a, Pila b)
{
if (b.isEmpty())
{
registrarMovimiento(a, b);
}
else if (a.isEmpty())
{
registrarMovimiento(b, a);
}
else
{
Disco discoA = b.lastElement();
Disco discoB = a.lastElement();
if (discoA.Valor < discoB.Valor)
{
registrarMovimiento(b, a);
}
else
{
registrarMovimiento(a, b);
}
}
}
static void Main(string[] args)
{
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
Console.WriteLine("¿Cuantos discos quieres?");
int cantidadDiscos = 0;
int pesoDisco = 1; // El peso del disco en cada momento que pedimos uno.
bool pesoCorrecto = false; // Nos dice si el peso introducido es inferior al anterior
try
{
cantidadDiscos = int.Parse(Console.ReadLine());
if (cantidadDiscos == 0)
{
Console.WriteLine("¿Cuantos discos quieres?");
cantidadDiscos = 0;
cantidadDiscos = int.Parse(Console.ReadLine());
}
}
catch (Exception e)
{
Console.WriteLine("Has puesto un valor no aceptado");
}
for (int i = 1; i <= cantidadDiscos; i++)
{
try
{
// Creamos un While para que pregunte el peso del disco mientras no sea inferior al anterior
while (!pesoCorrecto)
{
// Preguntamos el peso que quiere de disco
Console.WriteLine("¿De que tamaño quieres que sea el disco " + i + "?" + "\n\n\t Como mínimo debería de ser de " + (cantidadDiscos - i + 1));
pesoDisco = int.Parse(Console.ReadLine()); // Añadimos el peso a la variable pesoDisco
// Si un disco tiene peso 0 nos da error a la hora de hacer el hanoi
if (pesoDisco != 0 && pesoDisco > 0 && pesoDisco >= (cantidadDiscos - i + 1))
{
// Comprovamos si la lista ini está vacía
if (ini.isEmpty())
{
// Si está insertamos el disco directamente
ini.push(new Disco(pesoDisco));
pesoCorrecto = true;
}
else // Entramos si la pila ini tiene algún disco
{
// Preguntamos el peso del disco es inferior al que está ya puesto
if (ini.Top > pesoDisco)
{
pesoCorrecto = true; // Ponemos que el peso introducido es correcto
ini.push(new Disco(pesoDisco)); // Creamos un disco y lo insertamos en ini
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Has puesto un valor no aceptado");
i--;
}
pesoCorrecto = false;
}
Hanoi hanoi = new Hanoi();
Console.WriteLine("Llamamos a iterativo: ");
int movimientosHechos = hanoi.iterativo(cantidadDiscos, ini, fin, aux);
//Console.WriteLine("Llamamos a recursivo: ");
//int movimientosHechos = hanoi.recursivo(cantidadDiscos, ini, fin, aux);
double movimientoRequeridos = Math.Pow(2, cantidadDiscos) - 1;
Console.WriteLine("Número de discos: " + cantidadDiscos);
Console.WriteLine("Número de movimentos necesarios mínimos: " + movimientoRequeridos);
Console.WriteLine("Número de movimentos hechos: " + movimientosHechos);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static TestPila()
{
Disco disco_1 = new Disco();
disco_1.ValorInt = 1;
Disco disco_2 = new Disco();
disco_2.ValorInt = 2;
Disco disco_3 = new Disco();
disco_3.ValorInt = 3;
/*---------------------------------------------*/
/* TESTING:
* Creació de pila */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Creació de pila ");
Pila pila_A = new Pila();
Pila pila_B = new Pila();
Pila pila_C = new Pila();
int size_A = pila_A.Size;
bool buida_A = pila_A.isEmpty();
Console.WriteLine("Tamany de pila_A: " + size_A.ToString());
Console.WriteLine("Està buida pila_A: " + buida_A.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Checking top de una pila buida (pila_A) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Checking top de una pila buida (pila_A) ");
Console.WriteLine("top de pila_A buida: " + pila_A.Top.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Pushing en una pila buida un disco (pila_A, disco_3) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Pushing en una pila buida un disco (pila_A, disco_3) ");
pila_A.push(disco_3);
Console.WriteLine("disco en top pila (pila_A es Disco 3): " + pila_A.Top.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Elements en una pila buida (pila_B) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Elements en una pila buida (pila_B) ");
List <Disco> Elements_B = pila_B.Elementos;
int Total_B = 0;
Console.WriteLine("Elements en la pila buida ");
foreach (Disco Element in Elements_B)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
Total_B++;
}
Console.WriteLine("Total: " + Total_B.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Elements en una pila amb un disco (pila_A) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Elements en una pila amb un disco (pila_A) ");
List <Disco> Elements_A = pila_A.Elementos;
int Total_A = 0;
Console.WriteLine("Elements en la pila ");
foreach (Disco Element in Elements_A)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
Total_A++;
}
Console.WriteLine("Total: " + Total_A.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Elements en una pila amb varis discos disco (pila_C) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Elements en una pila amb varis discos disco (pila_C) ");
pila_C.push(disco_3);
pila_C.push(disco_2);
pila_C.push(disco_1);
List <Disco> Elements_C = pila_C.Elementos;
int Total_C = 0;
Console.WriteLine("Elements en la pila ");
foreach (Disco Element in Elements_C)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
Total_C++;
}
Console.WriteLine("Total: " + Total_C.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Poping de una pila amb sols un disco (pila_A disco_3) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Poping de una pila amb sols un disco (pila_A disco_3) ");
Console.WriteLine("Disco extret: " + pila_A.pop().ValorInt.ToString());
Console.WriteLine("La pila queda buida: " + pila_A.isEmpty().ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Poping una pila fins a buidar-la (pila_C) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Poping una pila fins a buidar-la (pila_C) ");
Total_C = 0;
while (!pila_C.isEmpty())
{
Console.WriteLine("Disco extret: " + pila_C.pop().ValorInt.ToString());
Total_C++;
}
Console.WriteLine("Total: " + Total_C.ToString());
Console.WriteLine("La pila queda buida: " + pila_A.isEmpty().ToString());
Console.WriteLine();
}
