Queues. Data structures that wait their turn. queues 1

Size: px

Start display at page:

Download "Queues. Data structures that wait their turn. queues 1"

Chester Singleton
6 years ago
Views:

1 Queues Data structures that wait their turn queues 1

2 Queue characteristics FIFO: first in, first out insertion of items occurs at one end, removal occurs at the other end first item inserted is the first item removed; second inserted is second removed, third is third, etc. queues 2

3 Queue characteristics Structure is very similar to stack, with much the same considerations -- still subject to overflow and underflow Unlike stack, queue is accessible at both ends Entry and removal still occur at one end -- but each operation occurs at a different end queues 3

4 Java s Queue interface Unlike the Stack ADT, the Java API doesn t provide a full implementation of a generic Queue The Queue interface specifies methods for working with a queue, most of which are listed on the next slide There are several API classes that implement the interface, but each of these adds methods not specified by the interface queues 4

5 Queue ADT member methods Constructor(s) Modifiers enqueue (insert item at back): add dequeue (remove item at front): remove Observers size isempty queues 5

6 Queue implementations The API classes that implement the Queue interface are designed for more sophisticated uses than the simple interface implies We can implement a simple queue using either an array or a linked list as the basic structure queues 6

7 Array implementation public class ArrayQueue<E> implements Cloneable { private Object [ ] data; private int manyitems; private int front; private int rear; queues 7

8 Array implementation public ArrayQueue( ) { final int INITIAL_CAPACITY = 10; manyitems = 0; data = new Object[INITIAL_CAPACITY]; // Since queue is empty, front and rear values // don t matter queues 8

9 Array implementation public ArrayQueue(int initialcapacity) { if (initialcapacity < 0) throw new IllegalArgumentException ("initialcapacity is negative: " + initialcapacity); manyitems = 0; data = new Object[initialCapacity]; queues 9

10 Array implementation public ArrayQueue<E> clone( ) { ArrayQueue<E> answer; try { answer = (ArrayQueue<E>) super.clone( ); catch (CloneNotSupportedException e) { throw new RuntimeException ("This class does not implement Cloneable"); answer.data = data.clone( ); return answer; queues 10

11 Enqueue and dequeue not as simple as they look! // first attempt at enqueue public void add (E item) { if (manyitems == 0) { front = 0; rear = 0; else rear++; data[rear]=item; manyitems++; queues 11

12 dequeue (first attempt) public E remove( ) { E answer; if (manyitems == 0) throw new NoSuchElementException("Queue underflow"); answer = (E)data[front]; front++; manyitems--; return answer; queues 12

13 Problems!!! Consider a queue with a capacity of 3: As items are added, rear approaches capacity: As items are removed, front approaches back: Situation: queue isn t full (manyitems = 0) but attempt to add an item will go beyond array boundary queues 13

14 Possible solution Maintain fixed front of queue: // dequeue method: answer = (E)data[0]; for (int x=0; x<rear; x++) data[x]=data[x+1]; Increases complexity of algorithm considerably -- we ve gone from O(1) operation in original function to O(N) queues 14

15 Better solution: circular array Let front continue to float, but add ability for rear to float as well When rear reaches index capacity-1, if queue isn t full, rear=0 In effect, the successor of the last array index is the first array index -- array can be thought of as circular Can also grow array as necessary queues 15

16 Circular queue implementation Add helper function nextindex as private method of queue class: private int nextindex(int i) { if (++i == data.length) return 0; else return i; Call method from enqueue and dequeue queues 16

17 New enqueue method public void add(e item) { if (manyitems == data.length) ensurecapacity(manyitems*2 + 1); if (manyitems == 0) { front = 0; rear = 0; else rear = nextindex(rear); data[rear] = item; manyitems++; queues 17

18 New dequeue method public E remove( ) { E answer; if (manyitems == 0) throw new NoSuchElementException("Queue underflow"); answer = (E)data[front]; front = nextindex(front); manyitems--; return answer; queues 18

19 Other methods Besides the queue-specific methods (and clone()), the ArrayQueue implementation includes a few other methods: ensurecapacity getcapacity isempty queues 19

20 Invariant for revised queue Number of items on queue stored in variable manyitems Items are stored in circular array from data[front] to data[rear] If queue is empty, manyitems == 0 and the values of front and rear are undefined queues 20

21 Queue as linked list Implementation using linked list is actually easier Need to decide which end of list is which; easiest implementation is to have the head pointer point to the front of the list, and maintain another pointer to keep track of the back queues 21

22 Queue as Linked List Implementation seen here is based on Node<E> class from text; could be even simpler if LinkedListWithNode implementation was chosen Ironically, the Java API s LinkedList class implements the Queue interface, and will be our preferred implementation when we look at queue applications queues

23 Code for linked list queue public class LinkedQueue<E> implements Cloneable{ private int manynodes; private Node<E> front; private Node<E> rear; public LinkedQueue( ) { front = null; rear = null; manynodes = 0; queues 23

24 Code for linked list queue public void add(e item) { if (isempty( )) { front = new Node<E>(item, null); rear = front; else { rear.addnodeafter(item); rear = rear.getlink( ); manynodes++; queues 24

25 Code for linked list queue public LinkedQueue<E> clone( ) { LinkedQueue<E> answer; Node<E>[ ] cloneinfo; try { answer = (LinkedQueue<E>) super.clone( ); catch (CloneNotSupportedException e) { throw new RuntimeException ("This class does not implement Cloneable"); queues 25

26 Clone method continued cloneinfo = Node.listCopyWithTail(front); answer.front = cloneinfo[0]; answer.rear = cloneinfo[1]; return answer; queues 26

27 Code for linked list queue public boolean isempty( ) { return (manynodes == 0); public int size( ) { return manynodes; queues 27

28 Code for linked list queue public E remove( ) { E answer; if (manynodes == 0) throw new NoSuchElementException("Queue underflow"); answer = front.getdata( ); front = front.getlink( ); manynodes--; if (manynodes == 0) rear = null; return answer; queues 28

29 Invariant for linked list implementation The number of items in the queue is stored in the instance variable manynodes. The items in the queue are stored in a linked list, with the front of the queue stored at the head node, and the rear of the queue at the final node. For a non-empty queue, the instance variable front is the head reference of the linked list and the instance variable rear is the tail reference. For an empty queue, both front and rear are the null reference. queues 29

30 Priority Queues Variation on an ordinary queue -- stores entries and a priority value for each entry Elements are dequeued according to priority, highest first In case of a tie, priority queue reverts to FIFO behavior queues2 30

31 PQ implementation One strategy is to create an array of ordinary queues each element in the array would be a queue of items all items in any given queue have equal priority Array index indicates priority level queues2 31

32 PQ Implementation public class PQ<E> { private Queue[] queues; // API Queue interface public int highest; public int total; public int highcurrent; public PQ (int h) { // LinkedList implements Queue highest = h; queues = new LinkedList[h+1]; for (int x=0; x<h+1; x++) { queues[x] = new LinkedList(); total = 0; highcurrent = 0; queues2 32

33 PQ implementation public int size () { return total; public boolean is_empty() { return (total == 0); queues2 33

34 Enqueue method public void PQenqueue(E entry, int priority){ assert (priority <= highest); // check if highest priority entry so far: if (priority > highcurrent) highcurrent = priority; // place entry in queue: queues[priority].add(entry); // increment count of total entries: total++; queues2 34

35 Dequeue method public E PQdequeue(){ assert (size() > 0); int p = highcurrent; total--; for(; p>=0; p--) if (!queues[p].isempty()){ highcurrent = p; return(e)(queues[p].remove()); return (E)(queues[p].remove()); queues2 35

36 Queue Applications

37 Palindrome recognition Palindrome: collection of characters that reads the same backwards and forwards Examples: otto is a palindrome is a palindrome snub no man; nice cinnamon buns! is a palindrome, if you ignore spaces and punctuation queues2 37

38 Palindrome recognition program Read string, storing each character in both a stack and a queue Once string is read, pop stack and dequeue queue, comparing characters if all characters have matched when both structures are empty, you ve got a palindrome queues2 38

39 Palindrome recognition program import java.util.linkedlist; // implements Queue interface import java.util.queue; import java.util.stack; import java.util.scanner; public class Palindrome { queues2 39

40 Palindrome recognition program public static void main(string[ ] args) { Scanner stdin = new Scanner(System.in); String line; do { System.out.print("Your expression (or return to end): "); line = stdin.nextline( ); if (is_palindrome(line)) System.out.println("That is a palindrome."); else System.out.println("That is not a palindrome."); while (line.length( )!= 0); queues2 40

41 Palindrome recognition program public static boolean is_palindrome(string input) { Queue<Character> q = new LinkedList<Character>( ); Stack<Character> s = new Stack<Character>( ); Character letter; int i; for (i = 0; i < input.length( ); i++) { letter = input.charat(i); if (Character.isLetter(letter)) { q.add(letter); s.push(letter); queues2 41

42 Palindrome recognition program while (!q.isempty( )) { if (q.remove( )!= s.pop( )) return false; return true; // end of method // end of class queues2 42

43 Using queues for simulation Many real-world situations can be simulated by employing a queue or queues to represent clients waiting for service Clients might be cars at a traffic light, customers at a grocery store, jobs awaiting CPU time in a computer, etc. Clients are represented by number indicating time of entry into the queue queues2 43

44 Queue simulation program Inputs: amount of time needed to serve one client probability of customer arriving at any given time length of simulation Outputs: number of clients served during simulation average time spent waiting in line queues2 44

45 Queue simulation program: required data structures Queue of clients -- represented by time stamp (second when user entered queue) Server -- an object that simulates the service to be performed -- includes: start( ) method reduceremainingtime( ) method isbusy( ) method variables secondsforservice, timeleft constructor that establishes variable values queues2 45

46 Queue simulation program: required data structures ClientGenerator: reports whether or not a client has arrived in a given second, using probability input to determine odds of arrival Averager: tracks total number of customers served and average time spent waiting in queue queues2 46

47 Simulation: main method import java.util.*; public class CarWash { public static void main(string[ ] args) { final int WASHTIME = 240; final double ARRIVALPROB = ; final int TOTALTIME = 6000; carwashsimulate(washtime, ARRIVALPROB, TOTALTIME); queues2 47

48 Simulation: carwashsimulate() public static void carwashsimulate (int washtime, double arrivalprob, int totaltime) { Queue<Integer> arrivaltimes = new LinkedList<Integer>( ); int next; ClientGenerator arrival = new ClientGenerator(arrivalProb); Server machine = new Server(washTime); Averager waittimes = new Averager( ); int currentsecond; System.out.println("Seconds to wash one car: " + washtime); System.out.print("Probability of customer arrival during a second: "); System.out.println(arrivalProb); System.out.println("Total simulation seconds: " + totaltime); queues2 48

49 carwashsimulate continued if (washtime <= 0 arrivalprob < 0 arrivalprob > 1 totaltime < 0) throw new IllegalArgumentException("Values out of range"); for (currentsecond = 0; currentsecond < totaltime; currentsecond++) { if (arrival.query( )) arrivaltimes.add(currentsecond); if ((!machine.isbusy( )) && (!arrivaltimes.isempty( ))) { next = arrivaltimes.remove( ); waittimes.addnumber(currentsecond - next); machine.start( ); // end if queues2 49

50 carwashsimulate continued // Subtract one second from the time in the current wash cycle. machine.reduceremainingtime( ); // end of for loop // Write the summary information about the simulation. System.out.println("Customers served: " + waittimes.howmanynumbers( )); if (waittimes.howmanynumbers( ) > 0) System.out.println("Average wait: " + waittimes.average( ) + " sec"); // end method // end class queues2 50

51 Server class public class Server { private int secondsforservice; private int timeleft; public Server(int s) { secondsforservice = s; timeleft =0; queues2 51

52 Server class public boolean isbusy( ) { return (timeleft > 0); public void reduceremainingtime( ) { if (timeleft > 0) timeleft--; queues2 52

53 Server Class public void start( ) { if (timeleft > 0) throw new IllegalStateException ("Server is already busy."); timeleft = secondsforservice; // end class queues2 53

54 ClientGenerator class public class ClientGenerator { private double probability; public ClientGenerator(double p) { if ((p < 0) (1 < p)) throw new IllegalArgumentException ("Illegal p: " + p); probability = p; queues2 54

55 ClientGenerator class public boolean query( ) { return (Math.random( ) < probability); // end class queues2 55

56 Averager class public class Averager { private int count; private double sum; public Averager( ) { count =0; sum = 0; queues2 56

57 Averager class public void addnumber(double value) { if (count == Integer.MAX_VALUE) throw new IllegalStateException ("Too many numbers"); count++; sum += value; queues2 57

58 Averager class public double average( ) { if (count == 0) return Double.NaN; else return sum/count; public int howmanynumbers( ) { return count; // end class queues2 58

Stacks. The unorganized person s data structure. stacks 1

Stacks. The unorganized person s data structure. stacks 1 Stacks The unorganized person s data structure stacks 1 Stack characteristics Entries are ordered in terms of access -- both insertion and removal take place at same spot (top of stack) Specialized type