PROGRAMACION DE PILAS JAVA ORIENTACION DE OBJETOS.pdf

/1
1 / 1 1 / 2
PILAS
DEFINICIÓN.
Una pila es un tipo de estructura de datos en la que sólo se pueden INSERTAR y
ELIMINAR nodos en uno de los extremos del mismo. Estas operaciones se conocen
como “PUSH” y “POP” respectivamente. Además, las escrituras de datos siempre son
inserciones de nodos, y las lecturas siempre eliminan el nodo leído.
Estas características implican un comportamiento LIFO (Last In First Out), el último en
entrar es el primero en salir.
Ejemplo de este tipo de etructura es una pila de platos. Sólo es posible agregar platos
en la parte superior de la pila, y sólo pueden tomarse del mismo extremo.
En una pila es muy importante que nuestro programa nunca pierda el valor del puntero
al primer elemento.
Teniendo en cuenta que las inserciones y borrados en una pila se hacen siempre en un
extremo, lo que consideramos como el primer elemento de la Pila es en realidad el
último elemento de la pila.
OPERACIONES BÁSICAS CON PILAS
Las pilas sólo permiten las operaciones de “push” y “pop”:
 Push (Insertar): Agregar un elemento al final de la pila.
 Pop (Eliminar): Leer y eliminar un elemento del final de la pila.
INSERCIÓN DE ELEMENTOS EN LA PILA PUSH()
Las operaciones con pilas son muy simples, no hay casos especiales, salvo que la Pila
esté vacía.
a) INSERCIÓN EN UNA PILA VACIA
Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero
que apunte a él, además el puntero de la Pila valdrá NULO:
El proceso es muy simple, bastará con que:
1. nodo.siguiente apunte a NULO.
2. Pila apunte a nodo.
b) INSERCIÓN EN UNA PILA NO VACIA
Podemos considerar el caso anterior como un caso particular de éste, la única
diferencia es que podemos y debemos trabajar con una pila vacía como con
una pila normal.
De nuevo partiremos de un nodo a insertar, con un puntero que apunte a él, y
de una pila, en este caso no vacía:
El proceso sigue siendo muy sencillo:
1. Hacemos que nodo.siguiente apunte a Pila.
2. Hacemos que Pila apunte a nodo.
ELIMINACIÓN EN UNA PILA

