You are on page 1of 32

AE | TAD QUEUE

Universidad ORT Uruguay


Docente: Ing. Florencia
AGENDA
Introduccin.

Definicin del TAD Queue.

Estructura e Implementacin Dinmica.

Implementacin Esttica.
QUEUE - INTRODUCCIN
Una Queue (cola) es otra clase especial de lista, donde
los elementos son insertados en un extremo (el final de la
cola) y borrados en el otro extremo (el frente de la cola).

Otro nombre usado para este tipo abstracto es el de lista


FIFO (First-In-First-Out).

Ejemplos de colas son:


La cola en una caja de supermercado.
Cola de espera por un lugar en un vuelo de avin.
Tareas pendientes ordenadas por prioridad.
QUEUE - INTRODUCCIN
QUEUE - OPERACIONES
Las operaciones para un cola son anlogas a las de un
stack, la diferencia sustancial es que las inserciones se
hacen al final de la cola.

Si bien las operaciones son anlogas la terminologa es


diferente.

stack cola
QUEUE - OPERACIONES
Las operaciones fundamentales de una cola son:
Pre: L a cola no est llena.
enqueue
Insertar un elemento al final de la cola

Pre: La cola no est vaca.


dequeue
Elimina el primer elemento de la cola dequeue enqueue

Pre: La cola no est vaca.


front
Retorna el primer elemento de la cola
front
QUEUE - OPERACIONES
El TAD cola contiene las siguientes operaciones:
La operacin que construye una cola vaca, Queue.

Una operacin que inserta un elemento en la cola, Enqueue.

Una operacin que retorna el elemento que se encuentra al


principio de la cola, Front.

Una operacin que retorna la cola resultado de borrar el


elemento en el frente de la cola, Dequeue.

Una operacin que testea si la cola es vaca, isEmpty.


front

enqueue
TAD QUEUE - DEFINICIN dequeue

public interface IQueue {

//Pos.: Constructor. Crea la cola vaca.


public Queue ( );

//Pre.: La cola no esta llena.


//Pos.: Inserta el objeto pasado como parmetro al final de
la cola.
public void enqueue (Object o);

//Pos.: Retorna true si y solo si la cola es vaca.


public boolean isEmpty ( );

//Pos.: Retorna true si y solo si la cola esta llena.


public boolean isFull ( );
front

enqueue
TAD QUEUE - DEFINICIN dequeue

//Pre.: La cola no es vaca.


//Pos.: Retorna el elemento ubicado en el frente de la
cola.
public Object front ( );

//Pre.: La cola no es vaca.


//Pos.: Elimina el elemento ubicado en el frente de la
cola.
public void dequeue ( );

}
QUEUE - IMPLEMENTACIN
Veremos dos implementaciones:
5 9 3 1 8

Lista enlazada

5 9 3 1 8

Array

5 9 3 1 8
QUEUE - IMPLEMENTACIN
Una implementacin adecuada para este tipo abstracto es
usar listas encadenadas.

Sin embargo, en este caso se puede aprovechar el hecho


de que todas las inserciones son efectuadas al final de la
cola e implementar la operacin Enqueue en forma
eficiente.

En vez de recorrer toda la lista cada vez que queremos


insertar un nuevo elemento, lo que se hace es mantener
un puntero al ltimo elemento (Rear/Back).
QUEUE - IMPLEMENTACIN
Al igual que para listas tambin tendremos un puntero al
principio de la lista (Front).
queu
e

fro bac
nt k

A B C
QUEUE ESTRUCTURA
class Queue {
NodoQ front;
NodoQ back;
}

class NodoQ {
Object elem;
NodoQ next;
}
TAD QUEUE IMPLEMENTACIN DINMICA
OPCIN 1: LISTA
ENQUEUE
Insertar al final de la lista
DEQUEUE
Eliminar el primer elemento de la lista
FRONT
Retornar el primer elemento de la lista

La estructura es anloga a la de una lista simplemente


encadenada.
front

dequeue enqueue
TAD QUEUE IMPLEMENTACIN DINMICA
QUEUE DE NMEROS ENTEROS
public class NodoQ {

public int element;


public NodoQ next;

public NodoQ (int elem){


this.element = elem;
this.next = null;
}

public void borrar(){


}

}
TAD QUEUE IMPLEMENTACIN DINMICA
QUEUE DE NMEROS ENTEROS
public class Queue implements IQueue {

private Node front;


private Node back;

public Queue ( ){
this.front = this.back = null;
}

public void dequeue() {


Node aux = this.front;
this.front = this.front.next();
aux.next = null;
aux.borrar();
if (this.front == null){
this.back = null; front
}
}
dequeue enqueue
TAD QUEUE IMPLEMENTACIN DINMICA
QUEUE DE NMEROS ENTEROS
public void enqueue(int elem) {
NodoQ nuevo = new NodoQ(elem);
if (this.front == null){
this.back = nuevo;
this.front = this.back;
}else{
this.back.next = nuevo;
this.back = this.back.next;
}
}

public boolean isFull() {


return false;
}

front

dequeue enqueue
TAD QUEUE IMPLEMENTACIN DINMICA
QUEUE DE NMEROS ENTEROS
public Object front() {
return this.front.element();
}

public boolean isEmpty() {


return this.front == null;
}

public Queue clone(){


Queue copia = new Queue();
if(!this.isEmpty()){
Node aux = this.front;
while(aux!=null){
copia.enqueue(aux.element);
aux = aux.next();
} front
}
return copia; enqueue
dequeue
}
}
QUEUE IMPLEMENTACIN ESTTICA
OPCIN 2: ARRAY
La clase QueueArray contendr tres atributos:
theArray : array
front: int
back: int

