Que es una Pilas en informatica?
Pila:
Una pila es una estructura de datos a la cual se puede acceder solo por un extremo de la misma. Las operaciones de inserción y extracción se realizan a través del tope, por lo cual no se puede acceder a cualquier elemento de la pila. Se la suele llamar estructura L.I.F.O. como acrónimo de las palabras inglesas "last in, first out" (último en entrar, primero en salir). La pila se considera un grupo ordenado de elementos, teniendo en cuenta que el orden de los mismos depende del tiempo que lleven "dentro" de la estructura.
Las pilas son frecuentemente utilizadas en el desarrollo de sistemas informáticos y software en general. Por ejemplo, el sistema de soporte en tiempo de compilación y ejecución del Pascal utiliza una pila para llevar la cuenta de los parámetros de procedimientos y funciones, variables locales, globales y dinámicas. Este tipo de estructuras también son utilizadas para traducir expresiones aritméticas o cuando se quiere recordar una secuencia de acciones u objetos en el orden inverso del ocurrido.
Dada la definición teórica de una pila, podremos representar la misma en forma gráfica como se ve en la figura:
La pila recién creada se encuentra 1 TOPE
vacía, el tope apunta a nil.
Se desean ingresar los elementos 5
1, 5 y 7 en ese orden.
7 nil
TOPE
El elemento '1' se ubica en (Se ve claramente como los elemento
el "fondo" de la pila, mien- 5 se ingresan por "arriba" y se van
tras que el siguiente, el '5', "apilando".)
se ubica "sobre" él. 1
nil
7 TOPE
Luego de dicha operación El tope apunta al elemento de
la pila puede representarse 5 "arriba", y el enlace se realiza
como en la figura. Así de- desde él hacia el "fondo".
cimos que se encuentra 1
"llena"
nil
Podemos de esta manera observar claramente que para obtener el elemento '5' que ingresamos anteriormente, al poder acceder únicamente a la pila por el tope (la parte "superior"), debemos retirar antes los elementos que se encuentren antes o "sobre" él. De ésta manera la acción de retirar elementos de la estructura podemos graficarla de la siguiente forma:
TOPE
Así, entonces, queda la elemento
pila al retirar los elementos 5 retirado
en forma secuencial. 7
1 nil
El tope apunta al siguiente del elemento retirado. Si se quiere continuar retirando los elementos que se ingresaron con anterioridad, la pila quedará completamente vacía, y se ve claramente como los elementos se van repitiendo en el orden inverso en que se habían ingresado. Finalmente, cuando la pila se encuentre vacía, el tope apuntará a nil.
5
TOPE se retiran los elementos
1 en forma secuencial.
nil
7
elemento retirado
Ahora bien, una vez conocido el comportamiento de las pilas veremos como se definen las mismas y su forma de manejo, o "comportamiento" de la pila.
Definición dinámica de una pila:
Las operaciones que definen el comportamiento de una pila o primitivas son las siguientes:
Crear pila.
Insertar elemento.
Retirar elemento.
Pila vacía.
Vaciar pila.
La definición junto con la implementación de éste tipo de estructura, es conveniente realizarlas en una unidad de biblioteca, de este modo se mantiene el nivel de abstracción de la estructura.
Unit Pilas;
Interface
type
tipo_dato = <dato a almacenar>;
tptr_nodo_pila = ^tnodo_pila
tnodo_pila = record
dato : tipo_dato;
enlace : tptr_nodo_pila;
end;
{encabezamiento de las primitivas que utilizaremos en el tipo de dato PILA}
Procedure Pila_crear (var pila : tptr_nodo_pila);
{Pre: La pila nunca fue creada.
Post: Se creo la pila y se encuentra vacía}
Procedure Pila_insertar (var pila : tptr_nodo_pila; elem : tipo_dato; var error : boolean);
{Pre: La pila existe.
Post: Si error = false el elemento fue ingresado en el tope de la pila, si error = true no se ha ingresado el elemento, la pila se encuentra llena}
Procedure Pila_retirar (var pila : tptr_nodo_pila; var elem : tipo_dato);
{Pre:La pila fue creada y no está vacia.
Post: El elemento del tope de la pila fue retirado y se encuentra en elem, la pila queda igual, sin el elemento que se encontraba en el tope}
Procedure Pila_vaciar (var pila : tptr_nodo_pila);
{Pre: La pila fue creada.
Post: La pila se encuentra vacía}
Function Pila_vacia (pila : tptr_nodo_pila);
{Pre: La pila fue creada.
Post: Devuelve true si la pila se encuentra vacía, y sino false}
Implementation
Procedure Pila_crear (var pila : tptr_nodo_pila);
begin
pila := nil;
end;
Procedure Pila_insertar (var pila : tptr_nodo_pila; elem : tipo_dato; var error : boolean);
var ptr_aux : tptr_nodo_pila; {se utiliza para insertar el nuevo elemento}
begin
error:= Maxavail < sizeof(tnodo_pila);
if ( not error) then
begin
new (ptr_aux);
ptr_aux^.dato := elem;
ptr_aux^.enlace := pila;
pila := ptr_aux;
end
end;
Procedure Pila_retirar (var pila : tptr_nodo_pila; var elem : tipo_dato);
var ptr_aux : tptr_nodo_pila; {se utiliza para eliminar el elemento que se encuentra en}
{el tope}
begin
ptr_aux := pila;
elem := pila^.dato;
pila := pila^.enlace;
dispose (ptr_aux);
end;
Procedure Pila_vaciar (var pila : tptr_nodo_pila);
var e : tipo_dato;
begin
while not(Pila_vacía(pila)) do
Pila_retirar (pila,e)
end;
Function Pila_vacia (pila : tptr_nodo_pila);
begin
Pila_vacía := (pila = nil);
end;
<begin>
end.
De esta manera la pila, queda definida y lista para su utilización.
No hay comentarios:
Publicar un comentario