Java programa para manejar Pila de nodos menú vacía tamaño apilar retirar cima

[ElMike]

Estimados amigos, buenas tardes, acudo a ustedes debido a que tengo duda de como se podría implementar el siguiente menú:

1. Esvacia
2. Tamaño de la pila
3. Guardar un nuevo registro (apilar)
4. Eliminar un elemento de la pila(retirar)
5. El ultimo elemento de la pila(cima)
6. Buscar
7. Remover un elemento de la pila
8. Editar, permite cambiar un elemento de la pila por otro valor
9. Eliminar la pila
10. Listar Mostrar los elementos que se contienen dentro de las pilas
11. Salir

Sobre este ejercicio de pilas que ya he desarrollado.

Función principal:

Código: [Seleccionar]

package ejemplopilas;

public class EjemploPilas {

    public static void main(String[] args) {
   Pilas pila=new Pilas();
   
   pila.apilar(50);
   pila.apilar(1);
   pila.apilar(60);
   pila.apilar(5);
   pila.apilar(100);
   pila.apilar(9);
   pila.apilar(18);
   
        System.out.println("el tamanio de la pila es:"+pila.getTamanio());
       
        pila.apilar(55);
        pila.apilar(99);
       
        System.out.println("el tamanio de la pila es:"+pila.getTamanio());

    }
   
}

Clase Nodo:

Código: [Seleccionar]

package ejemplopilas;

public class Nodo {
    //Definir los atributos
    private int valor;
    private Nodo siguiente;
   
    //Contructor
   
    public void Nodo(){
    this.valor=0;
    this.siguiente=null;
    }
   
    //Metodos get y set
   
    public int getValor(){
        return valor;
    }
   
    public Nodo getSiguiente(){
        return siguiente;
    }
   
    public void setValor(int valor){
        this.valor= valor;
    }
   
    public void setSiguiente(Nodo siguiente){
        this.siguiente = siguiente;
    }
   
   
}

Clase pilas:

Código: [Seleccionar]

package ejemplopilas;


public class Pilas {
    //Definiendo los atributos de la pila
   
    private Nodo inicio;
   
    private int tamanio;

    //Constructor
    public void Pila(){
        inicio=null;
        tamanio=0;
    }
   
    /** Consulta si la pila esta vacia
    *@return true si el primer nodo (inicio), no apunta a otro nodo.
    */
    public boolean esVacio(){
        return inicio==null;
    }
   
     /**
     * Consulta cuantos elementos (nodos) tiene la pila.
     * @return numero entero entre (0,n)donde n es el numero de elementos
     * que contenga la lista
     */
    public int getTamanio(){
        return tamanio;       
    }
   
     public void apilar(int valor){
     //Definir nuevo nodo
     Nodo nuevo= new Nodo();
     //Agrega al valor Nodo
     nuevo.setValor(valor);
     //Consultar si la pila esta vacia.
     
     if(esVacio()){
         //Inicializa la pila con el nuevo valor
         inicio=nuevo;
     }
     //en caso contrario agrega el nuevo nodo al inicio de la pila
     else{
         nuevo.setSiguiente(inicio);
         inicio= nuevo;
        }
     //Incrementa el contador del tamaño de la pila
        tamanio++;
     }   
    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }

    //Metodo que regresa el valor que esta en la cima de la pila
   
    public int cima() throws Exception{
    if(!esVacio()){
        return inicio.getValor();
        }   
    else
        {
        throw new Exception("La pila se encuentra vacia");
        }
    }
   
    public boolean buscar(int referencia){
        //Crear una copia de la pila
        Nodo aux = inicio;
        //Verificar si existe el elemento a buscar
        boolean existe= false;
       
        //Recorre la pila hasta llegar a encontrar el nodo o
        //llegar al final de la pila
       
        while(existe !=true && aux!=null){
            //Compara si el valor del nodo es igual al valor de la referencia
            if(referencia==aux.getValor()){
                existe=true;
            }
            else
            {
                //Avanza al siguiente nodo
                aux= aux.getSiguiente();
            }
        }
        return existe;
    }
}   


De antemano, agradezco todo su apoyo, muchas gracias.

Saludos con afecto,
ElMike