/1
2 / 1 2 / 2
Ahora sólo existe un caso posible, ya que sólo podemos leer desde un extremo de la
pila (Tope). Partiremos de una pila con uno o más nodos, y usaremos un puntero
auxiliar, nodo:
1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila.
2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila.siguiente.
3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la
operación pop equivale a leer y borrar.
4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.
Si la pila sólo tiene un nodo, el proceso sigue siendo válido, ya que el valor de
Pila.siguiente es NULO, y después de eliminar el último nodo la pila quedará vacía, y el
valor de Pila será NULO.
EJEMPLO DE MANEJO DE PILAS EN JAVA
En el siguiente ejemplo se muestra el manejo de una pila que almacena un dato de
tipo entero.
********** CLASE Nodo.java **********
public class Nodo {
// Variable en la cual se va a guardar el valor.
private int valor;
// Variable para enlazar los nodos.
private Nodo siguiente;
/** Constructor en el que inicializamos el valor de las variables. */
public void Nodo(){
this.valor = 0;
this.siguiente = null;
}
// Métodos get y set para los atributos.
public int getValor() {
return valor;
}
public void setValor(int valor) {
this.valor = valor;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
}
********** CLASE Pila.java **********
public class Pila {
// Puntero que indica el inicio de la pila o tambiEn conocida como el TOPE de la pila.
private Nodo inicio;
// Variable para registrar el tamaño de la pila.
private int tamanio;
// Constructor por defecto.
public void Pila(){
inicio = null;
tamanio = 0;
}
/*Consulta si la pila es vacia. retorna true si el primer nodo (inicio) no apunta a otro */
public boolean esVacia(){
return inicio == null;
}
/** Consulta cuantos elementos (nodos) tiene la pila. retorna numero entero entre
[0,n] donde n es el numero de elementos que contiene la Pila. */

/1
3 / 1 3 / 2
public int getTamanio(){
return tamanio;
}
/** Agrega un nuevo nodo a la pila. parametro valor a agregar. */
public void apilar(int valor){
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Consulta si la pila esta vacia.
if (esVacia()) {
// Inicializa la pila con el nuevo valor.
inicio = nuevo;
}
// Caso contrario agrega el nuevo nodo al inicio de la pila.
else{
nuevo.setSiguiente(inicio);
inicio = nuevo;
}
// Incrementa el contador del tamaño.
tamanio++;
}
/** Elimina el elemento que se encuentra en el tope de la pila. */
public void retirar(){
if (!esVacia()) {
// Asigna como primer nodo al siguiente de la pila.
inicio = inicio.getSiguiente();
// Decrementa el contador del tamaño de la pila
tamanio--;
}
}
/* Consulta valor del nodo en la cima de la pila. retorna valor de nodo. */
public int cima() throws Exception{
if(!esVacia()){
return inicio.getValor();
} else {
throw new Exception("La pila se encuentra vacia.");
}
}
/** Busca un elemento en la pila. Parametro referencia valor del nodo a buscar.
retorna TRUE si el valor de referencia existe en la pila. */
public boolean buscar(int referencia){
// Crea una copia de la pila.
Nodo aux = inicio;
// Bandera para verificar si existe el elemento a buscar.
boolean existe = false;
// Recorre pila hasta encontrar el nodo o llegar al final de la pila.
while(existe != true && aux != null){
// Compara si el valor del nodo es igual que el de la referencia.
if (referencia == aux.getValor()) {
// Cambia el valor de la bandera.
existe = true;
}
else{
// Avanza al siguiente nodo.
aux = aux.getSiguiente();
}
}
// Retorna el valor de la bandera.
return existe;
}

/1
4 / 1 4 / 2
/** Elimina un nodo de la pila ubicado por su valor. parametro referencia valor de
referencia para ubicar el nodo. */
public void remover(int referencia){
// Consulta si el valor existe en la pila.
if (buscar(referencia)) {
// Crea una pila auxiliar para guardar los valores que se vayan desapilando de la pila
original.
Nodo pilaAux = null;
// Recorre la pila hasta llegar al nodo que tenga el valor igual que el de referencia.
while(referencia != inicio.getValor()){
// Crea un nodo temporal para agregarlos a la pila auxiliar.
Nodo temp = new Nodo();
// Ingresa el valor al nodo temporal.
temp.setValor(inicio.getValor());
// Consulta si la pila auxiliar no a sido inicializada.
if(pilaAux == null){
// Inicializa la pila auxiliar.
pilaAux = temp;
}
// Caso contrario si la pila auxiliar ya contiene elementos los agrega al inicio.
else{
temp.setSiguiente(pilaAux);
pilaAux = temp;
}
// Elimina el nodo del tope de la pila hasta llegar al nodo que se desea eliminar.
retirar();
}
// Elimina el nodo que coincide con el de referencia.
retirar();
// Regresa valores de pila auxiliar a pila original mientras pila auxiliar tenga elementos.
while(pilaAux != null){
// Utiliza el metodo apilar para regresar los elementos a la pila original.
apilar(pilaAux.getValor());
// Avansa al siguiente nodo de la pila auxiliar.
pilaAux = pilaAux.getSiguiente();
}
// Libera la memoria utilizada por la pila auxiliar.
pilaAux = null;
}
}
/* Actualiza valor de un nodo en la pila. parametro referencia valor del nodo para
ubicar el que se actualizará. parametro valor que remplazará el valor del nodo. */
public void editar(int referencia, int valor){
// Consulta si el nodo existe en la pila
if (buscar(referencia)) {
// Crea una pila auxiliar.
Nodo pilaAux = null;
// Recoore la pila hasta llegar al nodo que tenga el valor igual que el de referencia.
while(referencia != inicio.getValor()){
// Crea un nodo temporal para agregarlos a la pila auxiliar.
Nodo temp = new Nodo();
// Ingresa el valor al nodo temporal.
temp.setValor(inicio.getValor());
// Consulta si la pila auxiliar no a sido inicializada.
if(pilaAux == null){
// Inicializa la pila auxiliar.
pilaAux = temp;
}

/1
5 / 1 5 / 2
// Caso contrario si la pila auxiliar ya contiene elementos los agrega al inicio.
else{
temp.setSiguiente(pilaAux);
pilaAux = temp;
}
// Elimina el nodo del tope de la pila hasta llegar al nodo que se desea eliminar.
retirar();
}
// Actualiza el valor del nodo.
inicio.setValor(valor);
//Regresa valores de pila auxiliar a pila original mientras pila auxiliar tenga elementos.
while(pilaAux != null){
// Utiliza el metodo apilar para regresar los elementos a la pila original.
apilar(pilaAux.getValor());
// Avansa al siguiente nodo de la pila auxiliar.
pilaAux = pilaAux.getSiguiente();
}
// Libera la memoria utilizada por la pila auxiliar.
pilaAux = null;
}
}
/** Elimina la pila */
public void eliminar(){
// Elimina el valor y la referencia a los demas nodos.
inicio = null;
// Reinicia el contador a 0.
tamanio = 0;
}
/** Despliega en pantalla los elementos de la pìla. */
public void listar(){
// Crea una copia de la pila.
Nodo aux = inicio;
// Recorre la pila hasta el ultimo nodo.
while(aux != null){
System.out.println("|t" + aux.getValor() + "t|");
System.out.println("-----------------");
aux = aux.getSiguiente();
}
}
}
********** CLASE Main.java **********
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Pila pila = new Pila();
int dato;
Scanner lee = new Scanner(System.in);
System.out.println("<<-- Ejemplo de Pila -->>nn");
int op=0;
do {
System.out.println("Tamaño de la PILA----> "+pila.getTamanio());
System.out.println("<<-- MENU DE OPCIONES -->>nn");
System.out.println("1. Insertar dato en la PILA.n"
+ " 2. Eliminar de la PILA (Tope).n"
+ " 3. Modificar el valor de un NODOn"
+ " 4. Eliminar NODO con un valor específicon"
+ " 5. Buscar un valor en la PILAn"
+ " 6. Eliminar la PILA.n"
+ " 7. Verificar PILA vacian"
+ " 8. Mostrar PILAn"
+ " 0. Salirn");
System.out.print("Número de opción---> ");

/1
6 / 1 6 / 2
op=lee.nextInt();
switch (op) {
case 1:
System.out.println("Dato a introducir: ");
dato=lee.nextInt();
pila.apilar(dato);
break;
case 2:
pila.retirar();
break;
case 3:
int busca, inserta;
System.out.println("Dato a buscar---> ");
busca=lee.nextInt();
System.out.println("Dato a insertar---> ");
inserta=lee.nextInt();
pila.editar(busca, inserta);
break;
case 4:
System.out.println("Dato a eliminar ---> ");
pila.remover(busca);
break;
case 5:
System.out.println("Dato a buscar---> ");
System.out.println(pila.buscar(busca));
break;
case 6:
pila.eliminar();
break;
case 7:
System.out.println(pila.esVacia());
break;
case 8:
System.out.println("<<<<<< IMPRIMIENDO PILA >>>>>>");
System.out.println("Tamaño: "+pila.getTamanio());
pila.listar();
break;
}
}while (op!=0);
}
}
APLICACIONES DE LAS PILAS
Con la implementación de las pilas es posible el uso de la modularización
(recursividad). La variable que llama al mismo procedimiento en el que está, habrá
que guardarla así como el resto de variables de la nueva llamada, para a la vuelta
de la recursividad ir sacándolas, esto es posible a la implementación de pilas.
Las pilas también se utilizan en muchas aplicaciones que utilizamos con frecuencia. Por
ejemplo, la gestión de ventanas en Windows (cuando cerramos una ventana siempre
recuperamos la que teníamos detrás). Otro ejemplo es la evaluación general de
cualquier expresión matemática para evitar tener que calcular el número de variables
temporales que hacen falta.
Por ejemplo:
3 + 4 * (8 – 2 * 5)
EJERCICIOS PILAS
1. Escriba un programa que reciba una Pila P de números enteros y mueva sus
elementos a una nueva Pila, pero manteniendo el orden de salida de los mismos.
Al finalizar la Pila P no debe contener elementos.
2. Realizar un programa que cuente la cantidad de elementos de una pila. La
estructura debe quedar en el estado original.
3. Realizar un procedimiento que invierta el orden de una pila.
4. Realizar un procedimiento que saque el elemento N de una pila. Tener en
cuenta que los demás elementos deben quedar en el mismo orden.

