COMP 213 Advanced Object-oriented Programming Lecture 8 The Queue ADT (cont.)

Transcription

1 COMP 213 Advanced Object-oriented Programming Lecture 8 The Queue ADT (cont.)

2 Recall: The Queue ADT A data structure in which elements enter at one end and are removed from the opposite end is called a queue. 2 main operations: enqueue dequeue

3 Recall: Formal Specification Our queues are generic the type of object held by a particular queue is indicated by the client. We provide observer operations isempty and isfull. We create a QueueInterface that defines the signatures of the queue methods that do not depend on the boundedness of the queue. We create a BoundedQueueInterface and an UnboundedQueueInterface, which extend QueueInterface.

4 Array-Based Implementation for unbounded queue Class ArrayUnbQueue that implements the UnboundedQueueInterface. The trick here is to create a new larger array, when needed, and copy the structure into the new array. No need for isfull method.

5 Array-Based Implementation for unbounded queue Class ArrayUnbQueue that implements the UnboundedQueueInterface. The trick here is to create a new larger array, when needed, and copy the structure into the new array. No need for isfull method.

6 Array-Based Implementation for unbounded queue Class ArrayUnbQueue that implements the UnboundedQueueInterface. The trick here is to create a new larger array, when needed, and copy the structure into the new array. No need for isfull method.

7 Unbounded vs. bounded implementation: what changes? enqueue method to increase the capacity of the array if it has run out of space. we implement it as a separate method named enlarge. Then, the enqueue method can start with: if (numelements == queue.length) enlarge();

8 Unbounded vs. bounded implementation: what changes? enqueue method to increase the capacity of the array if it has run out of space. we implement it as a separate method named enlarge. Then, the enqueue method can start with: if (numelements == queue.length) enlarge();

9 Unbounded vs. bounded implementation: what changes? enqueue method to increase the capacity of the array if it has run out of space. we implement it as a separate method named enlarge. Then, the enqueue method can start with: if (numelements == queue.length) enlarge();

10 Options for the enlarge method We could set a constant increment value or multiplying factor within the class. We could allow the application to specify an increment value or multiplying factor when the queue is instantiated. We could use the original capacity as the increment value.

11 Options for the enlarge method We could set a constant increment value or multiplying factor within the class. We could allow the application to specify an increment value or multiplying factor when the queue is instantiated. We could use the original capacity as the increment value.

12 Options for the enlarge method We could set a constant increment value or multiplying factor within the class. We could allow the application to specify an increment value or multiplying factor when the queue is instantiated. We could use the original capacity as the increment value.

13 Brainstorming The enlarge operation is costly increment by large amount. Increment too much waste of both time & space. Let us use henceforth the original capacity as the increment value: Instantiate an array with a size equal to the current capacity plus the original capacity. Remember the original capacity using an instance variable origicap.

14 Brainstorming The enlarge operation is costly increment by large amount. Increment too much waste of both time & space. Let us use henceforth the original capacity as the increment value: Instantiate an array with a size equal to the current capacity plus the original capacity. Remember the original capacity using an instance variable origicap.

15 Brainstorming The enlarge operation is costly increment by large amount. Increment too much waste of both time & space. Let us use henceforth the original capacity as the increment value: Instantiate an array with a size equal to the current capacity plus the original capacity. Remember the original capacity using an instance variable origicap.

16 Brainstorming The enlarge operation is costly increment by large amount. Increment too much waste of both time & space. Let us use henceforth the original capacity as the increment value: Instantiate an array with a size equal to the current capacity plus the original capacity. Remember the original capacity using an instance variable origicap.

17 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

18 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

19 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

20 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

21 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

22 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

23 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

24 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