[Kabuto]

Bueno, en realidad lo "difícil", que es la clase Pila y Nodo, ya lo tienes.
Hacer un menú es lo fácil.

Primero una corrección en la clase Nodo.
Recuerda que los constructores NO TIENEN NINGÚN TIPO DE RETORNO.
Ni siquiera void, si se lo pones a un constructor, deja de serlo y se transforma en un método:

public class Nodo {
   //Definir los atributos
   private int valor;
   private Nodo siguiente;

   //Contructor

   public void Nodo(){
      this.valor=0;
      this.siguiente=null;
   }

Aparentemente ha estado funcionando, porque ese "no constructor", su código hace lo mismo que si no hubiera constructor.
No hace falta un constructor para hacer que un int tenga valor 0 y que un objeto de clase tenga valor null, eso son los valores que van a tener por defecto si no hay un "verdadero constructor" que diga lo contrario.

Así que el void lo tienes que quitar. Pero incluso puedes prescindir totalmente del constructor ya que por las características de esta clase no parece que sea necesario.

Con la clase Pila ocurre lo mismo, si quieres constructor has de quitar el retorno "void".
Pero en cualquier caso, para esta clase también podrías prescindir de constructores.


Dicho esto, para hacer un menú, basta con crear una clase con un objeto Pila y un objeto Scanner como atributos.
Y en el método main, un bucle que ofrezca las opciones disponibles.

Con un switch evalúas que opción ha escogido el usuario y en cada case escribes el código necesario para cumplir con lo solicitado.

Aquí te dejo un ejemplo para que lo completes. Si te atascas al desarrollar alguna de las opciones, vuelve a pedir ayuda por aquí.

Código: [Seleccionar]

import java.util.Scanner;

public class Menu {

private static Pila pila = new Pila();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

while (opcion != 11) {

System.out.println("\n\t\tMENU PILA\n");
System.out.println("[1] -- Es vacia");
System.out.println("[2] -- Tamaño de la pila");
System.out.println("[3] -- Guardar un nuevo registro (apilar)");
System.out.println("[4] -- Eliminar un elemento de la pila(retirar)");
System.out.println("[5] -- El ultimo elemento de la pila(cima)");
System.out.println("[6] -- Buscar");
System.out.println("[7] -- Remover un elemento de la pila");
System.out.println("[8] -- Editar, cambiar un elemento de la pila por otro valor");
System.out.println("[9] -- Eliminar la pila");
System.out.println("[10] -- Listar elementos contenidos en las pilas");
System.out.println("[11] -- Salir");
System.out.print("Elija opcion: ");
opcion = teclado.nextInt();

switch(opcion) {
case 1:
System.out.println(pila.esVacio()?"La pila esta vacia":"La pila NO esta vacia");
break;
case 2:
System.out.println("Tamaño pila: " + pila.getTamanio());
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
case 10:
break;
case 11:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpcion equivocada...");
}
}

}

}

[ElMike]

Creo que estoy muy wey, por que me marca error al llamar las clases, me puedes ayudar por favor?

Esto es lo que he realizado:

Función principal Menú

Código: [Seleccionar]

package menu;

import java.util.Scanner;

public class Menu {

private static Pila pila = new Pila();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

while (opcion != 11) {

System.out.println("\n\t\tMENU PILA\n");
System.out.println("[1] -- Es vacia");
System.out.println("[2] -- Tamaño de la pila");
System.out.println("[3] -- Guardar un nuevo registro (apilar)");
System.out.println("[4] -- Eliminar un elemento de la pila(retirar)");
System.out.println("[5] -- El ultimo elemento de la pila(cima)");
System.out.println("[6] -- Buscar");
System.out.println("[7] -- Remover un elemento de la pila");
System.out.println("[8] -- Editar, cambiar un elemento de la pila por otro valor");
System.out.println("[9] -- Eliminar la pila");
System.out.println("[10] -- Listar elementos contenidos en las pilas");
System.out.println("[11] -- Salir");
System.out.print("Elija opcion: ");
opcion = teclado.nextInt();

switch(opcion) {
case 1:
System.out.println(pila.esVacio()?"La pila esta vacia":"La pila NO esta vacia");
break;
case 2:
System.out.println("Tamaño pila: " + pila.getTamanio());
break;
case 3:
                            pila.apilar();
break;
case 4:
                            System.out.println("Ingrese el elemento a eliminar") pila.retirar();
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
case 10:
break;
case 11:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpcion equivocada...");
}
}

}

}

