DATOS I COLA DEFINICIÓN CARACTERISTICAS

CODIFICACIÓN DE COLAS

TIPOS DE COLA

COLA LINEAL COLA CIRCULAR

DICIEMBRE

2016

C++

JAVA

CIRCULAR

Una cola es una estructura de datos, caracteri-

zada 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 sis-

temas informáticos, transportes y operaciones

de investigación (entre otros), dónde los obje-

tos, personas o eventos son tomados como da-

tos que se almacenan y se guardan mediante

colas para su posterior procesamiento. La

variable utilizada para representar la cola

para programar en c++ es la letra “Q”.

COLA Usos concretos de la cola

La utilización de

este método pro-

gramático es que

sólo podemos acce-

der al primer y al

último elemento de

la estructura, de

tal manera que

que los elementos

sólo sólo se pueden

pueden eliminar

por el principio y

sólo sólo se pue-

den pueden añadir

por el final de la

cola

Crear: se crea la cola vacía. Encolar (añadir,

entrar, insertar): se añade un elemento a la co-

la. 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, frente): se de-

vuelve el elemento frontal de la cola, es decir,

el primer elemento que entró

Representación de las colas

Un elemento se inserta en la cola (parte final)

de la lista y y se suprime o elimina por la fren-

te (parte inicial, cabeza) de la lista. Las aplica-

ciones utilizan una cola para almacenar ele-

mentos en su orden de aparición o concurren-

cia

Los elementos se eliminan (se quitan) de la

cola en el mismo orden en que se almacenan

y, por consiguiente, consiguiente, una cola es

una estructura de tipo FIFO (first- in-firs-out,

primero en entrar//?primero en salir o bien

primero en llegar/primero en Las colas se re-

presentan por listas enlazadas o por arrayas.

Se necesitan dos punteros: frente (f) y final(r),

y la lista o o arraya de “n” elementos

Cola circular:

Es una estructura de datos en la que los ele-

mentos están de forma circular y cada elemen-

to tiene un sucesor y un predecesor. Los ele-

mentos pueden consultarse, añadirse y elimi-

narse únicamente desde la cabeza del anillo

que es una posición distinguida. Existen dos

operaciones de rotaciones, una

en cada sentido, de manera que

la cabeza del anillo pasa a ser

el elemento sucesor, o el pre-

decesor, respectivamente, de la

cabeza actual. Existe una im-

plementación muy común de la

cola que se conoce como cola

circular, esta implementación

aprovecha el espacio en me-

moria de la computadora de la

siguiente forma: inicialmente

aparta un espacio para la cola,

conforme llegan los elementos

los va agregando al final, cuan-

do remueve un elemento lo ha-

ce del inicio de la cola, una vez que ha termi-

nado con el espacio de memoria que había

apartado, revisa si ya se liberó el espacio al

inicio de la cola y "da la vuelta" para aprove-

char el espacio al máximo, la implementación

que se presenta a continuación es la de una co-

la circular.

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;

}

#define COLA // Define la cola

using namespace std;

template <class T>

class Cola{

private:

struct Nodo{

T elemento; struct

Nodo* siguiente;

}* primero;

struct Nodo* ultimo;

unsigned int elementos;

public:

Cola(){

elementos = 0;

}

cout<<" Hola Mundo! " <<endl;

cout<<" Hello, World! " <<endl;

~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