/1
7 / 1 7 / 2
5. Realizar un procedimiento que ingrese un elemento en la posición N de una pila.
Tener en cuenta que los demás elementos deben quedar en el mismo orden.
6. Escriba una rutina que reciba una Pila P de números enteros y mueva sus elementos
a una nueva Pila, pero invirtiendo el orden de salida de los mismos. Al finalizar la
Pila P no debe contener elementos.
7. Escriba una rutina que reciba dos Pilas P1 y P2 de números flotantes y apile las
mismas en una nueva Pila resultante. Es de destacar que las Pilas recibidas no
deben sufrir ningún tipo de cambio o alteración.
8. Escriba una rutina que reciba dos Pilas P1 y P2 de números enteros y proceda a
intercambiar sus elementos, pero manteniendo el orden de salida de los
elementos. Al finalizar la rutina, la Pila P1 tendrá los elementos de la Pila P2 y esta
a su vez tendrá los elementos de la Pila P1.
9. Escriba una rutina que reciba una Pila P de números enteros y devuelva una copia
exacta de lamisma. Es de destacar que la Pila P no debe sufrir ningún tipo de cambio
o alteración.
10.Escriba una rutina que reciba una Pila P de números flotantes y devuelva una nueva
Pila pero con los elementos invertidos, es decir el último de la Pila P, pasará a ser el
primero de la nueva Pila Es de destacar que la Pila P no debe sufrir ningún tipo de
cambio o alteración.
11.Escriba una rutina que reciba una Pila P de números flotantes y devuelva otra pila,
manteniendo el orden de salida de los elementos. Es de destacar que la Pila P no
debe sufrir ningún tipo de cambio o alteración.
12.En un archivo f están almacenados números enteros arbitrariamente grandes. La
disposición es tal que hay un número entero por cada línea de F. Escribir un
programa que muestre por pantalla la suma de todos los números enteros. Al
resolver el problema habrá que tener en cuenta que, al ser enteros grandes, no
pueden almacenarse en variables numéricas.
13.Utilizar dos pilas para guardar los dos primeros números enteros, almacenándose
digito a dígito. Al extraer los elementos de la pila, salen en orden inverso y, por lo
tanto, de menor peso a mayor peso; se suman digito con digito y el resultado se
guarda en una cola, también digito a digito. A partir de este primer paso se obtienen
el siguiente número del archivo, se guarda en una pila y, a continuación, se suma
digito a dígito con el número que se encuentra en la cola; el resultado se guarda en
otra cola. El proceso se repite, nuevo número del archivo se mete en la pila, que se
suma con el número actual de la cola.

PROGRAMACION DE PILAS JAVA ORIENTACION DE OBJETOS.pdf

Más contenido relacionado

Similar a PROGRAMACION DE PILAS JAVA ORIENTACION DE OBJETOS.pdf (20)

Último (9)

PROGRAMACION DE PILAS JAVA ORIENTACION DE OBJETOS.pdf