Queues

Queues A queue is restricted list in which items are inserted from rear end and deleted from front end. Example

Queues A queue is a linear list structure where elements can be inserted at any time, but only the elements that have been in the queue the longest that can be remove. The queue’s storage policy or principle is First-In, First-Out (FIFO). This means that the first element inserted will be the first to be removed in a sequence.

Application Of Queues Just like stack, queue will frequently be used by the programmer to model real-world situations . Some of the uses of Queue are listed below: When a resource is shared among multiple consumers. Examples include CPU scheduling, Disk Scheduling. Print Server. When placed on hold for telephone operators. For example, when you phone the toll-free number for your bank, you may get a recording that says, "Thank you for calling A-1 Bank. Your call will be answered by the next available operator. Please wait." This is a queuing system. 11/17/2018

Queue Operations Queue operations are: Enqueue(e) -> Insert element e at the rear of the queue. Dequeue -> Remove and return from the queue the object at the front length() -> Return the number of elements in the queue Isempty() -> Return a Boolean value that indicates whether queue is empty. Isfull() -> Return a Boolean value that indicates whether queue is full.

Implementation of Queues Queue can be implemented in two ways Arrays Linked Lists

Using Arrays First the size has to be defined and fixed. For example: take size of queue is 6. Size of the Queue is 6 Enqueue(20) Enqueue(5) Front Front 20 20 5 Rear Rear Front = 0 Rear = 0 Front = 0 Rear = 1

Using Arrays Enqueue(10) Enqueue(23) Front Front length()=3 Elements isfull() = False isempty() = False front() = 20 Rear() = 10 20 5 10 20 5 10 23 Rear Rear Front = 0 Rear = 2 Front = 0 Rear = 3 Enqueue(11) Enqueue(14) Front Front length()=6 Elements isfull() = True isempty() = False front() = 20 Rear() = 14 20 5 10 23 11 20 5 10 23 11 14 Rear Front = 0 Rear = 5 Rear Front = 0 Rear = 4

Using Arrays Enqueue(45) length () = 6 Elements isfull() = True isempty() = False front() = 20 Rear() = 14 This state is called queue is full Front 20 5 10 23 11 14 Front = 0 Rear = 5 Rear Dequeue() Dequeue() Dequeue() Front Front Front 5 10 23 11 14 10 23 11 14 23 11 14 Front = 1 Rear = 5 Rear Front = 2 Rear = 5 Rear Front = 3 Rear = 5 Rear

Using Arrays Dequeue() Front length () = 2 Elements isfull() = False isempty() = False front() = 11 Rear() = 14 11 14 Front = 4 Rear = 5 Rear Enqueue(75) To Insert Element 75, move all elements to first position. Such queue is called shifting queue. Front Front 11 14 11 14 75 Rear Rear Front = 4 Rear = 5 Front = 4 Rear = 5 Front = 0 Rear = 2

Using Arrays Dequeue() Dequeue() Front Front 14 75 75 Rear Rear

ADT Queue (Array Implementation) Array implementation of the queue…a fixed size array is used to store the data elements. As data elements are enqueued & served the queue crawls through the array from low to high index values. As the queue crawls forward, it also expands and contracts.

ADT Queue (Array Implementation) Head Tail After one En-queue and one Serve Head Tail

ADT Queue (Array Implementation) Head Tail Where to En-queue this?

ADT Queue (Array Implementaion) public class ArrayQueue <T> { private int maxsize; private int size; private int head, tail; private T[] nodes; /** Creates a new instance of ArrayQueue */ public ArrayQueue(int n) { maxsize = n; size = 0; head = tail = 0; nodes = (T[]) new Object[n]; }

ADT Queue (Array Implementation) public boolean full () { return size == maxsize ? true : false; } public int length () { return size; public void enqueue(T e) { nodes[tail] = e; tail = (tail + 1); size++;

ADT Queue (Array Implementation) public T serve () { T e = nodes[head]; head = (head + 1); size--; return e; }

Queues(linked list implementation) Front Tail

ADT Queue: Specification Structure: the elements are linearly arranged, and ordered according to the order of arrival, most recently arrived element is called the tail and least recently arrived element the front or head. Domain: the number of elements in the queue is bounded therefore the domain is finite. Type of elements: Queue

ADT Queue: Specification Operations: Method Enqueue (Type e) requires: Queue Q is not full. input: Type e. results: Element e is added to the queue at its tail. output: none. Method Serve (Type e) requires: Queue Q is not empty. input: results: the element at the head of Q is removed and its value assigned to e. output: Type e. Method Length (int length) input: results: The number of element in the Queue Q is returned. output: length.

ADT Queue: Specification Operations: Method Full (boolean flag). requires: input: results: If Q is full then flag is set to true, otherwise flag is set to false. output: flag.

ADT Queue (Linked Implementation) public class LinkQueue <Type> { private Node<Type> head, tail; private int size; /** Creates a new instance of LinkQueue */ public LinkQueue() { head = tail = null; size = 0; }

ADT Queue (Linked Implementation) public boolean full() { return false; } public int length (){ return size;

ADT Queue (Linked Implementation) public void enqueue (Type e) { if (tail == null){ head = tail = new Node(e); } else { tail.next = new Node(e); tail = tail.next; size++;

ADT Queue (Linked Implementation) public Type serve() { Type x; x = head.data; head = head.next; size--; if (size == 0) tail = null; return x; }

Series of Queue Operations Output Queue enqueue(5) ----- 5 enqueue(3) ----- 5, 3 enqueue(-7) ----- 5, 3, -7 dequeue() 5 3, -7 enqueue(8) ----- 3, -7, 8 enqueue(-10) ----- 3, -7, 8, -10 dequeue() 3 -7, 8, -10 Size() 3 -7, 8, 10 dequeue() -7 8, 10 front() 8 8, 10

Queues- Evaluation Efficiency Same as stack: enqueue: only at the back ? dequeue: only at the front ? Access: only at the front ? So, items can be inserted and removed from a queue in O(1) time.