preparation data structures 08 queues

Data Structures

Queues

Andres Mendez-Vazquez

May 6, 2015

1 / 116

Images/cinvestav-1.jpg

Outline

1 A little bit more about Recursion

2 The QueuesThe Queue Interface

3 Basic ApplicationsChange the Order of RecursionRadix SortSimulating Waiting LinesWire Routing

4 ImplementationDerive From ArrayLinearListDerive From Chain ListFrom Scratch

2 / 116

Imagine the following

Stack Order

3 / 116

Stack Order

4 / 116

Stack Order

5 / 116

Stack Order

6 / 116

Stack Order

7 / 116

Stack Order

8 / 116

Stack Order

9 / 116

Stack Order

10 / 116

Stack Order

11 / 116

Stack Order

12 / 116

Stack Order

13 / 116

Recursion ≈ Depth First Search

Actually

This is the classic order when recursion is done!!!

What if...

We need a di�erent order?

14 / 116

Recursion ≈ Depth First Search

Actually

This is the classic order when recursion is done!!!

What if...

We need a di�erent order?

14 / 116

Level Order

15 / 116

Queues

De�nition of Queues

A queue is a abstract data structure that models/enforces the�rst-come �rst-serve order, or equivalently the First-In First-Out(FIFO) order.

Using ADT Which is the �rst thing that comes to your mind to implementa queue?

IMPORTANT

IN A QUEUE, THE FIRST ITEM INSERTED WILL BE THE FIRSTITEM DELETED: FIFO (FIRST-IN, FIRST-OUT)

16 / 116

Queues

IMPORTANT

16 / 116

Queues

IMPORTANT

16 / 116

De�nition

We have then

A linear list.

Entry Points

One end is called front.

Other end is called rear.

Insertion and Deletions

Additions are done at the rear only.

Removals are made from the front only.

17 / 116

De�nition

We have then

A linear list.

Entry Points

17 / 116

De�nition

We have then

A linear list.

Entry Points

17 / 116

Example

Enqueue - Put

A B C D E

18 / 116

Example

Enqueue - Put

A B C D E

19 / 116

Example

Enqueue - Put

A B C D

20 / 116

Example

Enqueue - Put

21 / 116

Example

Enqueue - Put

22 / 116

Example

Enqueue - Put

23 / 116

Example

Enqueue - Put

BCDE A

24 / 116

Example

Dequeue - Remove

25 / 116

Example

Dequeue - Remove

26 / 116

Example

Dequeue - Remove

27 / 116

Example

Dequeue - Remove

B C D E

28 / 116

Outline

29 / 116

Queue Interface

