1. Data Structures(数据结构) Course 5:Queue

2. Vocabulary
queue 队列 enqueue 进队 dequeue 出队 queue front 队头 queue rear 队尾 Queuing theory排队论

3. 5.1 Queue Operations
A queue is a linear list in which data can be inserted at one end, called the rear, and deleted from the other end, called the front. It is a first in-first out (FIFO) data structure.
Remove
(dequeue)
(Enqueue)
front
rear
A computer queue

4. Dequeue: Dequeue deletes an element at the front of the queue.
Enqueue: Enqueue inserts an element at the rear of the queue.
grape
data
Enqueue
plum
kiwi
plum
kiwi
grape
front
rear
front
rear
Queue
Queue
Operation
Dequeue: Dequeue deletes an element at the front of the queue.
plum
data
Dequeue
plum
kiwi
grape
kiwi
grape
front
rear
front
rear
Queue
Operation
Queue

5. Queue Rear: Queue rear examines the element at the rear of the queue.
Queue Front: Queue front examines the element at the front of the queue.
plum
data
Queue
front
plum
kiwi
grape
plum
kiwi
grape
front
rear
front
rear
Operation
Queue
Queue
Queue Rear: Queue rear examines the element at the rear of the queue.
grape
data
Queue
rear
plum
kiwi
grape
plum
kiwi
grape
front
rear
front
rear
Operation
Queue
Queue

6. 5.2 Queue Linked List Design
Data structure: For the linked list implementation of a queue, we use tow types of structures: a head and a node.
Queue head: The queue head contains the two pointers and a count of the queue.
Queue data node: The queue data node contains the user data and a link field pointing to the next node .

7. front rear front count rear data next plum kiwi grape fig front rear
Conceptual queue
front
rear 4
plum
kiwi
grape
fig
front
rear
Physical queue
front
count
rear
data
next
Head structure
Node structure