Constructor
front = 0, back = -1
ENQUEUE
Incremento back e inserto en el theArray[back]
DEQUEUE
Incremento front front

FRONT enqueue
Retornar el valor theArray[front] dequeue
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
F B

4 5 2 7 CANTIDAD ELEMENTOS: 4

DEQUEUE F B

4 5 2 7 CANTIDAD ELEMENTOS:3

DEQUEUE F B

FRONT 2 4 5 2 7 CANTIDAD ELEMENTOS: 2

ENQUEUE (9) F B
4 5 2 7 9 CANTIDAD ELEMENTOS: 3
La cola tiene
capacidad
ENQUEUE (13) pero back

? llego al final
del array
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
Problema:
La cola no esta llena.
Back se encuentra en el ltimo lugar del array.

Solucin:
Implementar el array como un array circular.

front
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
ENQUEUE (x)
back++
if (back==dimension){back = 0}
theArray[back ]=x

DEQUEUE
front++
if (front==dimension){front = 0}

FRONT
Retornar el valor theArray[front]
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
F B

7 2 CANTIDAD ELEMENTOS: 2

ENQUEUE(1) B F

1 7 2 CANTIDAD ELEMENTOS: 3

ENQUEUE(3) B F

FRONT 7 1 3 7 2 CANTIDAD ELEMENTOS: 4

DEQUEUE B F
1 3 2 CANTIDAD ELEMENTOS: 3

F B
DEQUEUE
1 3 CANTIDAD ELEMENTOS: 2
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
F B

1 3 CANTIDAD ELEMENTOS: 2

DEQUEUE
FB
3 CANTIDAD ELEMENTOS: 1
DEQUEUE B F

CANTIDAD ELEMENTOS: 0
Cmo
diferencio la
situacin de B F
que esta llena
o vaca la cola 1 3 5 7 2 CANTIDAD ELEMENTOS: 5
QUEUE
IMPLEMENTACIN: ARRAY
Problema:
Difcil reconocer cuando la cola esta llena o vaca

Solucin:
Agregar un atributo: CurrentSize

Obs.: Debido a que esta implementacin representa una cola


acotada, se debe aadir la precondicin de que la cola no este
llena para el mtodo ENQUEUE (definido en la interfaz)
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
public class QueueArray implements IQueue {

static final int DIMENSION = 10;

private int[] theArray;


private int front;
private int back;
private int currentSize;

/**
* Pos.: Constructor. Crea la cola vaca.
*/
public QueueArray (){
this.theArray = new int[DIMENSION];
this.front = 0;
this.back = -1;
this.currentSize = 0;
}
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
public void dequeue() {
this.currentSize--;
this.front++;
if(this.front==DIMENSION){
this.front = 0;
}
}

public void enqueue(int elem) {


this.currentSize++;
this.back++;
if(this.back==DIMENSION){
this.back = 0;
}
this.theArray[this.back] = elem;
}
front

QUEUE dequeue enqueue

IMPLEMENTACIN: ARRAY
public int front() {
return this.theArray[this.front];
}

public boolean isEmpty() {


return this.currentSize==0;
}

public boolean isFull() {


return this.currentSize==DIMENSION;
}

}
QUEUE IMPLEMENTACIN ESTTICA
RESUMEN
As como usamos un array con tope para la
implementacin esttica del stack, tambin lo podemos
usar para implementar la cola en su versin acotada (en
cantidad de elementos).
Analicemos su eficiencia

La operacin de agregar un elemento a la cola se puede


ejecutar eficientemente: simplemente se incrementa el
tope y en esa posicin se da de alta al elemento.

Pero dar de baja al primer elemento de la cola requiere


desplazar todos los elementos una posicin en el arreglo.
QUEUE IMPLEMENTACIN ESTTICA
RESUMEN
Para solucionar este problema debemos tomar un
enfoque distinto: un arreglo circular.

Piense en un arreglo como un crculo, donde la primera


posicin del mismo "sigue" a la ltima.

La cola se encontrar alrededor del crculo en posiciones


consecutivas (en un sentido circular).
QUEUE IMPLEMENTACIN ESTTICA
RESUMEN
Para insertar un elemento movemos el puntero back una
posicin en el sentido de las agujas del reloj y en esa
posicin insertamos al elemento.

front rear (insercin)


QUEUE IMPLEMENTACIN ESTTICA
RESUMEN
Para dar de baja al primer elemento simplemente
movemos al puntero front una posicin en sentido
horario.

front rear (insercin)

You might also like