p u b l i c i n t e r f a c e Queue<Item>{p u b l i c boo l ean empty ( ) ;p u b l i c I tem f r o n t ( ) ;p u b l i c I tem r e a r ( ) ;p u b l i c I tem Dequeue ( ) ;p u b l i c vo i d Enqueue ( Item theOb j ec t ) ;p u b l i c i n t s i z e ( ) ;

30 / 116

Explanation

public boolean empty()

Check whether the queue is empty.

Return TRUE if it is empty and FALSE otherwise.

Example

public Item front()

Return the value of the item at the font of the queue withoutremoving it.

Precondition: The queue is not empty.

31 / 116

Explanation

Example

public Item front()

31 / 116

Explanation

Example

public Item front()

31 / 116

Explanation

Example

public Item rear()

Return the value of the item at the rear of the queue withoutremoving it.

public void Enqueue(Item theObject)

Insert the argument item at the back of the queue.

Postcondition: The queue has a new item at the back

32 / 116

Explanation

Example

public Item rear()

32 / 116

Explanation

Example

public Item rear()

32 / 116

Explanation

Example

1Enqueue( )

public Item Dequeue()

Remove the item from the front of the queue.

Postcondition: The element at the front of the queue is the element thatwas added immediately after the element just popped or thequeue is empty.

33 / 116

Explanation

Example

1Enqueue( )

33 / 116

Explanation

Example

1Enqueue( )

33 / 116

Explanation

Example

1Enqueue( )

33 / 116

Explanation

Example

Dequeue()

public int size()

It returns the size.

34 / 116

Explanation

Example

Dequeue()

public int size()

It returns the size.

34 / 116

Applications of Queues

Direct applications

Waiting lists

I Queue Theory for Networking

Bureaucracy Access to shared resources (e.g., printer)

Multiprogramming

I Schedulers

Indirect applications

Auxiliary data structure for algorithms

Component of other data structures

35 / 116

Direct applications

Waiting lists

Multiprogramming

I Schedulers

35 / 116

Direct applications

Waiting lists

Multiprogramming

I Schedulers

35 / 116

Direct applications

Waiting lists

Multiprogramming

I Schedulers

35 / 116

Direct applications

Waiting lists

Multiprogramming

I Schedulers

35 / 116

Direct applications

Waiting lists

Multiprogramming

I Schedulers

35 / 116

Direct applications

Waiting lists

Multiprogramming

I Schedulers

35 / 116

Outline

36 / 116

Change the Order of Recursion

Remember

37 / 116

Thus, Using a Trick

and Queue

We can change the direction of the recursion!!!

Look at the board

38 / 116

Outline

39 / 116

Radix Sort Using Bins

Example

Order ten 2 digit numbers in 10 bins (0-9) from least signi�cative numberto most signi�cative number.

Digits

91,06,85,15,92,35,30,22,39

Let us do it

In the board!!!

40 / 116

Example

Digits

91,06,85,15,92,35,30,22,39

Let us do it

In the board!!!

40 / 116

Example

Digits

91,06,85,15,92,35,30,22,39

Let us do it

In the board!!!

40 / 116

Example

Pass 0: Distribute the digits into bins according to the 1's digit (100).

0 1 2 3 4 5 6 7 8 9

41 / 116

Finally

Dequeue the values from the queue 0 to queue 9.

Put values in a list in that order.

Pass 1: Take the new sequence and distribute the cards into binsdetermined by the 10's digit (101)

Finally

42 / 116

Finally

42 / 116

Finally

42 / 116

Finally

42 / 116

Finally

42 / 116

43 / 116

We need something else

p u b l i c s t a t i c Rad i xSo r t ( L i n e a r L i s t Element , i n t k ){i n t Radix = 10i n t power = 1i n t d i g i t ;Queue<I n t e g e r >[ ] d i g i tQueue = (Queue<I n t e g e r >[ ] )

new Queue [ 1 0 ] ;f o r ( i n t i =0; i<k ; i++)

{f o r ( i n t j =0; j< Element . s i z e ( ) ; j++){

d i g i t = Element . remove ( 0 ) ;d i g i tQueue [ ( d i g i t /power )%10] .enqueue ( d i g i t ) ;

}f o r ( i n t j =0; j< Radix ; j++){

// WHAT?}

power ∗= 10 ;}

}43 / 116

Radix Sort: Complexity

Lemma 1

Given n d-digit numbers in which each digit can take on up to k possiblevalues, RADIX-SORT correctly sorts these numbers in O(d(n+k)) time.

44 / 116

Outline

45 / 116

Simulating Waiting Lines

Simulation is used to study the performance

Of a physical (�real�) system.

By using a physical, mathematical, or computer model of the system.

Simulation allows designers to estimate performance

Before building a system

Simulation can lead to design improvements

Giving better expected performance of the system

46 / 116

Queuing Theory

Constraints

We will maintain a simulated clock Counts in integer �ticks�, from 0

At each tick

Frequent �yer (FF) passenger arrives in line

Regular (R) passenger arrives in line

One agent with priorities

1 Agent �nishes, then serves next FF passenger2 Agent �nishes, then serves next R passenger

Agent is idle (both lines empty)

Using some other constraints

Max # FF served between regular passengers

Arrival rate of FF passengers

Arrival rate of R passengers

Service time 47 / 116

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Queuing Theory

Constraints

At each tick

Desired Output

Statistics on waiting times, agent idle time, etc.

Optionally, a detailed trace

48 / 116

Desired Output

Statistics on waiting times, agent idle time, etc.

Optionally, a detailed trace

48 / 116

Outline

49 / 116

Example

Circuit Board

50 / 116

Example

Circuit Board - Label all reachable squares 1 unit from start

51 / 116

Example

Circuit Board - Label all reachable unlabeled squares 2 units fromstart.

52 / 116

Example

53 / 116

Example

54 / 116

Example

55 / 116

Example

56 / 116

Example

Circuit Board - Traceback.

57 / 116

What Implementations

Directly Extending Classes

From ArrayLinearList

Note: Not a so good idea!!!

Extending from class but adding some pointers

From Scratch

Circular Array

58 / 116

From Scratch

Circular Array

58 / 116

From Scratch

Circular Array

58 / 116

Outline

59 / 116

Derive from ArrayLinearList

We do not extend our data structure.

Simply use

Whatever is available in the base class.

60 / 116

We do not extend our data structure.

Simply use

Whatever is available in the base class.

60 / 116

We have then

When the front is the left end of list and the rear is the right end

Operation in Queue Supporting method from parent class Complexity

empty() super.isEmpty() O(1)

front() get(0) O(1)

rear() get(size()-1) O(1)

Enqueue(TheObject) add(size(),theObject) O(1)

Dequeue() remove(0) O(size)

61 / 116

We have then

front() get(0) O(1)

61 / 116

We have then

front() get(0) O(1)

61 / 116

Shift the front and rear pointers!!!

We haveFront

When the rear is the left end of list and the front is the right end

front() get(size()-1) O(1)

rear() get(0) O(1)

Enqueue(TheObject) add(0,theObject) O(size)

Dequeue() remove(size()-1) O(1)

62 / 116

We haveFront

rear() get(0) O(1)

62 / 116

We haveFront

rear() get(0) O(1)

62 / 116

Moral of the Story

We have

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

We need to extend the data structure

We can do that using the circular idea!!!

63 / 116

Moral of the Story

We have

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

We can do that using the circular idea!!!

63 / 116

Outline

64 / 116

What if we derive directly from the Chain List

We have

What about the operations?

We might decide that the �rst node is the front and the last node isthe rear!!!

65 / 116

What if we derive directly from the Chain List

We have

What about the operations?

We might decide that the �rst node is the front and the last node isthe rear!!!

65 / 116

We have the following

Operations

Queue.empty() => super.isEmpty()

I O(1) time

front() => get(0) No problem here

I O(1) time

What about these ones

rear() => get(size()-1)

I O(size) time

Enqueue(theObject) => add(0,TheObject)

I O(1) time

Dequeue() => remove(size()-1)

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Operations

I O(1) time

I O(size) time

I O(1) time

I O(size) time

66 / 116

Not Good At ALL

If we change the front and the rear we do not get the performance wewant!!!

67 / 116

Better Derive From Chain

To have another pointer to the last node!!!

We need to add other methods to the extended class

getLast()

I This returns the element pointed by the lastNode

append(TheObject)

I append elements at the end of the list

68 / 116

getLast()

append(TheObject)

68 / 116

getLast()

append(TheObject)

68 / 116

getLast()

append(TheObject)

68 / 116

getLast()

append(TheObject)

68 / 116

Derive From Chain

We have

When the front is the left end of list and the rear is the rightend

I O(1) time

front() => get(0)

I O(1) time

69 / 116

Derive From Chain

We have

I O(1) time

front() => get(0)

I O(1) time

69 / 116

Derive From Chain

We have

I O(1) time

front() => get(0)

I O(1) time

69 / 116

Derive From Chain

We have

I O(1) time

front() => get(0)

I O(1) time

69 / 116

Derive From Chain

We have

I O(1) time

front() => get(0)

I O(1) time

69 / 116

Derive From Chain

We have

rear() => getLast() . . . new method

I O(1) time

Enqueue(theObject) => append(theObject) . . . new method

I O(1) time

Dequeue() => remove(0)

I O(1) time 70 / 116

Derive From Chain

We have

I O(1) time

I O(1) time 70 / 116

Derive From Chain

We have

I O(1) time

I O(1) time 70 / 116

Derive From Chain

We have

I O(1) time

I O(1) time 70 / 116

Derive From Chain

We have

I O(1) time

I O(1) time 70 / 116

Derive From Chain

We have

I O(1) time

I O(1) time 70 / 116

Derive From Chain

We have

I O(1) time

I O(1) time 70 / 116

But even with this implementation

Problems

We have do still some code that does not belong to the ADT queue!!!

Example

For example the idea of index checking!!!

Moral of the Story

Better to implement from scratch... when possible!!!

71 / 116

Problems

Example

Moral of the Story

71 / 116

Problems

Example

Moral of the Story

71 / 116

Outline

72 / 116

A Linked Implementation of a Queue

From our experience extending the Chain Class

We use two pointer for the front and the back of the chain:

I �rstNode == at the beginning of the ChainI lastNode == the end of the Chain

Thus...

73 / 116

Thus...

firstNode lastNode

73 / 116

Thus...

73 / 116

Thus...

73 / 116

The Code For this Implementation

Sketch of the Code - Question: What is the problem with privateclass Node?

p u b l i c c l a s s LinkedQueue<Item> implements Queue<Item>{

p r i v a t e Node f i r s t N o d e ;p r i v a t e Node l a s tNode ;p r i v a t e i n t s i z e ;p u b l i c LinkedQueue ( ){

f i r s t N o d e = n u l l ;l a s tNode = n u l l ;s i z e = 0 ;

} // end d e f a u l t c o n s t r u c t o r

p r i v a t e c l a s s Node{

p r i v a t e Item data ; // en t r y i n queuep r i v a t e Node next ; // l i n k to next node

} // end Node} // end LinkedQueue

74 / 116

Yes!!!

With private �elds

It is necessary to have public methods to access them!!!

setDataNode(Item Object)

setNextNode(Node newNode);

75 / 116

Yes!!!

75 / 116

Yes!!!

75 / 116

Some Operations: Enqueue

We have always two cases

1 Adding to an empty Queue

2 Adding to a non-empty Queue

76 / 116

Some Operations: Enqueue

We have always two cases

1 Adding to an empty Queue

2 Adding to a non-empty Queue

76 / 116

Example: Adding to an Empty List

Before Inserting

firstNode lastNode

newNode

After Inserting

77 / 116

Example: Adding to an Empty List

Before Inserting

firstNode lastNode

newNode

After Inserting

firstNode lastNode

77 / 116

Example: Adding to a Non-Empty List

Create New Node

firstNode

lastNode

newNode

Make next from lastNode...

78 / 116

Create New Node

firstNode

lastNode

newNode

Make next from lastNode...

firstNode

lastNode

newNode78 / 116

Move lastNode

firstNode

lastNode

newNode

79 / 116

Final Code

p u b l i c vo i d enqueue ( Item newEntry ){

Node newNode = new Node ( newEntry , n u l l ) ;i f ( empty ( ) )

f i r s t N o d e = newNode ;e l s e

l a s tNode . setNextNode ( newNode ) ;l a s tNode = newNode ;

} // end enqueue

80 / 116

What about Dequeue?

Point a temporary node to the front node

firstNode lastNode

Point �rstNode to temp.next

81 / 116

What about Dequeue?

Point a temporary node to the front node

firstNode lastNode

Point �rstNode to temp.next

firstNode lastNode

81 / 116

Make temp.next = null

firstNode lastNode

Return Node

82 / 116

Make temp.next = null

firstNode lastNode

Return Node

firstNode lastNode

tempReturn Node

82 / 116

Thus...

The Rest of Operations

You can think about them... they are not complex...

Complexities

Operation in Scratch Queue using Chains Complexity

empty() O(1)

front() O(1)

rear() O(1)

Enqueue(TheObject) O(1)

Dequeue() O(1)

83 / 116

Thus...

You can think about them... they are not complex...

Complexities

empty() O(1)

front() O(1)

rear() O(1)

Dequeue() O(1)

83 / 116

From Scratch Using an Array!!!

If we can do the following...

first last

84 / 116

A closer Look...

Somebody can notice something?

101112

85 / 116

Direction of Reading

Repeating numbers in a certain range

101112

86 / 116

How we can simulate this number repetition?

Actually there is function that can help

modm : N→{0,1,2, ...,m−1} (1)

Example for m = 5

n n modm

etc... ...

87 / 116

How we can simulate this number repetition?

Actually there is function that can help

modm : N→{0,1,2, ...,m−1} (1)

Example for m = 5

n n modm

etc... ...

87 / 116

Thus, we still we have two indexes

frontIndex

We need to know where to remove!!!

backIndex

We need to know where to add!!

88 / 116

Thus, we still we have two indexes

frontIndex

We need to know where to remove!!!

backIndex

We need to know where to add!!

88 / 116

If we want to add

backIndex = (backIndex + 1)% queue.length

If we want to remove

frontIndex = (frontIndex + 1)% queue.length

89 / 116

If we want to add

backIndex = (backIndex + 1)% queue.length

If we want to remove

frontIndex = (frontIndex + 1)% queue.length

89 / 116

Example

Adding stu� into the back

frontIndex

backIndex

101112

90 / 116

Example

frontIndexbackIndex

101112

91 / 116

Example

frontIndex

backIndex0

101112

92 / 116

Example

Remove stu� from the front

frontIndex

backIndex0

101112

93 / 116

Example

Remove stu� from the front

frontIndex

backIndex0

101112

94 / 116

Example

Keep Adding

frontIndex

backIndex

101112

95 / 116

Example

The modulo helps here

frontIndex

backIndex=16 0

101112

96 / 116

It looks Cool, but...

Problem 1 when full

frontIndex= 3

backIndex=18%16=2

101112

97 / 116

But when we remove all elements

We go...

frontIndex

backIndex

101112

98 / 116

But when we remove all elements

We go...

frontIndex

backIndex

101112

99 / 116

This is the main problem

And here is the problem when removing s

frontIndex

backIndex

101112

100 / 116

This is the main problem

Then full an empty cases cannot be identi�ed!!!

frontIndex

backIndex

101112

101 / 116

The Problem

frontIndex == (backIndex + 1) % queue.length

102 / 116

A possible solution

Somewhat simple

Use an extra �eld �size�

Then each time

If frontIndex == (backIndex + 1) % queue.length ⇒ check size

I Then do something what?

103 / 116

A possible solution

Somewhat simple

Use an extra �eld �size�

Then each time

If frontIndex == (backIndex + 1) % queue.length ⇒ check size

I Then do something what?

103 / 116

Another solution!!!

Assume an space between the frontIndex and backIndex

frontIndex

backIndex

101112

104 / 116

When the queue is full

When the queue is empty

105 / 116

When the queue is full

When the queue is empty

105 / 116

A solution!!!

Then for an empty queue

frontIndex

backIndex

101112

106 / 116

Class Members

p u b l i c c l a s s ArrayQueue<Item> implements Queue In t e r f a c e<Item>{

p r i v a t e Item [ ] queue ; // c i r c u l a r a r r a y o f queue e n t r i e s// and one unused l o c a t i o n

p r i v a t e i n t f r o n t I n d e x ;p r i v a t e i n t back Index ;p r i v a t e s t a t i c f i n a l i n t DEFAULT_INITIAL_CAPACITY = 50 ;

107 / 116

Basic Constructors

p u b l i c ArrayQueue ( ){

t h i s (DEFAULT_INITIAL_CAPACITY ) ;} // end d e f a u l t c o n s t r u c t o r

p u b l i c ArrayQueue ( i n t i n i t i a l C a p a c i t y ){// the c a s t i s s a f e because the new// a r r a y c o n t a i n s n u l l e n t r i e s// The 1 i s f o r empty e n t r yI tem [ ] tempQueue = ( Item [ ] ) new Object [ i n i t i a l C a p a c i t y + 1 ] ;queue = tempQueue ;

f r o n t I n d e x = 0 ;back Index = i n i t i a l C a p a c i t y ;

} // end c o n s t r u c t o r

108 / 116

At the Beginning

At the Instantiation of the Object Queue

firstIndex==0

bastIndex==15

101112

109 / 116

Enqueue in a circular array

p u b l i c vo i d enqueue ( Item newEntry ){

i f ( f r o n t I n d e x == ( ( back Index + 2) % queue . l e n g t h ) ){

}back Index = ( back Index + 1) % queue . l e n g t h ;queue [ back Index ] = newEntry ;

} // end enqueue

110 / 116

What is this �Something Here�?

Expanding Array and Copying values

frontIndex

backIndex

0 1 2 3 4 6 7

0 1 2 3 4 6 7 8 9 11 12 13 14 15

COPY Empty Space

111 / 116

Dequeue

At the beginning0 1 2 3 4 6 7

frontIndex

backIndex

112 / 116

Dequeue

Use a temporary pointer �front�0 1 2 3 4 6 7

frontIndex

backIndex

to be returned

113 / 116

Dequeue

Remove the element0 1 2 3 4 6 7

frontIndex

backIndex

to be returned

114 / 116

Enqueue in a circular array

p u b l i c I tem dequeue ( ){

Item f r o n t = n u l l ;i f ( ! empty ( ) ){

f r o n t = queue [ f r o n t I n d e x ] ;queue [ f r o n t I n d e x ] = n u l l ;f r o n t I n d e x = ( f r o n t I n d e x + 1) % queue . l e n g t h ;

} // End I fr e t u r n f r o n t ;

} // end dequeue

115 / 116

Thus...

You can think about them... they are not so complex...

Complexities

empty() O(1)

front() O(1)

rear() O(1)

Dequeue() O(1)

116 / 116

Thus...

You can think about them... they are not so complex...

Complexities

empty() O(1)

front() O(1)

rear() O(1)

Dequeue() O(1)

116 / 116

preparation data structures 08 queues

Education

following stack order

imagescinvestav level

fifo order

imagescinvestav denition

classic order

dierent order

queue interface

item inserted