8. Queue Algorithms
Create queue: set the metadata pointers to null and the count to 0.
No queue
front
count
rear
front
count
rear ? ? ?
Before
After
Algorithm createQueue (ref queue <metadata>
queue.fornt = null
Queue.rear = null
Queue.count = 0
End createQueue

9. Enqueue: Three conditions need to be considered:
1.insert into an empty queue.
2. Insert into a queue with data.
3. Insertinto a queue when there is no memory left in the heap.
front
count
rear
front
count
rear 1
data
next
data
next
newPtr
plum
plum
newPtr
After
Before
Insert into empty queue

10. plum next data front rear count kiwi plum next data 1 front rear count
Algorithm enqueue (ref queue<metadata>
dataIn <dataType>
If (queue full)
1 return false
End if
Allocate (newPtr)
newPtr->data = dataIn
newPtr->next = null pointer
If (queue.count zero)
// inserting into null queue
1 queue.front = newPtr
Else // insert data
1 queue.rear->next = newPtr
Queue.rear = newPtr
Queue.count = queue.count + 1
Return true
End enqueue
plum
next
data 1
front
rear
count
kiwi
newPtr
There are four ways to test if the queue is null 1.Front null
2.Rear null
3.Count 0
4.Emptyqueue
Before
plum
next
data 2
front
rear
count
kiwi
newPtr
After
Insert into queue with data

11. Dequeue: 1. Ensure that the queue contains data. 2
Dequeue: 1. Ensure that the queue contains data. 2. Pass the data back through the parameter list and then set the front pointer to the next item in the queue. 3. If the queue is now empty, set the rear pointer to null.
plum
next
data 1
front
rear
count
front
count
rear
(recycled)
deleteLoc
Before
After
Delete only item in queue

12. plum next data front rear count kiwi front count rear data data next2
front
rear
count
kiwi
Algorithm dequeue (ref queue <metadata>
ref item <dataType>)
If (queue.count is 0)
1 return false
End if
Item = queue.front->data
deleteLoc = queue.front
If (queue.count 1)
// Delete only item in queue
1 queue.rear = null pointer
Queue.front = queue.front->next
Queue.count = queue.count – 1
Recycle (deleteLoc)
Return true
End dequeue
Before
front
count
rear 1
data
next
data
next
plum
kiwi
(recycled)
After
deleteLoc

13. Retrieving Queue Data: the logic of retrieving data is the same to that of dequeue except that the data are not deleted from the queue.
Algorithm queueFront ( val queue <metadata>,
ref dataOut <dataType>)
If (queue.count is 0)
1 return false
End if
dataOut = queue.front->data
Return true
End queueFront

14. Empty Queue: it returns true if the queue is empty and false if the queue contains data.
Algorithm emptyQueue ( val queue <metadata>)
Return (queue.count equal 0)
End emptyQueue
Full Queue: By allocating a node and then releasing the memory we can determine whether there is room for at least one more node.
Algorithm fullQueue ( val queue <metadata>)
Allocate (tempPtr)
If (allocate successful)
1 recycle (tempPtr)
2 return false
Else
1 return true
End if
End fullQueue

15. Queue Count: it returns the number of elements currently in the queue by returning the count found in the queue head node.
Algorithm Queuecount ( val queue <metadata>)
Return (queue.count)
End queueCount
Destroy Queue: it deletes all data in the queue and recycles their memory.
Algorithm destroyQueue ( ref queue <metadata>)
pWalker = queue.front
Loop (pWalker not null)
1 deletePtr = pWalker
2 pWalker = pWalker.next
3 recycle (deletePtr)
End loop
Queue.front = null
Queue.rear = null
Queue.count = 0
return
End destroyQueue

16. 5.3 Queuing Theory
Queuing theory is a field of applied mathematics that is used to predict the performance of queues.
A Single-server queue can provide service to only one customer at a time.
Example: the hot-food vendor.
A Multi-server queue can provide service to many customers at a time.
Example: a bank in which there is one line with many bank tellers providing service.

17. Two elements to all queues
A customer is any person or thing needing service. Such as jobs in computer, packages being sent…
The service is any activity needed to accomplish the required result.
Two factors affect the queue
The arriving rate(比率) is the rate at which customers arrive in the queue for service. Depending on the service being provided, the arrival rate may be random or regular.
Service time is the average time required to complete the processing of a customer request.
The arriving rate and service time are the factors that most affect the performance of queues.

18. The faster customers arrive and the higher the service time, the longer the queue will be.
The ideal is arrival rate matches service time
The importance of queuing theory: it can predict the queue patterns including queue time(that is, the average length of time customers wait in the queue), the average size of the queue, and the maximum queue size. So, we can build a model of queue and used the model to study proposed changes to the system.
For example, In the banking queue, if we were able to add automation improvements that would reduce the average service by 15%,how many fewer tellers would we need?

19. Queue time Service time Response time Queue Server
A queuing theory model

20. 5.4 Queue Applications
Two queue implementations: Queue simulation and categorizing data
Queue simulation: a modeling activity used to generate statistics about the performance of queues.
An example: a saltwater taffy store on a beach boardwalk. The store has one window and a clerk can service only one customer at a time. The store also ships boxes of taffy anywhere in the country.The time to serve customers varies between 1 and 10 minutes.(8hs per day, 7 days a week)

21. Events:
completed process new customer module: determine the arrival of a new customer. The owner found that, on average , a customer arrives every 4 minutes. An arrival rate is simulated by using a random number generator that returns a values between 1 and 4.
If = 4, customer arrived; 1,2,3 customer not arrived.
server free module: determine whether the clerk is busy or idle. If the clerk is idle, then the next waiting customer in line can be served. If the clerk is busy, then the waiting customers remain in the queue.
Completed processing: determine whether it has completed processing for the current customer. Then processing time for the current customer is determined by a random number generator when the processing is started. When customers has been completely served, we gather statistics about sale and set server to an idle state

22. Data structures:
Four data structure are required for the queue simulation
Queue head: It contains two node pointers – front and rear – and a count of the number of elements currently in the queue.
Queue node: It contains the customer data and a next node pointer. The customer data consist of a sequential customer number and the arrival time.
Current Customer status: We use customer’s number, arrival time, the start time and the processing time to describe customer status.(random generator to calculate)
Simulation statistics: It stores the total number of customers processed in the simulation, the total and average service time, the total and average wait time, and the maximum number of customers in the queue at one time.

23. front rear count head next node custNum arriveTime startTime svcTime2
front
rear
count
head
next
custNum
arriveTime
node
custNum
arriveTime
startTime
svcTime
custStatus
numCust
totSvcTime
totWaitTime
maxQueueSize
simStats
Figure 5-13 queue data structures

24. Output: the statistics gathered during the simulation and the average queue wait time and average queue service time, the basic statistics for each customer: arrival time, start time, wait time, service time etc.
Simulator
Create
queue
New
customer
Server
free
Service
complete
Print
stats
Figure 5-14 design for queue simulation

25. Simulation Algorithm Simulator custStatus Algorithm taffySimulation
custNum <integer>
arriveTime <integer>
startTime <integer>
svcTime <integer>
end custstatus
simStats
numCust <integer>
totSvcTime <integer>
totWaitTime <integer>
maxQueueSize <integer>
end simstats
Algorithm taffySimulation
Data Structures
data
number <integer>
arrivalTime <integer>
end data
head
front <node pointer>
count <integer>
rear <node pointer>
end head
node
custData <data>
next <node pointer>
end node

26. Algorithm 5-9 queue simulation: driver
Statements
CreateQueue (queue)
Clock = 1
endTime = 8*60
custNum = 0
Loop (clock <=endTime or moreCusts)
1 newCustomer (queue, clock, custNum)
2 serverFree (queue, clock, custStatus, moreCusts)
3 svcComplete (queue, clock, custStatus, runStats, moreCusts)
4 if ( not emptyQueue (queue))
1 moreCusts = true
5 end if
6 clock = clock + 1
End loop
printStats (runStats)
return
end taffySimulation
Algorithm 5-9 queue simulation: driver

27. New customer Algorithm newCustomer (ref queue < metadata >,
val clock <integer>,
ref custNum <integer>)
Arrival = (random number modulo 4) + 1
If (arrival equal 4)
// new customer has arrived
1 custNum = custNum + 1
2 custData.number = custNum
3 custData.arriveTime = clock
4 enqueue (queue, custData)
End if
Return
End newCustomer

28. Server free Algorithm serverFree ( ref queue <metadata>,
val clock <integer> ,
ref status <custStastus>,
ref moreCusts <Boolean> )
If (clock > status.startTime + status.svcTime – 1) // server is idle
1 if (not emptyQueue (queue))
1 dequeue (queue,custData)
2 status.custNum = custData.number
3 status.arriveTime = custData.arriverTime
4 status.startTime = clock
5 status.svcTime = random service time
6 moreCusts = true
2 end if
End if
Return
End serverFreestatus

29. Service complete Algorithm svcComplete (ref queue <metadata>,
val clock <integer>,
ref status <custStatus>,
ref stats <simStats>,
ref moreCusts <Boolean>)
If (clock equal status.startTime + status.svcTime – 1) //current call complete
1 waitTime = status.startTime – status.arriveTime
2 stats.numCust = stats.numCust + 1
3 stats.totSvcTime = stats.totSvcTime + status.svcTime
4 stas.totWaitTime = stats.totWaitTime + waitTime
5 queueSize = queueCount (queue)
6 if (stas.maxQueueSize < queueSize)
1 stats.maxQueueSize = queueSize
7 end if
8 print ( status.custNum status.arriveTime
status.startTime status.svcTime
waitTime queueCount(queue))
9 moreCusts = false
Return
End svcComplete

30. Print stats Algorithm printStats ( stats <simStats> )
Print (Simulation Statistics: )
Print (Total customers: stats.numCust)
Print (Total service time: stats.totSvcTime)
avrgSvcTime = stats.totSvcTime / stats.numCust
Print (Average service time: arvgSvcTime)
avrgWaitTime = stats.totWaitTime / stats.numCust
Print (Average wait time: avrgWaitTime)
Print (,Maximum queue size: stats.maxQueueSize)
return
End printstats

31. For example, given the following list of numbers
Categorizing Data: It is often necessary to rearrange data without destroying their basic sequence.
For example, given the following list of numbers
then categorize them into four different groups:
Group1: less than 10
Group2: between 10 and 19
Group3: between 20 and 29
Group4: 30 and greater

32. Algorithm categorize
CreateQueue (q0to9)
createQueue (q10to19)
createQueue (q20to29)
createQueue (qOver29)
fillQueues (q0t09, q10to19,q20to29, qOver29)
printQueues (q0to9, q10to19, q20to29,qOver29)
Return
End categorize

33. Algorithm fillQueues (ref q0to9 <metadata>,
ref qOver29 <metadata>)
Loop (not EOF)
1 read (number)
2 if (number < 10)
1 enqueue (q0to9, number)
3 elseif (number<20)
1 enqueue (q10to19, number)
4 elseif (number<30)
1 enqueue (q20to29, number)
5 else
1 enqueue (qOver29, number)
6 end if
End loop
Return
End fillQueue

34. 5.8 Summary
A queue is a linear list in which data can only be inserted at one end, called the rear, and deleted from the other end, called the front.
A queue is a first in-first out (FIFO) structure.
There are four basic queue operations: enqueue, dequeue, queue front, and queue rear.
The enqueue operation inserts an element at the rear of the queue.
The dequeue operation deletes the element at the front of the queue.
The queue front operation examines the element at the front of the queue without deleting it.
The queue rear operation examines the element at the rear of the queue without deleting it.

35. To implement the queue using a linked list, we use two types of structures: a head and a node.
Queuing theory is a field of applied mathematics that is used to predict the performance of queues.
Queue applications can be divided into single servers and multi-servers.
A single-server queue application provides service to only one customer at a time.
A multi-server queue application provides service to only several customers at a time.
The two features that most affect the performance of queues are the arrival rate and the service time.
The rate at which the customers arrive in the queue for service is known as the arrival rate.
Service time is the average time required to complete the processing of a customer request.

36. The queue time is the average length of time customers wait in the queue.
The response time is a measure of average time from the point at which customers enter the queue until the moment they leave the server. It is queue time plus service time.
One application of queues is queue simulation, which is a modeling activity used to generate statistics about the performance of a queue.
Another application of queues is categorization. Queues are used to categorize data into different groups without losing the original ordering of the data.
Queues can be implemented suing linked lists or arrays.

37. Exercise
Imagine you have a stack of integers,S ,and a queue of integers,Q. Draw a picture of S and Q after the following operation:
PushStack(S,3)
PushStack(S,12)
Enqueue(Q,5)
Enqueue(Q,8)
PopStack(S,x)
pushStack(S,2)
Enqueue(Q,x)
Dequeue(Q,y)
PushStack(S,x)
PushStack(S,y)

38. Exercise
What would be the contents of queue Q1 and Q2 after the following code is executed and the following data are entered?
Q1=createQueue
Q2=createQueue
Loop (not end of file)
read number
enqueue(Q1,number)
enqueue(Q2,number)
loop (Not empty Q1)
dequeue(Q1,x)
enqueue(Q2,x)
End loop
The data are 5,7,12,4,0,4,6