PILAS

EJERCICIO 01:
/*
1. Elaborar un programa en java que permita el ingreso de un número correspondiente a
la cantidad de términos de la sucesión de fibonacci que se obtendrán, para luego
mostrar dichos valores en pantalla en forma INVERTIDA.
Controlar que ‘n’ pertence [5,25]
*/
/*TAREAS
1. Ingresar tamaño de la pila.
2. Generar Pila.
3. Mostrar Pila.
*/

CLASES
CLASE APLICACION
public class Aplicacion {
Pila pila;
public Aplicacion() {
pila = new Pila();
}
public static void main(String[] args) {
Aplicacion ap;
int n;
ap = new Aplicacion();
n = ap.ingresarTamaño(5, 25, "Ingrese el valor n: ");
ap.generarPila(n);
ap.mostrarResultados();
}
public int ingresarTamaño(int a, int b, String c) {
Scanner scanner;
int n;
scanner = new Scanner(System.in);
do {
System.out.println(c);
n = scanner.nextInt();
} while (n < a || n > b);
return n;
 }
public void generarPila(int n) {
Nodo nodo;
int a, b, i, temp;
a = 0;
b = 1;
for (i = 0; i < n; i++) {
nodo = new Nodo(a);
pila.push(nodo);
temp = a;
a = b;
b = temp + b;
}
}
public void mostrarResultados() {
pila.mostrarPila();
}
}
CLASE NODO
public class Nodo {
int valor;
Nodo sig;
public Nodo(int valor) {
this.valor = valor;
this.sig = null;
}
public void mostrarNodo() {
System.out.println("Número: " + valor);
}
}
CLASE PILA
public class Pila {
Nodo cab;
public Pila() {
cab = null;
}
public void push(Nodo p) {
if (p != null) {
p.sig = cab;
cab = p;
}
}
public Nodo pop() {
 Nodo p;
p = cab;
if (cab != null) {
cab = cab.sig;
p.sig = null;
}
return p;
}
public void mostrarPila() {
Nodo p;
p = cab;
while (p != null) {
p.mostrarNodo();
p = p.sig;
}
}
}
EJERCICIO 02:
/*
2. Elaborar un programa en JAVA que reciba el ingreso de una cadena de caracteres por
el teclado y luego la muestre en pantalla de manera INVERTIDA.
*/
/*TAREAS
1. Ingresar Cadena
2. Apilar caracteres
3. Mostrar resultados
*/

CLASES
CLASE APLICACION
public class Aplicacion {
Pila pila;
public Aplicacion() {
pila = new Pila();
}
public static void main(String[] args) {
Aplicacion ap;
String cadena;
ap = new Aplicacion();
 cadena = ap.solicitarCadena("Ingrese una cadena:");
ap.apilarCaracteres(cadena);
ap.mostrarCadenaInvertida();
}
public String solicitarCadena(String mensaje) {
Scanner entrada;
String cadenTexto;
entrada = new Scanner(System.in);
System.out.println(mensaje);
cadenTexto = entrada.nextLine();
return cadenTexto;
}
public void apilarCaracteres(String cadena) {
int i;
char caracter;
Nodo p;
for (i = 0; i < cadena.length(); i++) {
caracter = cadena.charAt(i);
p = new Nodo(caracter);
pila.push(p);
}
}
public void mostrarCadenaInvertida() {
System.out.println("Lista de caracteres:");
pila.mostrarPila();
}
}
CLASE NODO
public class Nodo {
char caracter;
Nodo sig;
public Nodo(char caracter) {
this.caracter = caracter;
this.sig = null;
}
public void mostrarNodo() {
System.out.println(caracter);
}
}
CLASE PILA
public class Pila {
Nodo cab;
public Pila() {
 cab = null;
}
public void push(Nodo p) {
if (p != null) {
p.sig = cab;
cab = p;
}
}
public Nodo pop() {
Nodo p;
p = cab;
if (cab != null) {
cab = cab.sig;
p.sig = null;
}
return p;
}
public void mostrarPila() {
Nodo p;
p = cab;
while (p != null) {
p.mostrarNodo();
p = p.sig;
}
}
}
EJERCICIO 03:
/*
3. Elaborar en JAVA que reciba una expresión aritmética en notación postfija como
cadena y la procese usando la pila para obtener el resultado que será mostrado en
pantalla.
Considerar que se colocan en la cadena solo números de un dígito.
*/
/*TAREAS
1. Recibir cadena.
2. Procesar la cadena.
3. Mostrar resultados.
*/

CLASES
CLASE APLICACION
public class Aplicacion {
Pila pila;
public Aplicacion() {
pila = new Pila();
}
public static void main(String[] args) {
Aplicacion ap;
String texto;
ap = new Aplicacion();
texto = ap.solicitarCadena("Ingrese la expresión a resolver: ");
ap.procesarCadena1(texto);
ap.mostrarResultados();
}
// 78*67/-48/3*+1-14/+
public String solicitarCadena(String text) {
Scanner scanner;
String dato;
scanner = new Scanner(System.in);
System.out.println(text);
dato = scanner.nextLine();
return dato;
}
public void procesarCadena1(String cadena) {
int i;
boolean resul;
char caracter;
for(i=0; i<cadena.length();i++){
caracter = cadena.charAt(i);
System.out.println("carcater: "+caracter);
resul = verificarNum(caracter);
if(resul){ // caracter es un número
apilarValor(caracter);
}else{ // caracter es un operador
operarValores(caracter);
}
}
}
public void apilarValor(char caracter) {
Nodo p;
float num;
num = caracter - '0';
p = new Nodo(num);
 pila.push(p);
}
public void operarValores(char caracter){
Nodo desapilado, p;
float a, b, c;
desapilado = pila.pop();
a = desapilado.getNum();
desapilado = pila.pop();
b = desapilado.getNum();
c = efectuarValores(a, b, caracter);
p = new Nodo(c);
pila.push(p);
pila.mostrarPila();
System.out.println("------------------");
}
public float efectuarValores(float a, float b, char operador){
float c;
c = 0;
switch(operador){
case '+':
c = a + b;
break;
case '-':
c = a - b;
break;
case '*':
c = a*b;
break;
case '/':
c = a/b;
break;
}
return c;
}
public boolean verificarNum(char c) {
boolean resul;
resul = false;
if (c >= '0' && c <= '9') {
resul = true;
}
return resul;
}
public void mostrarResultados() {
Nodo p;
 p = pila.pop();
if (p != null) {
System.out.println("Resultado de la expresión: ");
p.mostrarNodo();
System.out.println(" ");
}
}
}
CLASE NODO
public class Nodo {
float num;
Nodo sig;
public Nodo(float num) {
this.num = num;
this.sig = null;
}
public float getNum() {
return num;
}
public void mostrarNodo() {
System.out.println(num);
}
}
CLASE PILA
public class Pila {
Nodo cab;
public Pila() {
this.cab = null;
}
public void push(Nodo p) {
if (p != null) {
p.sig = cab;
cab = p;
}
}
public Nodo pop() {
Nodo p;
p = cab;
if (cab != null) {
cab = cab.sig;
p.sig = null;
}
return p;
 }
public void vaciarPila() {
Nodo p;
p = cab;
while (p != null) {
p = pop(); // cuando no contenga elementos la pila, p será nulo
}
}
public void mostrarPila() {
Nodo p;
p = cab;
while (p != null) {
p.mostrarNodo();
p = p.sig;
}
}
}