Clase Pila "Me marco en unas lineas un error al final de la clase"

Código: [Seleccionar]

package menu;

public class Pila {
   
     //Definiendo los atributos de la pila
   
    private Nodo inicio;
   
    private int tamanio;

    //Constructor
    public void Pila(){
        inicio=null;
        tamanio=0;
    }
   
    /** Consulta si la pila esta vacia
    *@return true si el primer nodo (inicio), no apunta a otro nodo.
    */
    public boolean esVacio(){
        return inicio==null;
    }
   
     /**
     * Consulta cuantos elementos (nodos) tiene la pila.
     * @return numero entero entre (0,n)donde n es el numero de elementos
     * que contenga la lista
     */
    public int getTamanio(){
        return tamanio;       
    }
   
     public void apilar(int valor){
     //Definir nuevo nodo
     Nodo nuevo= new Nodo();
     //Agrega al valor Nodo
     nuevo.setValor(valor);
     //Consultar si la pila esta vacia.
     
     if(esVacio()){
         //Inicializa la pila con el nuevo valor
         inicio=nuevo;
     }
     //en caso contrario agrega el nuevo nodo al inicio de la pila
     else{
         nuevo.setSiguiente(inicio);
         inicio= nuevo;
        }
     //Incrementa el contador del tamaño de la pila
        tamanio++;
     }   
    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }

    //Metodo que regresa el valor que esta en la cima de la pila
   
    public int cima() throws Exception{
    if(!esVacio()){
        return inicio.getValor();
        }   
    else
        {
        throw new Exception("La pila se encuentra vacia");
        }
    }
   
    public boolean buscar(int referencia){
        //Crear una copia de la pila
        Nodo aux = inicio;
        //Verificar si existe el elemento a buscar
        boolean existe= false;
       
        //Recorre la pila hasta llegar a encontrar el nodo o
        //llegar al final de la pila
       
        while(existe !=true && aux!=null){
            //Compara si el valor del nodo es igual al valor de la referencia
            if(referencia==aux.getValor()){
                existe=true;
            }
            else
            {
                //Avanza al siguiente nodo
                aux= aux.getSiguiente();
            }
        }
        return existe;
    }

    String getTamanio() {
        throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
    }
}   

Clase nodo

Código: [Seleccionar]

package menu;


class Nodo {
      //Definir los atributos
    private int valor;
    private Nodo siguiente;
   
    //Constructor
   
    public Nodo(){
    this.valor=0;
    this.siguiente=null;
    }
   
    //Metodos get y set
   
    public int getValor(){
        return valor;
    }
   
    public Nodo getSiguiente(){
        return siguiente;
    }
   
    public void setValor(int valor){
        this.valor= valor;
    }
   
    public void setSiguiente(Nodo siguiente){
        this.siguiente = siguiente;
    }
   
   
}

Perdón por la molestia, llevo ya un par de horas y simplemente no que queda.

Gracias por tus atenciones,
ElMike

[Kabuto]

Yo lo que veo es que tienes dos métodos llamados getTamanio()(los marco en rojo), y eso no es permisible.

package menu;

public class Pila {
   
     //Definiendo los atributos de la pila
   
    private Nodo inicio;
   
    private int tamanio;

    //Constructor
    public void Pila(){
        inicio=null;
        tamanio=0;
    }
   
    /** Consulta si la pila esta vacia
    *@return true si el primer nodo (inicio), no apunta a otro nodo.
    */
    public boolean esVacio(){
        return inicio==null;
    }
   
     /**
     * Consulta cuantos elementos (nodos) tiene la pila.
     * @return numero entero entre (0,n)donde n es el numero de elementos
     * que contenga la lista
     */
    public int getTamanio(){
        return tamanio;       
    }
   
