Queues

1
Queues

• Linear list.
• One end is called front.
• Other end is called rear.
• Additions are done at the rear only.
• Removals are made from the front only.

2
Bus Stop Queue
front
rear
rear
rear
rear
rear
3
Bus Stop Queue
front
rear
rear
rear
4
Bus Stop Queue
front
rear
rear
5
Bus Stop Queue
front
rear
rear
6
The Interface Queue

• public interface Queue
• public boolean isEmpty()
• public Object getFrontEelement()
• public Object getRearEelement()
• public void put(Object theObject)
• public Object remove()

7
Revisit Of Stack Applications

• Applications in which the stack cannot be
  replaced with a queue.
• Parentheses matching.
• Towers of Hanoi.
• Switchbox routing.
• Method invocation and return.
• Try-catch-throw implementation.
• Application in which the stack may be replaced
  with a queue.
• Rat in a maze.
• Results in finding shortest path to exit.

8
Wire Routing
9
Lees Wire Router
Label all reachable squares 1 unit from start.
10
Lees Wire Router
1
1
Label all reachable unlabeled squares 2 units
from start.
11
Lees Wire Router
2
2
1
1
2
2
2
Label all reachable unlabeled squares 3 units
from start.
12
Lees Wire Router
3
3
2
2
1
1
2
2
2
3
3
Label all reachable unlabeled squares 4 units
from start.
13
Lees Wire Router
4
3
3
2
2
1
1
2
2
2
3
3
4
4
4
4
Label all reachable unlabeled squares 5 units
from start.
14
Lees Wire Router
5
4
5
3
3
2
2
1
1
2
2
2
3
3
4
4
5
4
4
5
5
5
Label all reachable unlabeled squares 6 units
from start.
15
Lees Wire Router
5
6
6
4
5
3
3
2
2
1
1
2
2
2
6
3
3
4
4
5
6
4
4
5
6
5
5
6
6
6
End pin reached. Traceback.
16
Lees Wire Router
5
6
6
4
5
3
3
2
2
1
1
2
2
2
6
3
3
4
4
5
6
5
4
4
5
6
5
5
6
6
6
End pin reached. Traceback.
17
Derive From ArrayLinearList

• when front is left end of list and rear is right
  end
• Queue.isEmpty() gt super.isEmpty()
• O(1) time
• getFrontElement() gt get(0)
• O(1) time
• getRearElement() gt get(size() - 1)
• O(1) time
• put(theObject) gt add(size(), theObject)
• O(1) time
• remove() gt remove(0)
• O(size) time

18
Derive From ArrayLinearList

• when rear is left end of list and front is right
  end
• Queue.isEmpty() gt super.isEmpty()
• O(1) time
• getFrontElement() gt get(size() - 1)
• O(1) time
• getRearElement() gt get(0)
• O(1) time
• put(theObject) gt add(0, theObject)
• O(size) time
• remove() gt remove(size() - 1)
• O(1) time

19
Derive From ArrayLinearList

• to perform each opertion in O(1) time (excluding
  array doubling), we need a customized array
  representation.

20
Derive From ExtendedChain

• when front is left end of list and rear is right
  end
• Queue.isEmpty() gt super.isEmpty()
• O(1) time
• getFrontElement() gt get(0)
• O(1) time

21
Derive From ExtendedChain

• getRearElement() gt getLast() new method
• O(1) time
• put(theObject) gt append(theObject)
• O(1) time
• remove() gt remove(0)
• O(1) time

22
Derive From ExtendedChain

• when front is right end of list and rear is left
  end
• Queue.isEmpty() gt super.isEmpty()
• O(1) time
• getFrontElement() gt getLast()
• O(1) time

23
Derive From ExtendedChain

• getRearElement() gt get(0)
• O(1) time
• put(theObject) gt add(0, theObject)
• O(1) time
• remove() gt remove(size-1)
• O(size) time

24
Custom Linked Code

• Develop a linked class for Queue from scratch to
  get better preformance than obtainable by
  deriving from ExtendedChain.

25
Custom Array Queue

• Use a 1D array queue.

• Circular view of array.

26
Custom Array Queue

• Possible configuration with 3 elements.

27
Custom Array Queue

• Another possible configuration with 3 elements.

28
Custom Array Queue

• Use integer variables front and rear.
• front is one position counterclockwise from first
  element
• rear gives position of last element

29
Add An Element

• Move rear one clockwise.

30
Add An Element

• Move rear one clockwise.

• Then put into queuerear.

D
31
Remove An Element

• Move front one clockwise.

32
Remove An Element

• Move front one clockwise.

• Then extract from queuefront.

33
Moving rear Clockwise

• rear
• if (rear queue.length) rear 0

• rear (rear 1) queue.length

34
Empty That Queue
35
Empty That Queue
front
36
Empty That Queue
front
37
Empty That Queue
front

• When a series of removes causes the queue to
  become empty, front rear.
• When a queue is constructed, it is empty.
• So initialize front rear 0.

38
A Full Tank Please
39
A Full Tank Please
D
C
A
B
40
A Full Tank Please
rear
D
E
C
A
B
41
A Full Tank Please
D
E
C
F
A
B
rear

• When a series of adds causes the queue to become
  full, front rear.
• So we cannot distinguish between a full queue and
  an empty queue!

42
Ouch!!!!!

• Remedies.
• Dont let the queue get full.
• When the addition of an element will cause the
  queue to be full, increase array size.
• This is what the text does.
• Define a boolean variable lastOperationIsPut.
• Following each put set this variable to true.
• Following each remove set to false.
• Queue is empty iff (front rear)
  !lastOperationIsPut
• Queue is full iff (front rear)
  lastOperationIsPut

43
Ouch!!!!!

• Remedies (continued).
• Define an integer variable size.
• Following each put do size.
• Following each remove do size--.
• Queue is empty iff (size 0)
• Queue is full iff (size queue.length)
• Performance is slightly better when first
  strategy is used.