lunes, 17 de octubre de 2011

PILAS

DEFINICION
·        Una pila (stack) es una colección ordenada de elementos en la cual se pueden insertar nuevos elementos por un extremo y se pueden retirar otros por el mismo extremo; ese estremos se llama ``la parte superior'' de la pila.

·        Pila es una estructura de datos en la que la inserción y la extracción de elementos se realiza sólo por un extremo que se denomina cabeza. como consecuencia, los elementos de una pila serán eliminados en orden inverso al que se insertaron. es decir, el último elemento que se metió en la pila será el primero en salir de ella.
Debido al orden en que se insertan y eliminan los elementos en una pila, también se le conoce como estructura lifo (last in, first out: último en entrar, primero en salir).

TIPOS DE PILA
Estáticas y dinámicas

Estáticas.- Los espacios que creaste en tu arreglo son los que puedes usar para insertar elementos, no puedes agregar más.
Dinámicas.- En este tipo de pila vas agregando espacios como lo requieras.

OPERACIONES BÁSICAS
Las principales operaciones que podemos realizar en una pila son:
  • Insertar un elemento (push).
  • Eliminar un elemento (pop).
Los algoritmos para realizar cada una de estas operaciones se muestran a continuación. La variable máxima para hacer referencia al máximo número de elementos en la pila.


Inserción (Push)
 
            si sp=máximo entonces
                     mensaje (overflow)
            en caso contrario
                     sp<-- sp+1
                     pila[sp]<-- valor






Eliminación (Pop)
 
            si sp=0 entonces
                    mensaje (underflow)
            en caso contrario
                     x<--pila[sp]
                     sp<--sp-1

 
APLICACIONES CON PILAS
·        Llama a subprogramas.
·        Recursividad.
·        Tratamiento de expresiones aritméticas.
·        Ordenación.
·        Proporcionan un medio ordenado de demorar la realización de las
tareas secundarias que aparecen
durante la ejecución del programa.
·        Suelen ir asociadas a algoritmos recursivos.
·        Tipos derivados: pilas de programas, pila del analizador sintáctico (parser)

Ejemplos cotidianos
         Pila de platos
         Pila de discos

PROGRAMAS
public class Pila
{
               int tope=-1;
               int vec[];
 
               Pila(int max)
               {
                               vec=new int [max];
               }
               public boolean llena()
               {
                if (tope==vec.length-1)
                       return true;
                               else
                                       return false;
               }
               public boolean vacia()
               {
                               if (tope==-1)
                                              return true;
                               else
                                              return false;
               }
               public void push(int dato)
               {
                               if (llena()== true)
                       System.out.println("Overflow");
                               else
                               if (tope==-1)
                       { 
                               tope=0;
                        vec[tope]=dato;
                }
                else
                {
                        tope++;
                        vec[tope]=dato;
                }                
               }      
               public int pop()
               {
                     int aux;
                     if (vacia()==true)
                     {  
                               System.out.println("La pila esta vacia");
                                       return -1;
                     }
                     else
                     { 
                               aux=vec[tope];
                                       tope--;
                     }
                                     return aux;
                     }  
        public void Imprime_Datos()
        {
                if(vacia()==true)
                {
                        System.out.println("La pila esta vacia, ingrese datos primero:");
                }
                else                        
                        for(int Contador=0;Contador<vec.length;Contador++)
                                System.out.println("Los valores son:"+vec[Contador]);
        }
}

Programas en clase
package pilas;
import java.util.Scanner;
/**
 *
 * @author ALUMNO
 */
public class PilaEstatica {
    public static void main(String[] args) {
        int dato;
        int pila[]=new int[5];
        Scanner captura=new Scanner(System.in);
        for(int tope=0;tope<5;tope++)
        {
            System.out.println("proprcione datos para pila");
            dato=captura.nextInt();
            pila[tope]=dato;

        }
        for (int tope=5;tope>=0;tope--)
            System.out.println("la pila tiene los siguientes datos:"+pila[tope]);
    }

}

Videos