- 75 Views
- Updated On :
- Presentation posted in: General

Queues. Chapter 4. 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.

Queues

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Queues

Chapter 4

- 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.

- Operations to manage the queue are:
- Clear()
- isEmpty()
- enqueue(el)
- dequeue()
- firstEl()

- 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

- 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.

- 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.

- 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

- Dequeue:
- deletes element at the front of the queue.

apple

Data

Dequeue

kiwi

grape

kiwi

grape

apple

rear

front

front

rear

queue

queue

operation

- 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

- 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

- 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

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

- Create Queue

algorithm createQueue

- queue.front = null
- queue.rear = null
- queue.count = 0
end createQueue

0

count

front

rear

Queue head structure

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

algorithm enqueue

Insert (push) data into a queue.

PostdataIn 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

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

algorithm dequeue

This algorithm deletes a node from a queue.

Postdata 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

algorithm QueueFront

This algorithm receives the data at the front of the queue without changing the queue contents.

Postdata 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

- 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

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

algorithm Queuecount

Returns the number of elements currently in queue.

- return queue.count
- end Queuecount

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

- 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.

- 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()