jueves, 18 de octubre de 2012

Cola en Informática

Lectura de apoyo

 Una cola es una colección de elementos homogéneos (almacenados en dicha estructura), en la misma se pueden insertar elementos por uno de los extremos, llamado frente, y retirar los mismos por el otro extremo, denominado final.


Es importante aclarar que, tanto el frente como el final de la cola, son los únicos indicados para retirar e insertar elementos, respectivamente. Esto nos indica que no podemos acceder directamente a cualquier elemento de la cola, sino solo al primero, o sea el que está o se encuentra en el frente, y no se pueden insertar elementos en cualquier posición sino solo por el final, así el elemento insertado queda como último.


Por esta razón la cola es denominada una estructura F.I.F.O., o simplemente una lista F.I.F.O., esto representa el acrónimo de las palabras inglesas “first in, first out” (primero en entrar, primero en salir). Gráficamente podemos representarla como:

 La cola fue recién creada y esta vacía. (frente y final apuntan FINAL FRENTE a nil).



Si ahora le ingresamos el elemento A, la misma quedará se la siguiente manera:

 Como A  es el único A  elemento, frente y final apuntan a él. FINAL nil FRENTE

 Si a continuación se ingresa el elemento B, el frente de la cola continuará apuntando a A, pero ahora el final apuntará al elemento recién ingresado.

B A  El enlace se realiza desde el frente hacia el final. FINAL nil FRENTE

 Al retirar un elemento, el frente apuntará al siguiente del elemento retirado y en el caso que la cola quedara vacía, frente y final apuntarán a nil.

B A elemento retirado. FINAL nil FRENTE



FINAL FRENTE


nil nil

Ahora bien, una vez conocido el comportamiento de las colas veremos como se definen las mismas y su forma de manejo, o "comportamiento" de la cola.

Para trabajar con una cola, así como para cualquier tipo de estructura abstracta, tendremos que definir las operaciones que representen el comportamiento de la misma, para de esta manera poder utilizarlas. Dichas operaciones son:

Crear cola.

Insertar elemento.

Retirar elemento.

Cola vacía.

Vaciar cola.

Podemos definir una cola en forma dinámica implementándola como una lista simple y respetando las restricciones de inserción (sólo se puede realizar a través del final) y extracción (sólo se puede realizar por el frente).

A partir de la definición dada, podremos implementar una estructura de tipo cola en una unidad de biblioteca de la siguiente manera.

Unit Colas;

interface

type

 tipo_dato = <dato a almacenar>;

 ptr_nodo_cola = ^tnodo_cola;

tnodo_cola = record

 dato : tipo_dato;

 enlace : ptr_nodo_cola;

 end;

 tipo_cola = record

 frente,

 final : ptr_nodo_cola;

 end;

{encabezamiento de las primitivas que utilizaremos en el tipo de dato COLA}

Procedure Cola_crear (var Cola : tipo_Cola);

{Pre: La cola nunca fue creada.

Post: Se creo la cola y se encuentra vacía}

Procedure Cola_insertar (var Cola : tipo_cola; elem : tipo_dato; var error : boolean);

{Pre: La Cola existe.

Post: Si error = false el elemento fue ingresado en el final de la Cola, si error = true no se ha ingresado el elemento, la Cola se encuentra llena}


Procedure Cola_retirar (var Cola : tipo_cola; var elem : tipo_dato);

{Pre:La Cola fue creada y no está vacia.

Post: El elemento del frente de la Cola fue retirado y se encuentra en elem, la Cola queda igual, sin el elemento que se encontraba en el frente}


Function Cola_vacia (Cola : tipo_cola);

{Pre: La Cola fue creada.

Post: Devuelve true si la Cola se encuentra vacía, y sino false}

Procedure Cola_vaciar (var Cola : tipo_cola);

{Pre: La Cola fue creada.

Post: La Cola se encuentra vacía}

