ProgramacionFacil

PILAS (STACK)

Una pila (stack en inglés) es una estructura de datos de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura. Representación gráfica de una pila

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.

En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apliado (denominado TOS, top of stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.

Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.

Las pilas suelen emplearse en los siguientes contextos:

Ejemplo

Forma principal

:estructura_datos_csharp:principal.jpg

Procedimiento: Inserción de un elemento en Pila

Algoritmo


Insercion(Pila, Cima, Elemento)

1. [¿Pila llena?]

Si Cima = MaxPila, entonces:

- Escribir: Desbordamiento (Overflow) y Volver

Cima = Cima + 1;

Pila[Cima] = Elemento


Código

 
 
void CmdInsercionClick(object sender, EventArgs e)
        {
            string elemento = txtElemento.Text;
            txtElemento.Text = "";
            txtElemento.Focus();
 
            if (frmPrincipal.Cima == frmPrincipal.MaxPila)
            {
                MessageBox.Show("Pila llena (Overflow)");
                return;
            }
 
            frmPrincipal.Cima = frmPrincipal.Cima + 1;
            frmPrincipal.Pila[frmPrincipal.Cima] = elemento; // Inserta elemento en Pila
        }

Corrida

:estructura_datos_csharp:insercion.jpg

Procedimiento: Recorrido de elementos en Pila

Algoritmo


RECORRIDO(Pila, Top)

1. Apuntador = Top

2. repetir paso 3 mientras Apuntador != nulo

3. imprimir Pila(Apunatdor)

4. Apuntador = Apuntador - 1.

Fin del ciclo.

5. Salir.


Código

 
void CmdRecorrerClick(object sender, EventArgs e) 
            { 
 
                  // Verifica si la Pila esta vacia 
                  if (frmPrincipal.Cima == -1) 
                  { 
                        MessageBox.Show("Pila Vacia (Underflow)"); 
                        return; 
                  } 
                  int i = 0; 
                  do 
                  { 
                        lsRecorrer.Items.Add(frmPrincipal.Pila[i]); 
                        i = i + 1; 
                  } while (i <= frmPrincipal.Cima); 
            }

Corrida

:estructura_datos_csharp:recorrido.jpg

Procedimiento: Búsqueda de un elemento en Pila

Algoritmo


BUSQUEDA(Pila, Top, Elemento)

1. Si Top != Nulo

Apuntador = Top

2. Repetir mientras Apuntador != Nulo

3. Si Pila[Apuntador] = Elemento

Imprimir “El Dato fue encontrado” y Salir

Apuntador = Apuntador - 1

Fin del ciclo

Si no:

Imprimir “El Dato no se encontró”

4. Salir.


Código

 
void CmdBuscarClick(object sender, EventArgs e) 
 
            { 
                  string elemento = txtElemento.Text; 
                  txtElemento.Text = ""; 
                  txtElemento.Focus(); 
                  // Verifica si la pila esta vacia 
                  if (frmPrincipal.Cima == -1) 
                  { 
                        MessageBox.Show("Pila vacia (Underflow)"); 
                        return; 
                  } 
                  int i = 0; 
                  do 
                  { 
                        int res = string.Compare(elemento,frmPrincipal.Pila[i]); 
                        if (res == 0) 
                        { 
                             lsRes.Items.Add(frmPrincipal.Pila[i]); 
                             return; 
                        } 
                        i = i + 1; 
                  } while (i <= frmPrincipal.Cima); 
                  MessageBox.Show("Elemento no encontrado en Pila"); 
            }

Corrida

:estructura_datos_csharp:busqueda.jpg

Procedimiento: Eliminación de elemento en Pila

Algoritmo


Eliminar(Pila, Cima, Elemento)

1. [¿Pila Vacía?]

Si Cima = -1, entonces:

Escribe: Subdesbordamiento (Underflow)

2. Elemento = Pila[Cima]

3. Cima = Cima - 1


codigo

 
void CmdEliminarClick(object sender, EventArgs e)
        {
            if (frmPrincipal.Cima == -1)   
            {
                MessageBox.Show("Pila Vacia (Underflow)");
                return;
            }
 
            string Elemento = frmPrincipal.Pila[frmPrincipal.Cima];
            frmPrincipal.Cima = frmPrincipal.Cima - 1;
            lsEliminados.Items.Add(Elemento);
        }

Corrida

:estructura_datos_csharp:eliminacion.jpg

 




 


Recent changes RSS feed Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki

Politica de Privacidad