Video pilas

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.

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");
   }