Implementation

Procedure Cola_crear (var Cola : tipo_Cola);

begin

 cola.frente := nil;

 cola.final := nil;

end;

Procedure Cola_insertar (var Cola : tipo_cola; elem : tipo_dato; var error : boolean);

var ptr_aux : ptr_nodo_cola;

begin

 error:= Maxavail < sizeof(tnodo_cola);

 if (not error) then

 begin

 new (ptr_aux);

ptr_aux^.dato := elem;

 ptr_aux^.enlace := nil;

 if (Cola_vacía (cola)) then cola.frente := ptr_aux

 else cola.final^.enlace := ptr_aux;

 cola.final := ptr_aux;

 end

end;

Procedure Cola_retirar (var Cola : tipo_cola; var elem : tipo_dato);

var ptr_aux : ptr_nodo_cola;

begin

 ptr_aux := cola.frente;

 cola.frente := cola.frente^.enlace;

 if (cola.frente = nil) then cola.final := nil;

 elem := ptr_aux^.dato;

 dispose (ptr_aux);

end;

Function Cola_vacia (Cola : tipo_cola);

begin

 Cola_vacía := (cola.frente=nil) and (cola.final=nil);

end;

Procedure Cola_vaciar (var Cola : tipo_cola);

var e: tipo_dato;

begin

 while not(Cola_vacía(cola)) do

Cola_retirar(cola,e);

end;

<begin>

end.

Existen además del tipo de cola arriba definido, otros que tienen distintas utilidades según el requerimiento del programador, por ejemplo, la cola de prioridad.

Cola de prioridad:

 Una cola de prioridad es una estructura característica, donde se pude retirar e insertar un ítem teniendo en cuenta la clave más grande o más chica (según la implementación) definida por el programador. Si los ítems tienen claves iguales, entonces la regla usual utilizada es que el primer ítem insertado es el que se retirará primero.

Algunas aplicaciones de éste tipo de estructura son: la representación simulada de eventos dependientes del tiempo, como por ejemplo el funcionamiento de un aeropuerto, controlando partidas y aterrizajes de aviones. Otro ejemplo puede verse en los sistemas informáticos, el CPU asigna prioridades a las distintas tareas que debe ejecutar y las inserta en su cola, para de esta manera realizarlas en el orden correcto (multitareas).

Podemos representar una cola de prioridad como una lista contigua ordenada, en la cual retirar un ítem es una operación inmediata, pero la inserción tomaría un tiempo proporcional al número de elementos que se encuentren en la cola, hay que tener en cuenta que dicha operación se debe realizar en forma tal que la cola quede ordenada. Otra forma de representación es a través de una lista desordenada, en la cual el proceso de inserción es inmediato, pero el de extracción es muy lento, ya que debo recorrer toda la cola para encontrar el ítem que debo retirar.

Ejemplos de Las pilas En Informática




Lectura de apoyo







Aquí finaliza el tema de la gestión dinámica de memoria. Es un tema algo complejo hasta que se asimila el concepto y funcionamiento de las diferentes estructuras, pero tras conseguirlo ya no tiene ningún secreto. Si alguna vez no recuerdas su funcionamiento siempre es una buena solución coger papel y lápiz, dibujar una pila, cola o lista gráficamente y simular la introducción de elementos, escribiendo la situación de los punteros en cada momento.

      Existen otras estructuras, como las listas doblemente enlazadas. La única diferencia con la lista que conocemos es que en las primeras cada elemento guarda la dirección del anterior y del posterior. Sería una estructura como esta:
    struct lista_doble
    {
        char nombre[20];
        struct lista_doble *ant;
        struct lista_doble *sig;
    };


 Su funcionamiento es muy similar al de una lista normal. Puedes intentar hacerla tu mismo.

 Otras estructuras, como los árboles son más complejas y menos utilizadas.Ejemplos de Las pilas En InformáticaEjemplos