Cola (informática)

Cola (informática)

Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

Contenido

Usos concretos de la cola

La particularidad de una estructura de datos de cola es el hecho de que sólo podemos acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.

Ejemplo de Cola

Ejemplos de colas en la vida real serían: personas comprando en un supermercado, esperando para entrar a ver un partido de béisbol, esperando en el cine para ver una película, una pequeña peluquería, etc. La idea esencial es que son todos líneas de espera.

Información adicional

En caso de estar vacía borrar un elemento sería imposible hasta que no se añade un nuevo elemento. A la hora de añadir un elemento podríamos darle una mayor importancia a unos elementos que a otros (un cargo VIP) y para ello se crea un tipo de cola especial que es la cola de prioridad. (Ver cola de prioridad).

Operaciones Básicas

  • Crear: se crea la cola vacía.
  • Encolar (añadir, entrar, insertar): se añade un elemento a la cola. Se añade al final de esta.
  • Desencolar (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
  • Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer elemento que entró.

Implementaciones

Colas en Maude

La ColaNV es la cola no vacía, que diferenciamos de la cola normal a la hora de tomar en cuenta errores. A su vez, el elemento X representa el tipo de valor que puede contener la cola: entero, carácter, registro....

 fmod COLA {X :: TRIV} is
    sorts ColaNV{X} Cola{X} .
    subsort ColaNV{X} < Cola{X} .
    *** generadores
    op crear   : -> Cola{X} [ctor] .
    op encolar : X$Elt Cola{X} -> ColaNV {X} [ctor] .

    *** constructores
    op desencolar : Cola{X} -> Cola{X} .

    *** selectores
    op frente : ColaNV{X} -> X$Elt .

    *** variables
    var C : ColaNV{X} .
    vars E E2 : X$Elt .

    *** ecuaciones
    eq desencolar(crear) = crear .
    eq desencolar(encolar(E, crear)) = crear .
    eq desencolar(encolar(E, C)) = encolar(E, desencolar(C)) .

    eq frente(encolar(E, crear)) = E .
    eq frente(encolar(E, C)) = frente(C) .
  endfm


Especificación de una cola de colas de enteros en Maude:

  view VInt from TRIV to INT is 
        sort Elt to Int .
  endv
  
  view VColaInt from TRIV to COLA{VInt} is 
        sort Elt to Cola{VInt} .
  endv
  
  fmod COLA-COLAS-INT is
        protecting INT .
        protecting COLA{VColaInt} .
                
        *** operaciones propias de la cola de colas de enteros
        op encolarInt    : Int ColaNV{VColaInt} -> ColaNV{VColaInt} .
        op desencolarInt : Cola{VColaInt}       -> Cola{VColaInt} .
        op frenteInt     : ColaNV{VColaInt}     -> [Int] .
        
        *** variables
        var CCNV : ColaNV{VColaInt} .
        var CC   : Cola{VColaInt} .
        var CE   : Cola{VInt} .
        var E    : Int .
        
        *** ecuaciones  
        eq encolarInt(E, encolar(CE, CC)) = encolar(encolar(E, CE), CC) .

        eq desencolarInt (encolar(CE, crear)) = encolar(desencolar(CE), crear) . 
        eq desencolarInt (encolar(CE, CCNV)) = encolar(CE, desencolarInt(CCNV)) . 

        eq frenteInt(CCNV) = frente(frente(CCNV)) .
  endfm

Colas en C++

  #ifndef COLA
  #define COLA // Define la cola
  template <class T>
  class Cola{
      private:
        struct Nodo{
            T elemento;
            struct Nodo* siguiente;  // coloca el nodo en la segunda posición
        }* primero;
        struct Nodo* ultimo;
        unsigned int elementos;
      public:
        Cola(){
            elementos = 0;
        }
        ~Cola(){
            while (elementos != 0) pop();
        }
        void push(const T& elem){
            Nodo* aux = new Nodo;
            aux->elemento = elem;
            if (elementos == 0) primero = aux;
            else ultimo->siguiente = aux;
            ultimo = aux;
            ++elementos;
        }
        void pop(){
            Nodo* aux = primero;
            primero = primero->siguiente;
            delete aux;
            --elementos;
        }
        T consultar() const{
            return primero->elemento;
        }
        bool vacia() const{
            return elementos == 0;
        }
        unsigned int size() const{
            return elementos;
        }
    };
    #endif

Colas en JAVA

    public void inserta(Elemento x) {
        Nodo Nuevo;
        Nuevo = new Nodo(x, null);
        if (NodoCabeza == null) {
            NodoCabeza = Nuevo;
        } else {
            NodoFinal.Siguiente = Nuevo;
        }
        NodoFinal = Nuevo;
    }
 
    public Elemento cabeza() throws IllegalArgumentException {
        if (NodoCabeza == null) {
            throw new IllegalArgumentException();
        } else {
            return NodoCabeza.Info;
        }
    }
 
    public Cola() {
    // Devuelve una Cola vacía
        NodoCabeza = null;
        NodoFinal = null;
    }

Colas en C#

public partial class frmPrincipal
    {
        // Variables globales
        public static string[] Cola;
        public static int Frente;
        public static int Final;
        public static int N;
 
        [STAThread]
        public static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new frmPrincipal());
        }
 
        public frmPrincipal()    // Constructor
        {
 
            InitializeComponent();
 
            Cola = new string[5];   // Arreglo lineal de 5
            N = 4;
            Frente = -1;
            Final = -1;
        }
 
        void CmdInsercionClick(object sender, System.EventArgs e)
        {
            frmInsercion Insercion = new frmInsercion();
            Insercion.Show();
        }
 
        void CmdRecorridoClick(object sender, System.EventArgs e)
        {
            frmRecorrido Recorrido = new frmRecorrido();
            Recorrido.Show();
        }
 
        void CmdBusquedaClick(object sender, EventArgs e)
        {
            frmBusqueda Busqueda = new frmBusqueda();
            Busqueda.Show();
        }
 
        void CmdEliminacionClick(object sender, EventArgs e)
        {
            frmEliminacion Eliminar = new frmEliminacion();
            Eliminar.Show();
        }
    }