25 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { protected final int DEFAULTCAP = 100; // default capacity protected Object[] queue; // array that holds queue elements protected int origicap; // original capacity protected int numelements = 0; // number of elements in the queue protected int front = 0; // index of front of queue protected int rear = -1; // index of rear of queue public ArrayUnbQueue() { queue = new Object[DEFAULTCAP]; rear = DEFAULTCAP - 1; origicap = DEFAULTCAP; public ArrayBoundedQueue(int origicap) { queue = new Object[origiCap]; rear = origicap- 1; this.origicap = origicap;

26 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

27 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

28 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

29 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

30 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

31 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

32 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface { // Increments the capacity of the queue by an amount equal to the original capacity. private void enlarge() { // Create a larger array. Object[] larger = new Object[queue.length + origicap]; // Copy the elements from the smaller to the larger array. int currsmaller = front; for (int currlarger = 0; currlarger < numelements; currlarger++){ larger[currlarger] = queue[currsmaller]; currsmaller = (currsmaller+1)%queue.length; // Update the instance variables. queue = larger; front = 0; rear = numelements - 1;

33 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public void enqueue(object element) { if(numelements == queue.length) enlarge(); rear = (rear+1)%queue.length; queue[rear] = element; numelements = numelements + 1;

34 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public void enqueue(object element) { if(numelements == queue.length) enlarge(); rear = (rear+1)%queue.length; queue[rear] = element; numelements = numelements + 1;

35 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public void enqueue(object element) { if(numelements == queue.length) enlarge(); rear = (rear+1)%queue.length; queue[rear] = element; numelements = numelements + 1;

36 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public void enqueue(object element) { if(numelements == queue.length) enlarge(); rear = (rear+1)%queue.length; queue[rear] = element; numelements = numelements + 1;

37 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public void enqueue(object element) { if(numelements == queue.length) enlarge(); rear = (rear+1)%queue.length; queue[rear] = element; numelements = numelements + 1;

38 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public void enqueue(object element) { if(numelements == queue.length) enlarge(); rear = (rear+1)%queue.length; queue[rear] = element; numelements = numelements + 1;

39 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public Object dequeue() { if (isempty()){ System.out.println("Dequeue attempted on an empty queue!"); return null; else { Object itemtoreturn = queue[front]; queue[front] = null; front = (front + 1) % queue.length; numelements = numelements - 1; return itemtoreturn;

40 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public Object dequeue() { if (isempty()){ System.out.println("Dequeue attempted on an empty queue!"); return null; else { Object itemtoreturn = queue[front]; queue[front] = null; front = (front + 1) % queue.length; numelements = numelements - 1; return itemtoreturn;

41 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public Object dequeue() { if (isempty()){ System.out.println("Dequeue attempted on an empty queue!"); return null; else { Object itemtoreturn = queue[front]; queue[front] = null; front = (front + 1) % queue.length; numelements = numelements - 1; return itemtoreturn;

42 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public Object dequeue() { if (isempty()){ System.out.println("Dequeue attempted on an empty queue!"); return null; else { Object itemtoreturn = queue[front]; queue[front] = null; front = (front + 1) % queue.length; numelements = numelements - 1; return itemtoreturn;

43 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public boolean isempty() { return (numelements == 0);

44 Implementation of our queue public class ArrayUnbQueue implements UnboundedQueueInterface public boolean isempty() { return (numelements == 0);

45 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: It does not require elements to be inserted into the rear of the queue. For example, inserted elements might be ordered based on a priority value.

46 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: It does not require elements to be inserted into the rear of the queue. For example, inserted elements might be ordered based on a priority value.

47 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: It extends the Collection interface, so any class that implements it must also implement eight predefined abstract methods (e.g., to observe the size of the queue and to turn the queue into an array).

48 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: No separate interfaces for bounded and unbounded queues exist. Instead, the programmer chooses whether to place a limit on the number of elements a queue holds.

49 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: It provides 2 operations for enqueuing: -add (throws an exception if invoked on a full queue) -offer (returns a boolean value of false if invoked on a full queue).

50 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: It provides two operations for dequeuing: -remove (throws an exception) -poll (returns false, when invoked on an empty queue).

51 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: Operations for obtaining the front element, without removing it, are also included. The Java library Collections Framework includes 9 classes that implement its Queue interface.

52 The Java Library Collection Framework Queue A Queue interface exists in the Java library Collection. This is similar to our Queue ADT interfaces (elements are always removed from the front ). However, it also has several differences: Operations for obtaining the front element, without removing it, are also included. The Java library Collections Framework includes 9 classes that implement its Queue interface.

53 Interesting applications Identifying palindromes. A palindrome is a string that reads the same forward and backward: Madam, I m Adam. Eve Implementing decks in card games

54 Interesting applications Identifying palindromes. A palindrome is a string that reads the same forward and backward: Madam, I m Adam. Eve Implementing decks in card games

55 The List ADT Lists are one of the most widely used ADTs in computer science, which is only natural given how often we use them in daily life. The list of the kinds of lists that we make is endless! With a list, unlike with queues & stacks, we access elements within the structure: check if element is contained, insert name in alphabetical order, delete an entry

56 The List ADT Lists are one of the most widely used ADTs in computer science, which is only natural given how often we use them in daily life. The list of the kinds of lists that we make is endless! With a list, unlike with queues & stacks, we access elements within the structure: check if element is contained, insert name in alphabetical order, delete an entry

57 The List ADT Lists are one of the most widely used ADTs in computer science, which is only natural given how often we use them in daily life. The list of the kinds of lists that we make is endless! With a list, unlike with queues & stacks, we access elements within the structure: check if element is contained, insert name in alphabetical order, delete an entry

58 The List ADT We only need a few variations of the List ADT to represent the majority of realworld lists: unsorted, sorted, indexed Most differences in list types relate to the types of values that they store, rather than to their structure or operations. An important structural difference is how the values are ordered with respect to one another within each type of list. List operations sometimes depend on the content of the list elements let us see how we can compare objects.

59 The List ADT We only need a few variations of the List ADT to represent the majority of realworld lists: unsorted, sorted, indexed Most differences in list types relate to the types of values that they store, rather than to their structure or operations. An important structural difference is how the values are ordered with respect to one another within each type of list. List operations sometimes depend on the content of the list elements let us see how we can compare objects.

60 The List ADT We only need a few variations of the List ADT to represent the majority of realworld lists: unsorted, sorted, indexed Most differences in list types relate to the types of values that they store, rather than to their structure or operations. An important structural difference is how the values are ordered with respect to one another within each type of list. List operations sometimes depend on the content of the list elements let us see how we can compare objects.

61 The List ADT We only need a few variations of the List ADT to represent the majority of realworld lists: unsorted, sorted, indexed Most differences in list types relate to the types of values that they store, rather than to their structure or operations. An important structural difference is how the values are ordered with respect to one another within each type of list. List operations sometimes depend on the content of the list elements let us see how we can compare objects.

62 The equals method The equals method, as defined in the Object class, acts in much the same way as the comparison operator. It returns true if and only if the two variables reference the same object. We can redefine the method within a class to fit the goals of the class. We can then use the method to, e.g., check if a particular element is on a particular list.

63 The equals method The equals method, as defined in the Object class, acts in much the same way as the comparison operator. It returns true if and only if the two variables reference the same object. We can redefine the method within a class to fit the goals of the class. We can then use the method to, e.g., check if a particular element is on a particular list.

64 The equals method The equals method, as defined in the Object class, acts in much the same way as the comparison operator. It returns true if and only if the two variables reference the same object. We can redefine the method within a class to fit the goals of the class. We can then use the method to, e.g., check if a particular element is on a particular list.

65 The equals method int A int B 8 8 int A == int B evaluates to true.

66 The equals method int A int B 8 5 int A == int B evaluates to false.

67 The equals method Circle c1 c1 == c2 evaluates to false. Circle c2

68 The equals method Circle c1 c1 == c2 evaluates to true. Circle c2

69 The equals method public class Circle { int radius; Circle(int someradius){ this.radius = someradius; public boolean equals(circle circle){ if(this.radius == circle.radius) return true; else return false; public static void main(string[] args) { Circle c1 = new Circle(3); System.out.println(c1.radius); Circle c2 = new Circle(3); System.out.println(c2.equals(c1)); We redefine the equals method to fit the goals of the class.

70 Summary The Queue ADT Implementation of unbounded queues The Java Library Collection Framework Queue Introduction to Lists and the equals method Next: The List ADT