     public void apilar(int valor){
     //Definir nuevo nodo
     Nodo nuevo= new Nodo();
     //Agrega al valor Nodo
     nuevo.setValor(valor);
     //Consultar si la pila esta vacia.
     
     if(esVacio()){
         //Inicializa la pila con el nuevo valor
         inicio=nuevo;
     }
     //en caso contrario agrega el nuevo nodo al inicio de la pila
     else{
         nuevo.setSiguiente(inicio);
         inicio= nuevo;
        }
     //Incrementa el contador del tamaño de la pila
        tamanio++;
     }   
    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }

    //Metodo que regresa el valor que esta en la cima de la pila
   
    public int cima() throws Exception{
    if(!esVacio()){
        return inicio.getValor();
        }   
    else
        {
        throw new Exception("La pila se encuentra vacia");
        }
    }
   
    public boolean buscar(int referencia){
        //Crear una copia de la pila
        Nodo aux = inicio;
        //Verificar si existe el elemento a buscar
        boolean existe= false;
       
        //Recorre la pila hasta llegar a encontrar el nodo o
        //llegar al final de la pila
       
        while(existe !=true && aux!=null){
            //Compara si el valor del nodo es igual al valor de la referencia
            if(referencia==aux.getValor()){
                existe=true;
            }
            else
            {
                //Avanza al siguiente nodo
                aux= aux.getSiguiente();
            }
        }
        return existe;
    }

    String getTamanio() {
        throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
    }
}   

[ElMike]

Amigo Kabuto, ya hice el ajuste, solo que al llamar al procedimiento de la clase pila, me marca error, no puedo completar el menu por que no reconoce el llamado, el cual realizo asi.

pila.apilar();
pila.retirar();

Anexo el código con el ajuste que me indicas:

Clase Principal Menú

Código: [Seleccionar]

package menu;


import java.util.Scanner;


public class Menu {

private static Pila pila = new Pila();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

while (opcion != 11) {

System.out.println("\n\t\tMENU PILA\n");
System.out.println("[1] -- Es vacia");
System.out.println("[2] -- Tamaño de la pila");
System.out.println("[3] -- Guardar un nuevo registro (apilar)");
System.out.println("[4] -- Eliminar un elemento de la pila(retirar)");
System.out.println("[5] -- El ultimo elemento de la pila(cima)");
System.out.println("[6] -- Buscar");
System.out.println("[7] -- Remover un elemento de la pila");
System.out.println("[8] -- Editar, cambiar un elemento de la pila por otro valor");
System.out.println("[9] -- Eliminar la pila");
System.out.println("[10] -- Listar elementos contenidos en las pilas");
System.out.println("[11] -- Salir");
System.out.print("Elija opcion: ");
opcion = teclado.nextInt();

switch(opcion) {
case 1:
System.out.println(pila.esVacio()?"La pila esta vacia":"La pila NO esta vacia");
break;
case 2:
System.out.println("Tamaño pila: " + pila.getTamanio());
break;
case 3:
                            pila.apilar();
break;
case 4:
                            System.out.println("Ingrese el elemento a eliminar") pila.retirar();
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
case 10:
break;
case 11:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpcion equivocada...");
}
}

}

}

Java Class Pila

Código: [Seleccionar]

package menu;

public class Pila {
   
     //Definiendo los atributos de la pila
   
    private Nodo inicio;
   
    private int tamanio;

    //Constructor
    public void Pila(){
        inicio=null;
        tamanio=0;
    }
   
    /** Consulta si la pila esta vacia
    *@return true si el primer nodo (inicio), no apunta a otro nodo.
    */
    public boolean esVacio(){
        return inicio==null;
    }
   
     /**
     * Consulta cuantos elementos (nodos) tiene la pila.
     * @return numero entero entre (0,n)donde n es el numero de elementos
     * que contenga la lista
     */
    public int getTamanio(){
        return tamanio;       
    }
   
