sábado, 25 de junio de 2011

PILAS (PROGRAMACION):

Una pila es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO  que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de programación debido a su simplicidad y ordenación implícita de la propia estructura. También se puede decir que la pila 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 extremo se llama ``la parte superior'' de la pila.

OPERADORES:


Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.
  • Crear: se crea la pila vacía.
  • Apilar: se añade un elemento a la pila.(push)
  • Desapilar: se elimina el elemento frontal de la pila.(pop)
  • Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
  • Vacía: devuelve cierto si la pila está vacía o falso en caso contrario.

    viernes, 24 de junio de 2011

    EJEMPLOS:


    • Estos son ejemplos sencillos de una pila con las siguientes operaciones:

    EN PYTHON

    class Stack(object):
        def __init__(self):
            self.stack_pointer = None
     
        def push(self, element):
            self.stack_pointer = Node(element, self.stack_pointer)
     
        def pop(self):
            e = self.stack_pointer.element
            self.stack_pointer = self.stack_pointer.next
            return e
     
        def peek(self):
            return self.stack_pointer.element
     
        def __len__(self):
            i = 0
            sp = self.stack_pointer
            while sp:
                i += 1
                sp = sp.next
            return i
     
    class Node(object):
        def __init__(self, element=None, next=None):
            self.element = element
            self.next = next
     
    if __name__ == '__main__':
        # small use example
        s = Stack()
        [s.push(i) for i in xrange(10)]
        print [s.pop() for i in xrange(len(s))] 

    • PILA CON PUNTEROS EN C++

    #include<stdio.h>
    #include<conio.h>
     
    #define TAM 6
    #define MAX TAM-1
     
    typedef struct
    {
       int tope;
       int item[TAM];
    }pila;
     
     
    int full(pila *);
    int empty(pila *);
    void push(pila *, int);
    void pop(pila *,int *);
     
     
    void main()
    {
       pila p,t;
       int dato,opc,elemento,flag=0;
       p.tope=0;
       do
       {
          clrscr();
          printf("\nMENU-PILA");
          printf("\n1-> Insertar elemento");
          printf("\n2-> Eliminar elemento");
          printf("\n3-> Eliminar elemento X");
          printf("\n4-> Visualizar");
          printf("\n5-> Salir");
          printf("\n\nDe su opci¢n : ");
          scanf("%d",&opc);
          switch(opc)
          {
             case 1:
             if(!full(&p)) // si pila no esta llena
             {
             printf("\nDe el elemento a insertar: ");
             scanf("%d",&dato);
             push(&p,dato);
             printf("\nElemento insertado...");
             }
             else
             {
             printf("\nERROR: Pila llena");
             }
             break;
     
             case 2:
             if(!empty(&p))
             {
             pop(&p,&dato);
             printf("\nEl elemento eliminado es %d",dato);
             }
             else
             {
             printf("\nERROR: Pila vac¡a");
             }
             break;
     
            case 3:
             if(!empty(&p))
             {
             printf("eliminar elemento seleccionado: ");
             scanf("%d",&elemento);
     
            if(p.tope != 1){
             t.tope=0;
             do
             {
             pop(&p,&dato);
                     if (dato != elemento)
                     {                 
                     push(&t,dato);
                     } 
             }while(!empty(&p));
     
             do
             {
                     pop(&t,&dato);    
                     push(&p,dato);
             }while(!empty(&t));
             }
             else if(dato == elemento){pop(&p,&dato);}
                   else {printf("el elemento no se encuentra en la pila");}
             }
             else
             {
             printf("\nERROR: Pila vac¡a");
             }
             break;
     
     
             case 4:
             if(!empty(&p))
             {
             t.tope=0;
             do
             {
                     pop(&p,&dato);
                     printf("\n%d",dato);
                     push(&t,dato);
             }while(!empty(&p));
             do
             {
                     pop(&t,&dato);
                     push(&p,dato);
             }while(!empty(&t));
             }
             else
             {
             printf("\nERROR: Pila vac¡a");
             }
             break;
             case 5:
             flag=1;
             break;
             case 6:
             flag=0;
             break;
     
             default:
             printf("\nOpci¢n no v lida...");
          }
          if(!flag)
          {
             printf("\n\nPresione una tecla para continuar...");
             getch();
          }
       }while(!flag);
     
    }
     
    int full(pila *p)
    {
       return(p->tope==MAX);
    }
     
    int empty(pila *p)
    {
       return(p->tope==0);
    }
     
    void push(pila *p,int dato)
    {
       if(!full(p))
       {
          (p->tope)++;
          p->item[p->tope]=dato;  //elemento[1]=dato
       }
       else
          printf("\nOVERFLOW");
    }
     
    void pop(pila *p,int *dato)
    {
       if(!empty(p))
       {
          *dato=p->item[p->tope];
          (p->tope)--;
       }
       else
          printf("\nUNDERFLOW");
       }