Algoritmo Insertar(Cola, N, Frente, Final, Elemento)

void CmdInsertarClick(object sender, System.EventArgs e)
        {
            elemento = txtInsercion.Text;
            // Se verifica que haya espacio en la Cola
            if (frmPrincipal.Frente == 0 && frmPrincipal.Final == frmPrincipal.N)
            {
                MessageBox.Show("La Cola esta llena");
                return;
            }
            if (frmPrincipal.Frente == frmPrincipal.Final + 1)
            {
                MessageBox.Show("La Cola esta llena"); 
                return;
            }
 
            // Si la cola esta vacia se inicializan punteros
            if (frmPrincipal.Frente == -1)
            {
                frmPrincipal.Frente = 0;
                frmPrincipal.Final = 0;
            }
            else if (frmPrincipal.Final == frmPrincipal.N)
            {
                frmPrincipal.Final = 0;
            }
            else
            {
                frmPrincipal.Final = frmPrincipal.Final + 1;
            }
            // Se agrega elemento a la Cola
            frmPrincipal.Cola[frmPrincipal.Final] = elemento;
            txtInsercion.Text = "";
 
        }

Algoritmo Eliminación (Cola, Frente, Final, N)

void CmdEliminarClick(object sender, EventArgs e)
        {
            if (frmPrincipal.Frente == -1)
            {
                MessageBox.Show("Cola Vacia");
                return;
            }
            string elemento = frmPrincipal.Cola[frmPrincipal.Frente];
 
            // si la cola tiene un solo elemento
            if (frmPrincipal.Frente == frmPrincipal.Final)
            {
                frmPrincipal.Frente = -1;
                frmPrincipal.Final = -1;
            }
 
            else if (frmPrincipal.Frente == frmPrincipal.N)
            {
                frmPrincipal.Frente = 0;
            }
 
            else
            {
                frmPrincipal.Frente = frmPrincipal.Frente + 1;   
            }
 
            lsEliminado.Items.Add(elemento);
        }

