Problem Solving with Data Structures using Java: A Multimedia Approach
description
Transcript of Problem Solving with Data Structures using Java: A Multimedia Approach
![Page 1: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/1.jpg)
Problem Solving with Data Structures using Java: A Multimedia Approach
Chapter 11: Abstract Data Types: Separating the
Meaning from the Implementation
![Page 2: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/2.jpg)
Chapter Objectives
![Page 3: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/3.jpg)
Separating Meaning from Implementation
Powerful engineering idea in computer science.• Meaning
• Identify the behavior of an object or data structure.
• Build other program components to interact with that behavior.
• Implementation• Hide how that behavior is implemented, so that no
program components can be dependent on the implementation.
![Page 4: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/4.jpg)
Abstract Data Type: Stacks
An example of an Abstract Data Type (ADT):• We can define the methods and the
behavior apart from any implementation.
• There are multiple implementations, some better than others.
Can use a stack to reverse a list in less time, but more space.• A classic tradeoff!
Space for time.
Only put on top,Never pull from
bottom.
![Page 5: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/5.jpg)
A Stack is a LIFO List
Last-In-First-Out (LIFO) List• First item in the list is the last one out.
• Last one in is first one out.
I got here first!
I got here second!
I got here third!
This is the top of the stack
![Page 6: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/6.jpg)
New items go at the top
I got here first!
I got here second!
I got here third!
This is the new top of the stack
I got here fourth!
![Page 7: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/7.jpg)
Items only get removed from the top
I got here first!
I got here second!
I got here third!
This is the new (er, old) top of the stack
I got here fourth! And now I’m outta here!
![Page 8: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/8.jpg)
What can we do with stacks?
push(anObject): Tack a new object onto the top of the stack
pop(): Pull the top (head) object off the stack.
peek(): Get the top of the stack, but don’t remove it from the stack.
size(): Return the size of the stack
![Page 9: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/9.jpg)
Separation of Concerns
Separation definition of behavior of data structure from implementation.
Lets one change without changing the other.
Java allows us to use an interface as a way specify that behavior definition.
![Page 10: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/10.jpg)
Stack Interface
/**
* An abstract definition of a stack
* @author Barb Ericson
*/
public interface Stack<E> {
/**
* Method to add the element to the top of the stack
* @param element the element to add
*/
public void push(E element);
/**
* Method to return the top element on the
* stack, but not remove it from the stack
* @return the top object from the stack
*/
public E peek();
Just defining the operations here.
E is the type of the things in the Stack.
Stack<E> represents the generic stack for any time element
Just defining the operations here.
E is the type of the things in the Stack.
Stack<E> represents the generic stack for any time element
![Page 11: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/11.jpg)
/**
* Method to remove the top element from the
* stack and return it
* @return the top element from the stack
*/
public E pop();
/**
* Method to return the number of elements in
* the stack
* @return the number of elements in the stack
*/
public int size();
/**
* Method to check if the stack is empty
* @return true if empty, else false
*/
public boolean isEmpty();
}
![Page 12: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/12.jpg)
Creating an implementation
We declare a class as implementing that interface.
We can continue to use the <E> generic, so that we can later create a stack for any type object.
![Page 13: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/13.jpg)
Stack as a LinkedList
import java.util.LinkedList; // Need for LinkedList
/**
* Class that represents a stack using a linked list
* of objects
* @author Mark Guzdial
* @author Barb Ericson
*/
public class LinkedListStack<E> implements Stack<E> {
/** Where we store the elements */
private LinkedList<E> elements;
/**
* Constructor that takes no arguments
*/
public LinkedListStack() {
elements = new LinkedList<E>();
}
![Page 14: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/14.jpg)
//// Methods ///
/**
* Method to add an element to the stack
* @param element the element to add
*/
public void push(E element) {
// New elements go at the front
elements.addFirst(element);
}
/**
* Method to return the top element on the stack
* but leave the element on the stack
* @return the top element on the stack
*/
public E peek() {
return elements.getFirst();
}
![Page 15: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/15.jpg)
/**
* Method to remove the top element from a stack
* and return it
* @return the top element from the stack and remove it
*/
public E pop() {
E toReturn = this.peek();
elements.removeFirst();
return toReturn;
}
/**
* Method to get the number of elements in the stack
* @return the number of elements in the stack
*/
public int size(){return elements.size();}
/**
* Method to test if the stack is empty
* @return true if the stack is empty, else false
*/
public boolean isEmpty() {
return (size() == 0);
}
}
![Page 16: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/16.jpg)
Using the Stack with Strings > Stack<String> stack = new LinkedListStack<String>();
> stack.push("This")
> stack.push("is")
> stack.push("a")
> stack.push("test")
> stack.size()
4
> stack.peek()
"test"
> stack.pop()
"test"
> stack.pop()
"a"
> stack.pop()
"is"
> stack.pop()
"This"
Notice the use of <String>
Notice the use of <String>
![Page 17: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/17.jpg)
A Stack ofPictures
> Stack<Picture> stack = new LinkedListStack<Picture>();
> stack.push(new Picture(FileChooser.getMediaPath("beach.jpg")));
> stack.push(new Picture(FileChooser.getMediaPath("arch.jpg")));
> stack.push(new Picture(FileChooser.getMediaPath("bridge.jpg")));
> stack.size()
3
> stack.peek()
Picture, filename C:\dsBook\media-source/bridge.jpg
height 640 width 480
> stack.pop()
Picture, filename C:\dsBook\media-source/bridge.jpg
height 640 width 480
> stack.pop()
Picture, filename C:\dsBook\media-source/arch.jpg
height 480 width 360
> stack.pop()
Picture, filename C:\dsBook\media-source/beach.jpg
height 480 width 640
Note: You can’t create an object using an interface name, e.g., new Stack<String>()
Note: You can’t create an object using an interface name, e.g., new Stack<String>()
![Page 18: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/18.jpg)
A stack is a stack, no matter what lies beneath. Our description of the stack minus the
implementation is an example of an abstract data type (ADT).• An abstract type is a description of the methods that a
data structure knows and what the methods do. We can actually write programs that use the
abstract data type without specifying the implementation. • There are actually many implementations that will
work for the given ADT.• Some are better than others.
![Page 19: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/19.jpg)
New implementation: Stack as Array
/**
* Implementation of a stack as an array
* @author Mark Guzdial
* @author Barb Ericson
*/
public class ArrayStack<E> implements Stack<E> {
/** default size of the array */
private static final int ARRAY_SIZE = 20;
/** Where we'll store our elements */
private Object[] elements;
![Page 20: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/20.jpg)
Constructor
/** Index where the top of the stack is */
private int top;
/**
* No argument constructor
*/
public ArrayStack() {
elements = new Object[ARRAY_SIZE];
top = 0;
}
![Page 21: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/21.jpg)
Methods for Stack as Array
/**
* Method to add an element to the top of the stack
* @param element the element to add
*/
public void push(E element) {
// New elements go at the top
elements[top]=element;
// then add to the top
top++;
if (top==ARRAY_SIZE) {
System.out.println("Stack overflow!");
}
}
![Page 22: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/22.jpg)
/**
* Method to return the top element on the stack
* but not remove it.
* @return the object at the top of the stack
*/
public E peek() {
if (top==0) {
System.out.println("Stack empty!");
return null;
} else {
// this will give a warning but it is unavoidable
return (E) elements[top-1];
}
}
![Page 23: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/23.jpg)
/**
* Method to remove and return the top element on the stack
* @return the element on the top of the stack
*/
public E pop() {
E toReturn = this.peek();
top--;
return toReturn;
}
/**
* Method to return the number of elements in the stack
* @return the number of elements in the stack
*/
public int size(){return top;}
/**
* Method to check if the stack is empty
* @return true if the stack is empty else false
*/
public boolean isEmpty() {return this.size() == 0;}
}
![Page 24: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/24.jpg)
Trying out Stack as Array
> Stack<String> stack = new ArrayStack<String>();
![Page 25: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/25.jpg)
Pushing one element
> stack.push("Matt");
![Page 26: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/26.jpg)
Push two more, pop one
> stack.push("Katie");
> stack.push("Jenny");
> stack.size() // without the ending ';' it prints out the result
3
> stack.peek() // without the ending ';' it prints out the result
"Jenny"
> stack.pop()
"Jenny"
![Page 27: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/27.jpg)
Critique the array-based implementation
What happens if the number of elements in the stack is more than 20?
![Page 28: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/28.jpg)
What are stacks good for?
The algorithm for converting an equation into a tree uses a stack.
Often use stacks when describing card games, like solitaire.
The list of Web pages you have visited in a browser is stored in a stack, so that you can go “back.”
The list of operations you have executed is stored in a stack, so that you can “undo.”
![Page 29: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/29.jpg)
Stacks describe function calls
As new functions get called, position in old functions get pushed on a stack.• So you always return to the last function you
were in.
• If an error occurs, you get a stack trace.
• If your recursion goes into an infinite loop, what error do you get? Stack overflow!
![Page 30: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/30.jpg)
A Stack Example: New Reverse
Recall our original implementation of reverse().• We go to the end of the original list to find the last().
• We then remove() it (which involves walking the list until we find the one before last())
• We then insert it at the end of the new list (via add(), which does last().insertAfter()).
All told: For each node, we walk the whole list three times.• O(n*n2)=O(n3)
![Page 31: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/31.jpg)
Original Reverse
/** * Reverse the list starting at this, * and return the last element of the list. * The last element becomes the FIRST element * of the list, and THIS points to null. */ public LayeredSceneElement reverse() { LayeredSceneElement reversed, temp;
// Handle the first node outside the loop reversed = this.last(); this.remove(reversed);
while (this.getNext() != null) { temp = this.last(); this.remove(temp); reversed.add(temp); }
// Now put the head of the old list on the end of // the reversed list. reversed.add(this);
// At this point, reversed // is the head of the list return reversed; }
Highly inefficient.Touching each node requires touching every other node: O(n2)
Highly inefficient.Touching each node requires touching every other node: O(n2)
![Page 32: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/32.jpg)
New Reverse: Push all, pull off reversed
/**
* Reverse2: Push all the elements on
* the stack, then pop all the elements
* off the stack.
*/
public LayeredSceneElement reverse2() {
LayeredSceneElement reversed, current, popped;
Stack<LayeredSceneElement> stack =
new LinkedListStack<LayeredSceneElement>();
![Page 33: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/33.jpg)
// Push all the elements on the list
current=this;
while (current != null)
{
stack.push(current);
current = current.getNext();
}
// Make the last element (current top of stack) into new first
reversed = stack.pop();
// Now, pop them all onto the list
current = reversed;
while (stack.size()>0) {
popped = stack.pop();
current.insertAfter(popped);
current = popped;
}
return reversed;
}
![Page 34: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/34.jpg)
What’s the diff? Time
How often is each node touched in reverse2()?• Twice: Once going onto the stack, once
coming off.
• O(2*n) => O(n)
The stack-based reverse is faster than the original reverse.
![Page 35: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/35.jpg)
What’s the diff? Space
How much space does reverse2() take?• Whatever space the stack takes.
How much additional space does reverse() take? None
Very common tradeoff: Space for time.• You can make an algorithm go faster, by using more
space.
• If you need to fit into less memory, you have to do more processing, which takes more time.
![Page 36: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/36.jpg)
Testing Reverse in SoundListTest() public void reverseTest(){ Sound s = null; // For copying in sounds s = new Sound(FileChooser.getMediaPath("guzdial.wav")); SoundNode root = new SoundNode(s); s = new Sound(FileChooser.getMediaPath("is.wav")); SoundNode one = new SoundNode(s); root.last().insertAfter(one); s = new Sound(FileChooser.getMediaPath("scritch-q.wav")); SoundNode two = new SoundNode(s); root.last().insertAfter(two); s = new Sound(FileChooser.getMediaPath("clap-q.wav")); SoundNode three = new SoundNode(s); two.insertAfter(three); //root.playFromMeOn(); SoundNode reversed = (SoundNode) root.reverse2(); reversed.playFromMeOn(); }
![Page 37: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/37.jpg)
Second ADT: Introducing a Queue
First-In-First-Out List• First person in line is first person served
I got here first!
I got here second!
I got here third!
This is the front or head of the queue
This is the tail of the queue
![Page 38: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/38.jpg)
First-in-First-out
New items only get added to the tail.• Never in the middle
Items only get removed from the head.
I got here first!
I got here second!
I got here third!
This is the front or head of the queue
This is the tail of the queue
![Page 39: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/39.jpg)
As items leave, the head shifts
I got here first! AND NOW I’M UP!
I got here second!
I got here third!
Now, this is the front or head of the queue
This is the tail of the queue
Served!
![Page 40: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/40.jpg)
As new items come in, the tail shifts
I got here second!
I got here third!
Now, this is the front or head of the queue
Now, this is the tail of the queue
I got here fourth!
![Page 41: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/41.jpg)
Queue Operations
push(element): Tack a new element onto the tail (end) of the queue.
pop(): Pull the top (head) element off the queue.
peek(): Get the head of the queue, but don’t remove it from the queue.
size(): Return the size of the queue. isEmpty(): Return true or false, if the size of
the queue is zero.
![Page 42: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/42.jpg)
Queue Interface
/** * Interface to define an abstract queue * @author Barb Ericson */public interface Queue<E> {
/** * Push an element onto the tail of the Queue * @param element the element to add to the queue */ public void push(E element);
/** * Peek at, but don't remove, the head of the queue * @return the head of the queue (top) */ public E peek();
![Page 43: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/43.jpg)
/**
* Pop an object from the Queue
* @return the head (top) of the queue and
* remove it from the queue
*/
public E pop();
/**
* Return the size of a queue
* @return the number of elements in the queue
*/
public int size();
/**
* Method to see if the queue is empty
* @return true if the queue is empty, else false
*/
public boolean isEmpty();
}
![Page 44: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/44.jpg)
Implementing a Queue as a Linked List
import java.util.*; // LinkedList representation
/**
* Implements a simple queue using a linked list
* @author Mark Guzdial
* @author Barb Ericson
*/
public class LinkedListQueue<E> extends AbstractQueue<E> {
/** Where we'll store our elements */
private LinkedList<E> elements;
![Page 45: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/45.jpg)
/**
* No argument constructor
*/
public LinkedListQueue() {
elements = new LinkedList<E>();
}
/// Methods
/**
* Push an element onto the tail of the Queue
* @param element the element to add to the queue
*/
public void push(E element) {
elements.addFirst(element);
}
/**
* Peek at, but don't remove, top (first) of queue
* @return the first object in the queue
*/
public E peek() {
return elements.getLast();
}
![Page 46: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/46.jpg)
//**
* Pop an object from the Queue
* @return the top object from the queue (and remove it)
*/
public E pop() {
E toReturn = this.peek();
elements.removeLast();
return toReturn;
}
/**
* Return the size of a queue
* @return the number of elements in the queue
*/
public int size() { return elements.size(); }
/**
* Method to see if the queue is empty
* @return true if the queue is empty, else false
*/
public boolean isEmpty() { return size() == 0; }
}
![Page 47: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/47.jpg)
Testing our implementation:Behaving as expected?
> Queue<String> line = new LinkedListQueue<String>();
> line.push("Fred");
> line.push("Mary");
> line.push("Jose");
> line.size()
3
> line.peek() // without ending ';' prints the result
"Fred"
> line.pop()
"Fred"
> line.peek()
"Mary"
> line.pop()
"Mary"
> line.peek()
"Jose"
> line.pop()
"Jose"
![Page 48: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/48.jpg)
Queue as Array
/**
* Implements a simple queue using an array
* @author Mark Guzdial
* @author Barb Ericson
*/
public class ArrayQueue<E> extends AbstractQueue<E> {
/** constant for the size of the queue */
private static final int ARRAY_SIZE = 20;
/** Where we'll store our elements */
private Object[] elements;
/** The index of the head */
private int head;
/** The index of the tail */
private int tail;
![Page 49: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/49.jpg)
/** No argument constructor */
public ArrayQueue() {
elements = new Object[ARRAY_SIZE];
head = 0; tail = 0;
}
/// Methods
/**
* Push an element onto the tail of the Queue
* @param element the element to add to the queue
*/
public void push(E element) {
if ((tail + 1) >= ARRAY_SIZE) {
System.out.println("Queue underlying implementation failed");}
else {
// Store at the tail,
// then increment to a new open position
elements[tail] = element;
tail++;}
}
![Page 50: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/50.jpg)
/**
* Peek at, but don't remove, the head of the queue
* @return the head of the queue (top)
*/
public E peek() {
// this will give a warning but there is no way around it
return (E) elements[head];
}
![Page 51: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/51.jpg)
/**
* Pop an object from the Queue
* @return the head (top) of the queue and
* remove it from the queue
*/
public E pop() {
E toReturn = this.peek();
if (((head + 1) >= ARRAY_SIZE) ||
(head > tail)) {
System.out.println("Queue underlying implementation failed.");
return toReturn;
}
else {
// Increment the head forward, too.
head++;
return toReturn;
}
}
![Page 52: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/52.jpg)
/**
* Return the size of a queue
* @return the number of elements in the queue
*/
public int size() { return tail-head;}
/**
* Method to see if the queue is empty
* @return true if the queue is empty, else false
*/
public boolean isEmpty() { return size() == 0; }
}
![Page 53: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/53.jpg)
Again, testing implementation
> Queue<String> line = new ArrayQueue<String>();
> line.push("Fred");
> line.push("Mary");
> line.push("Jose");
> line.size()
3
> line.peek() // without ending ';' prints the result
"Fred"
> line.pop()
"Fred"
> line.peek()
"Mary"
> line.pop()
"Mary"
> line.peek()
"Jose"
> line.pop()
"Jose"
![Page 54: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/54.jpg)
How the array implementation of queue works
An empty queue
![Page 55: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/55.jpg)
Pushing “Matt”
![Page 56: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/56.jpg)
Pushing “Katie”
![Page 57: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/57.jpg)
Popping (returns “Matt”)
Notice that we’ve now permanently “lost” the first cell.Challenge: Can you “recover” that cell?Notice that we’ve now permanently “lost” the first cell.Challenge: Can you “recover” that cell?
![Page 58: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/58.jpg)
Improving the implementation
Our two implementations have duplicated code.• Check out isEmpty() in each.
Where could we put the code so that it’s not duplicated?• Interfaces can’t have method bodies.
• We can use an abstract class.
![Page 59: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/59.jpg)
Abstract Queue Class
/**
* Class to define an abstract queue
* @author Barb Ericson
*/
public abstract class AbstractQueue<E> implements Queue<E> {
/**
* Push an object onto the Queue
* @param element the element to add to the queue
*/
public abstract void push(E element);
![Page 60: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/60.jpg)
/**
* Peek at, but don't remove, the head of the queue
* @return the head of the queue (top)
*/
public abstract E peek();
/**
* Pop an object from the Queue
* @return the head (top) of the queue and
* remove it from the queue
*/
public abstract E pop();
/**
* Return the size of a queue
* @return the number of elements in the queue
*/
public abstract int size();
![Page 61: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/61.jpg)
Finally, the isEmpty method, factored out
/**
* Method to see if the queue is empty
* @return true if the queue is empty, else false
*/
public boolean isEmpty() {
return (size() == 0);
}
}
![Page 62: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/62.jpg)
Revised ArrayQueue
/**
* Implements a simple queue using an array
* @author Mark Guzdial
* @author Barb Ericson
*/
public class ArrayQueue extends AbstractQueue {
/// ... fields and other methods as before
/**
* Method to see if the queue is empty
* @return true if the queue is empty, else false
*/
// commented out since inherited from AbstractQueue
// public boolean isEmpty() { return size() == 0; }
}
![Page 63: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/63.jpg)
Revised LinkedListQueue
/**
* Implements a simple queue using a linked list
* @author Mark Guzdial
* @author Barb Ericson
*/
public class LinkedListQueue extends AbstractQueue {
// ... fields and other methods as before
/**
* Check if the queue is empty
* @return true if no elements in the queue, else false
*/
// commented out since inherited from AbstractQueue
// public boolean isEmpty() {return this.size() == 0;}
}
![Page 64: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/64.jpg)
Can switch implementations easily
As ArrayList
> import java.util.*;
> List<String> nameList = new ArrayList<String>();
> nameList.add("Shayna");
> nameList.add("Marcus");
> nameList.add("Jakita");
> nameList
[Shayna, Marcus, Jakita]
If inserting/deleting a lot, use LinkedList
> import java.util.*;
> List<String> nameList = new LinkedList<String>();
> nameList.add("Shayna");
> nameList.add("Marcus");
> nameList.add("Jakita");
> nameList
[Shayna, Marcus, Jakita]
How the List is used (methods and behavior) is the same in both cases.
How the List is used (methods and behavior) is the same in both cases.
![Page 65: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/65.jpg)
A Common Pattern
We see this structure repeated throughout java.util• Interface defines ADT
• Abstract class defines common parts
• Concrete classes differ in implementation
![Page 66: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/66.jpg)
Switching implementations
Switching the underlying implementation can provide advantages.• Of speed
• Of flexibility
For example, our stack implemented as an Array can go out of bounds if grows too large.• But not if we use ArrayList!
![Page 67: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/67.jpg)
Using an ArrayList:ArrayListStack
import java.util.*;
/**
* Implementation of a stack as an ArrayList
* @author Mark Guzdial
* @author Barb Ericson
*/
public class ArrayListStack<E> implements Stack<E> {
/** Where we'll store our elements */
private List<E> list = new ArrayList<E>();
/**
* No argument constructor
*/
public ArrayListStack() {
}
![Page 68: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/68.jpg)
//// Methods ///
/**
* Method to add an element to the top of the stack
* @param element the element to add
*/
public void push(E element) {
list.add(element);
}
/**
* Method to return the top element on the stack
* but not remove it.
* @return the object at the top of the stack
*/
public E peek() {
return list.get(list.size() - 1);
}
![Page 69: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/69.jpg)
/**
* Method to remove and return the top element on the stack
* @return the element on the top of the stack
*/
public E pop() {
return list.remove(list.size() - 1);
}
/**
* Method to return the number of elements in the stack
* @return the number of elements in the stack
*/
public int size(){return list.size();}
![Page 70: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/70.jpg)
Main() for testing
public static void main(String[] args) {
Stack<String> stack = new ArrayListStack<String>();
stack.push("Matt");
stack.push("Katie");
stack.push("Jenny");
System.out.println(stack.size());
System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
![Page 71: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/71.jpg)
New ADT: A Map
A Map associates a value with a key.• The key can be any unique object.
• The value can be any single object.
If you store two values under one key, the second value will overwrite the first value as THE value for THAT key.
![Page 72: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/72.jpg)
Using a Map to create oil paintings
Oil paintings have only one color for region (size of brush)
Using the Java implementation of Map (java.util.Map) to track how often a color (the key) appears in a region.
For each region,• Store color counts in map.
• Get most common (highest count) color.
• Set all colors in region to the most common color.
![Page 73: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/73.jpg)
oilPaint method in Picture
/**
* Method to do an oil paint effect on a picture
* @param dist the distance from the current pixel
* to use in the range
* @return the new picture
*/
public Picture oilPaint(int dist) {
// create the picture to return
Picture retPict = new Picture(this.getWidth(),this.getHeight());
// declare pixels
Pixel currPixel = null;
Pixel retPixel = null;
![Page 74: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/74.jpg)
// loop through the pixels
for (int x = 0; x < this.getWidth(); x++) {
for (int y = 0; y < this.getHeight(); y++) {
currPixel = this.getPixel(x,y);
retPixel = retPict.getPixel(x,y);
retPixel.setColor(currPixel.getMostCommonColorInRange(dist));
}
}
return retPict;
}
![Page 75: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/75.jpg)
getMostCommonColorInRange in class Pixel
/**
* Method to return the most common color in the given
* range from the current pixel in the picture or just
* return this color.
* @param dist the distance to use for the range
* @return the most common color in this range
*/
public Color getMostCommonColorInRange(int dist) {
Map<Color,Integer> colorMap = new HashMap<Color,Integer>();
Pixel currPixel = null;
Integer value = null;
Color theKey = null;
The variable colorMap is of type Map.We instantiate HashMap, but could switch to another implementation
The variable colorMap is of type Map.We instantiate HashMap, but could switch to another implementation
![Page 76: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/76.jpg)
// loop through the pixels around this one within the distance
for (int currY = y - dist; currY <= y + dist; currY++) {
for (int currX = x - dist; currX <= x + dist; currX++) {
if (currY >= 0 && currY < picture.getHeight() &&
currX >= 0 && currX < picture.getWidth()) {
currPixel = picture.getPixel(currX,currY);
theKey = currPixel.getColor();
value = colorMap.get(theKey);
if (value == null)
colorMap.put(theKey,1);
else
colorMap.put(theKey, value + 1);
}
}
}
![Page 77: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/77.jpg)
// find the color that is most common
int maxValue = 1;
int currValue = 0;
theKey = this.getColor(); // use current color as default
Set<Color> keySet = colorMap.keySet();
for (Color key : keySet) {
currValue = colorMap.get(key);
if (currValue > maxValue) {
theKey = key;
maxValue = currValue;
}
}
return theKey;
}
![Page 78: Problem Solving with Data Structures using Java: A Multimedia Approach](https://reader033.fdocuments.us/reader033/viewer/2022042822/56814e3a550346895dbba302/html5/thumbnails/78.jpg)
Example Use