PRACTICA PROGRAMACION II

13 septiembre, 2021

1. Modificar el siguiente código para insertar 5 elementos en la pila

import java.util.Stack;
public class NewMain {
   public static void main(String[] args) {
       Stack s = new Stack();
       s.push("Pila");
       s.push("En");
       s.push("Java");
       System.out.println(s);
   }
}

2. Modificar el siguiente código para insertar 5 elementos en una pila

import java.util.Stack;
public class PruebaStack {
public static void main(String[] args) {
Stack<String> pila1 = new Stack<String>();
System.out.println("Insertamos tres elementos en la pila: juan, ana y luis");
pila1.push("juan");
pila1.push("ana");
pila1.push("luis");
System.out.println("Cantidad de elementos en la pila:" + pila1.size());
System.out.println("Extraemos un elemento de la pila:" + pila1.pop());
System.out.println("Cantidad de elementos en la pila:" + pila1.size());
System.out.println("Consultamos el primer elemento de la pila sin extraerlo:" +
pila1.peek());
System.out.println("Cantidad de elementos en la pila:" + pila1.size());
System.out.println("Extraemos uno a uno cada elemento de la pila mientras no este
vacía:");
while (!pila1.isEmpty())
Sym.out.print(pila1.pop() + "-");
 System.out.println();
Stack<Integer> pila2 = new Stack<Integer>();
pila2.push(70);
pila2.push(120);
pila2.push(6);
System.out.println("Borramos toda la pila");
pila2.clear();
System.out.println("Cantidad de elementos en la pila de enteros:" + pila2.size());
}
}

3. Operaciones en una pila

import java.util.Scanner;
import java.util.Stack;
public class PruebaPila {
public static void main(String[] args) {
Stack pila = new Stack();
Scanner leer = new Scanner(System.in);
System.out.println(“Ingrese tamaño de la pila …”);
int n=leer.nextInt();
int i1 = 0;
for(int i=0; i<n;i++){
System.out.println("Ingrese numero…");
i1=leer.nextInt();
pila.push(Integer.toString(i1));
}
System.out.println(i1);
System.out.println("Desapilar");
while(!pila.empty())
System.out.println(pila.pop());
}
}

4. verificar si una determinada sentencia o instrucción está equilibrada en cuanto a número

de paréntesis, corchetes o llaves de apertura y cierre. Cuando se escribe código de
programación si no existe equilibrio entre signos de apertura (por ejemplo un paréntesis de
apertura) y cierre (por ejemplo un paréntesis de cierre) ni siquiera debería procesarse la
sentencia ya que no estaría formalmente bien construida. De esto se encargan los
analizadores léxicos de los compiladores.

import java.util.Stack;

public class Programa {
    public static void main(String arg[]) {
            String cadenano = "(Cadena no equilibrada en paréntesis(()()()))))";
            String cadenasi = "(Cadena equilibrada en parentesis())";
            System.out.println("Verificación equilibrado en paréntesis para cadenano:");
            System.out.println(verificaParentesis(cadenano));
            System.out.println("Verificación equilibrado en paréntesis para cadenasi:");
            System.out.println(verificaParentesis(cadenasi));
    }
 
    public static boolean verificaParentesis(String cadena)  {
        Stack<String> pila = new Stack<String>();       int i = 0;
            while (i<cadena.length()) {  // Recorremos la expresión carácter a carácter
                if(cadena.charAt(i)=='(') {pila.push("(");} // Si el paréntesis es de apertura apilamos
siempre                               
                else if  (cadena.charAt(i)==')') {  // Si el paréntesis es de cierre actuamos según el
caso
                            if (!pila.empty()){ pila.pop(); } // Si la pila no está vacía desapilamos
                            else { pila.push(")"); break; } // La pila no puede empezar con un cierre,
apilamos y salimos
                }
                i++;
            }
            if(pila.empty()){ return true; } else { return false; }
    }
}