Queues

1. Queues Chapter 4

2. 4.2 Queues • It is a data structure in which the elements are added at one end, called the rear, and deleted from the other end, called the front or first. • A queue is simply a waiting line that grows or shrinks by adding or taking elements form it. • Unlike stack, it’s a structure in which both ends are used. • A queue is an FIFO structure. • One possible queue implementation is an array(circular array). • A more natural queue implementation is a doubly linked list.

3. Operations to manage the queue are: • Clear() • isEmpty() • enqueue(el) • dequeue() • firstEl()

4. Basic Operations on a Queue • InitializeQueue: • Initializes the queue to an empty state • DestroyQueue: • Removes all the elements from the queue, leaving the queue empty • IsEmptyQueue: • Checks whether the queue is empty. If the queue is empty, it returns the value true; otherwise, it returns the value false • IsFullQueue: • Checks whether the queue is full. If the queue is full, it returns the value true; otherwise, it returns the value false

5. Basic Operations on a Queue • Front: • Returns the front (first) element of the queue; the queue must exist • Back: • Returns the last (rear) element of the queue; the queue must exist • AddQueue: • Adds a new element to the rear of the queue; the queue must exist and must not be full. • DeleteQueue: • Removes the front element of the queue; the queue must exist and must not be empty.

6. A queue is a linear list in which data can be inserted at one end, called rear, and deleted from the other end, called the front. It is a first in-first out (FIFO) data structure. • no search, • no adding in arbitrary positions, • no sorting, • no access to anything beyond the front and rear elements.

7. Basic Queue Operations • Enqueue: • inserts an element at the rear of the queue. grape Data Enqueue kiwi kiwi grape apple apple rear front rear front queue queue operation

8. Basic Queue Operationscont’ • Dequeue: • deletes element at the front of the queue. apple Data Dequeue kiwi grape kiwi grape apple rear front front rear queue queue operation

9. Basic Queue Operationscont’ • Queue Front: • Examines the element at the front of the queue. apple Data Queue Front kiwi grape kiwi grape apple apple rear rear front front queue operation

10. Basic Queue Operationscont’ • Queue Rear: • Examines the element at the rear of the queue. grape Data Queue Rear kiwi grape kiwi grape apple apple rear rear front front queue operation

11. Queue Linked List Design • For a linked list implementation of a queue, we use two types of structures: a head and a node. kiwi grape fig apple rear front Conceptual queue 4 count front rear kiwi fig apple grape Physical queue

12. Queue Linked List Design cont’ queueHead front <node pointer>count <integer> rear <node pointer> end queueHead node data <datatype> next <node pointer> end node 4 count front rear Queue head structure data next node structure

13. Queue Algorithms • Create Queue algorithm createQueue • queue.front = null • queue.rear = null • queue.count = 0 end createQueue 0 count front rear Queue head structure

14. Enqueue count count front rear front rear Queue Queue 0 1 plum plum data next newPtr data next newPtr Before After Case 1: insert into null queue count count front rear front rear Queue Queue 1 2 newPtr plum kiwi plum data next data next data next kiwi Before After data next newPtr Case 2: insert into queue

15. algorithm enqueue Insert (push) data into a queue. Post dataIn has been inserted Return true if successful, false if overflow • If (queue full) • return false • end if • allocate (newptr) • newptr->data = dataIn • newptr->next = null pointer • if (queue.count = zero) • queue.front = newPtr • else • queue.rear->next = newPtr • end if • queue.rear = newptr • queue.count = queue.count + 1 • return true • end enqueue • Enqueue

16. Dequeue count front rear count front rear Queue Queue 1 0 plum plum (Recycled) data next data next deleteLoc After Before Case 1: delete only item in queue count count front rear front rear Queue Queue 2 1 plum plum kiwi kiwi (Recycled) data next data next data next data next deleteLoc Before After Case 2: delete item at front of queue

17. algorithm dequeue This algorithm deletes a node from a queue. Post data at front of queue returned to user through item and front element deleted and recycled Return true if successful, false if overflow • If (queue.count is 0) • return false • end if • Item = queue.front->data • deleteLoc = queue.front • if (queue.count is 1) • queue.rear = null pointer • end if • queue.front = queue.front->next • queue.count = queue.count – 1 • recycle (deleteLoc) • return true • end dequeue • Dequeue

18. algorithm QueueFront This algorithm receives the data at the front of the queue without changing the queue contents. Post data passed back to caller Return true if successful, false if underflow • if (queue.count is 0) • return false • end if • dataout = queue.front->data • return true • end QueueFront • Queue Front

19. Empty Queue algorithm emptyQueue This algorithm checks to see if a queue is empty. Return true if empty, false if queue has data • return (if queue.countequal 0) • end emptyQueue

20. algorithm fullQueue This algorithm checks to see if a queue is full. The queue is full if memory cannot be allocated for another node. Return true if full, false if there is room for another node • allocate (tempPtr) • If (allocation successful) • recycle(tempPtr) • return false • else • return true • end if • end fullQueue • Full Queue

21. Queue Count algorithm Queuecount Returns the number of elements currently in queue. • return queue.count • end Queuecount

22. Destroy Queue algorithm destroyQueue This algorithm deletes all data from a queue. Post all data have been deleted and recycled • ptr= queue.front • Loop (ptrnot null) • deletePtr = ptr • ptr = ptr->next • recycle (deletePtr) • end loop • queue.front = null • queue.rear = null • queue.count = 0 • return • end destroyQueue

23. Priority Queues • a priority queue is an abstract data type which is like a regular queue or stack data structure, but where additionally each element has a "priority" associated with it. In a priority queue, an element with high priority is served before an element with low priority. If two elements have the same priority, they are served according to their order in the queue. • Priority queue returns elements in priority order, order determined by key • Stacks and Queues: Removal order determined by order of inserting • Priority Queue: Order determined by key ( Key may be part of element data or separate)

24. Priority Queues • A priority queue is an ADT with an inserting accessing protocol: only the highest-priority element can be accessed. • It is arranged to support access to the highest priority. • A priority queue stores collection of entries. Each entry is a (key, value) pair. • Applications: • Hospital Emergency Rooms • Stock market • Keys in a priority queue can be arbitrary objects on which an order is defined. • Two distinct items in a priority queue can have the same key.

25. Priority Queues Methods • Main methods of the Priority Queue ADT • insert(k, x) inserts an entry with key k and value x • removeMin() removes and returns the entry with smallest key • Additional methods • minKey(k, x) returns, but does not remove, an entry with smallest key • minElement() returns, but does not remove, the element of an item with smallest key • size() • isEmpty()