     public void apilar(int valor){
     //Definir nuevo nodo
     Nodo nuevo= new Nodo();
     //Agrega al valor Nodo
     nuevo.setValor(valor);
     //Consultar si la pila esta vacia.
     
     if(esVacio()){
         //Inicializa la pila con el nuevo valor
         inicio=nuevo;
     }
     //en caso contrario agrega el nuevo nodo al inicio de la pila
     else{
         nuevo.setSiguiente(inicio);
         inicio= nuevo;
        }
     //Incrementa el contador del tamaño de la pila
        tamanio++;
     }   
    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }

    //Metodo que regresa el valor que esta en la cima de la pila
   
    public int cima() throws Exception{
    if(!esVacio()){
        return inicio.getValor();
        }   
    else
        {
        throw new Exception("La pila se encuentra vacia");
        }
    }
   
    public boolean buscar(int referencia){
        //Crear una copia de la pila
        Nodo aux = inicio;
        //Verificar si existe el elemento a buscar
        boolean existe= false;
       
        //Recorre la pila hasta llegar a encontrar el nodo o
        //llegar al final de la pila
       
        while(existe !=true && aux!=null){
            //Compara si el valor del nodo es igual al valor de la referencia
            if(referencia==aux.getValor()){
                existe=true;
            }
            else
            {
                //Avanza al siguiente nodo
                aux= aux.getSiguiente();
            }
        }
        return existe;
    }

   }   

Java Class Nodo

Código: [Seleccionar]

package menu;


class Nodo {
      //Definir los atributos
    private int valor;
    private Nodo siguiente;
   
    //Constructor
   
    public Nodo(){
    this.valor=0;
    this.siguiente=null;
    }
   
    //Metodos get y set
   
    public int getValor(){
        return valor;
    }
   
    public Nodo getSiguiente(){
        return siguiente;
    }
   
    public void setValor(int valor){
        this.valor= valor;
    }
   
    public void setSiguiente(Nodo siguiente){
        this.siguiente = siguiente;
    }
   
   
}


[Kabuto]

El método apilar() ha de recibir un valor entre paréntesis.
Así está declarado:

Código: [Seleccionar]

public void apilar(int valor){
Pero tú al llamarlo no le estás dando ningún valor:

Código: [Seleccionar]

case 3:
    pila.apilar();
    break;
Es decir, le tienes que indicar el valor que quieres apilar.
Y se supone que tenemos solicitar al usuario dicho valor, algo como esto:

Código: [Seleccionar]

case 3:
    System.out.print("Indique valor que quiere apilar: ");
    pila.apilar(teclado.nextInt());
    break;
En cuanto al método retirar(), el fallo principal es que no has separado con ; la instrucción System.out de la llamada al método:

Código: [Seleccionar]

case 4:
    System.out.println("Ingrese el elemento a eliminar") pila.retirar();
    break;Falta el ; y mejor si separamos en dos líneas para mayor legibilidad:

Código: [Seleccionar]

case 4:
    System.out.println("Ingrese el elemento a eliminar");
    pila.retirar();
    break;Ahora no hay fallos de sintaxis, pero sí de lógica.

En el case 4, lanzas mensaje para que el usuario ingrese elemento a eliminar, pero no recoges por teclado ese elemento, así que el usuario no tiene posibilidad de teclear nada.
Pero es que además, el método retirar() no está preparado para recibir ningún argumento, así que aunque lo recogieras, no puedes dárselo al método.
El método retirar() que has escrito, lo que hace es retirar el primer nodo, no puedes indicarle un valor concreto para que lo retire:

Código: [Seleccionar]

    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }
Así que tienes que escribir un método nuevo que sí pueda recibir el valor que se ha de eliminar.
Lo que puedes hacer es sobrecargar el método retirar() para que existan dos versiones:
- la que no recibe argumento y retira el primer nodo, que es la que ya tienes escrita
- la que si recibe argumento y retira el nodo que coincida con ese argumento.

Para sobrecargar un método, simplemente has de volver a declararlo, indicando ahora el argumento que ha de recibir

    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }
   
    //Sobrecarga del método retirar(), para que reciba un valor concreto para retirar
    public void retirar(int valor) {
       
    }

Ahora intenta escribir el código necesario para retirar el nodo que coincida con ese valor.

Cuando lo tengas, ya en el case 4 podrás pedir un valor al usuario y proporcionárselo al método sobrecargado:

Código: [Seleccionar]

case 4:
    System.out.println("Ingrese el elemento a eliminar");
    pila.retirar(teclado.nextInt());
    break;