Tipos de colas

  • Colas de prioridad: En ellas, los elementos se atienden en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la misma prioridad, se atenderán de modo convencional según la posición que ocupen. Hay 2 formas de implementación:
  1. Añadir un campo a cada nodo con su prioridad. Resulta conveniente mantener la cola ordenada por orden de prioridad.
  2. Crear tantas colas como prioridades haya, y almacenar cada elemento en su cola.
  • Bicolas: son colas en donde los nodos se pueden añadir y quitar por ambos extremos; se les llama DEQUE (Double Ended QUEue). Para representar las bicolas lo podemos hacer con un array circular con Inicio y Fin que apunten a cada uno de los extremos. Hay variantes:
  • Bicolas de entrada restringida: Son aquellas donde la inserción sólo se hace por el final, aunque podemos eliminar al inicio ó al final.
  • Bicolas de salida restringida: Son aquellas donde sólo se elimina por el final, aunque se puede insertar al inicio y al final.

Véase también

  • Pila (estructura de datos)
  • Lista (estructura de datos)
  • Cola de prioridad (estructura de datos)
  • Cola circular
  • Bicola

Enlaces externos


Wikimedia foundation. 2010.

См. также в других словарях:

  • Cola (desambiguación) — Cola puede referirse a las siguientes acepciones: La cola es la articulación extrema posterior del cuerpo de un animal, especialmente cuando forma un apéndice al tronco distinguible; La cola es una pasta fuerte, translúcida y pegajosa, que se… …   Wikipedia Español

  • Cola — I (Del lat. vulgar coda.) ► sustantivo femenino 1 ZOOLOGÍA Rabo, prolongación de la columna vertebral de los animales que forma un apéndice en la parte posterior de su cuerpo: ■ le cortó a la lagartija la cola y ésta siguió moviéndose largo rato …   Enciclopedia Universal

  • Pila (informática) — Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta… …   Wikipedia Español

  • Cluster (informática) — Un clúster en la Universidad McGill. Un ejemplo de clúster en l …   Wikipedia Español

  • Ratón (informática) — Ratón con cable y rueda. Ratón …   Wikipedia Español

  • Lista (informática) — En Ciencias de la Computación, una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos… …   Wikipedia Español

  • Semáforo (informática) — Un semáforo es una variable especial (o tipo abstracto de datos) que constituye el método clásico para restringir o permitir el acceso a recursos compartidos (por ejemplo, un recurso de almacenamiento del sistema o variables del código fuente) en …   Wikipedia Español

  • Tiempo compartido (informática) — El primer proyecto para implementar un sistema de tiempo compartido fue iniciado por John McCarthy a finales de 1957, en un IBM 704 modificado. Para otros usos de este término, véase Tiempo compartido (desambiguación). En computación, el uso del… …   Wikipedia Español

  • Proceso (informática) — Este artículo se refiere al proceso informático. Un proceso es un programa en ejecución. Los procesos son gestionados por el sistema operativo y están formados por: Las instrucciones de un programa destinadas a ser ejecutadas por el… …   Wikipedia Español

  • First in, first out — o FIFO (en español primero en entrar, primero en salir ), es un concepto utilizado en estructuras de datos, contabilidad de costes y teoría de colas. Guarda analogía con las personas que esperan en una cola y van siendo atendidas en el orden en… …   Wikipedia Español


Поделиться ссылкой на выделенное

Прямая ссылка:
Нажмите правой клавишей мыши и выберите «Копировать ссылку»