1. COS 312 DAY 18 Tony Gauvin

2. Ch 1 -2 Agenda Questions? Capstone Progress reports over due Assignment 5 Corrected – 1 A, 2 B’s, 1 C, 1 D 1 F and 1 MIA – Review of 9.3 & 9.8 (Comparable and Lockable Interfaces) Assignment 6 Posted – Due April 16 Quiz 2 Corrected – 1 A+, 3 B’s, 1 C, 1 D and 1 MIA Cont. Introduction to Collections  Stacks Begin Linked Lists

3. Chapter 12 Introduction to Collections - Stacks

4. Chapter Scope Collection terminology The Java Collections API Abstract nature of collections Stacks – Conceptually – Used to solve problems – Implementation using arrays Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 4

5. Collections A collection is an object that holds and organizes other objects It provides operations for accessing and managing its elements Many standard collections have been defined over time Some collections are linear in nature, others are non-linear Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 5

6. Abstract Data Type A data type is a group of values and the operations defined on those values An abstract data type (ADT) is a data type that isn't pre-defined in the programming language A data structure is the set of programming constructs and techniques used to implement a collection The distinction between the terms ADT, data structure, and collection is sometimes blurred in casual use Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 6

7. Stacks A stack is a classic collection used to help solve many types of problems A stack is a linear collection whose elements are added in a last in, first out (LIFO) manner That is, the last element to be put on a stack is the first one to be removed Think of a stack of books, where you add and remove from the top, but can't reach into the middle Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 7

8. Stack - Conceptual View Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 8 https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

9. Stack Operations Some collections use particular terms for their operations These are the classic stack operations: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 9

10. Generics The generic type placeholder is specified in angle brackets in the class header: class Box { // declarations and code that refer to T } Any identifier can be used, but T (for Type) or E (for element) have become standard practice Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 10 denotes Generic Type, T will be replaced with object type when instantiated

11. Generics Then, when a Box is needed, it is instantiated with a specific class instead of T: Box box1 = new Box (); Now, box1 can only hold Widget objects The compiler will issue errors if we try to add a non- Widget to the box And when an object is removed from the box, it is assumed to be a Widget – BOX object will can only contain Widget objects Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 11

12. Generics Using the same class, another object can be instantiated: Box box2 = new Box (); The box2 object can only hold Gadget objects Generics provide better type management control at compile-time and simplify the use of collection classes Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 12

13. Exceptions When should exceptions be thrown from a collection class? Only when a problem is specific to the concept of the collection (not its implementation or its use) There's no need for the user of a collection to worry about it getting "full," so we'll take care of any such limitations internally But a stack should throw an exception if the user attempts to pop an empty stack Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 13

14. A Stack Interface Although the API version of a stack did not rely on a formal interface, we will define one for our own version To distinguish them, our collection interface names will have ADT (abstract data type) attached Furthermore, our collection classes and interfaces will be defined as part of a package called jsjf Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 14

15. package jsjf; /** * Defines the interface to a stack collection. * * @author Java Foundations * @version 4.0 */ public interface StackADT { /** * Adds the specified element to the top of this stack. * @param element element to be pushed onto the stack */ public void push(T element); /** * Removes and returns the top element from this stack. * @return the element removed from the stack */ public T pop(); /** * Returns without removing the top element of this stack. * @return the element on top of the stack */ public T peek(); /** * Returns true if this stack contains no elements. * @return true if the stack is empty */ public boolean isEmpty(); /** * Returns the number of elements in this stack. * @return the number of elements in the stack */ public int size(); /** * Returns a string representation of this stack. * @return a string representation of the stack */ public String toString(); } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 15 Code\chap12\jsjf\javadoc\jsjf\StackADT.html

16. A Stack Interface Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 16

17. Implementing a Stack with an Array Let's now explore our own implementation of a stack, using an array as the underlying structure in which we'll store the stack elements We'll have to take into account the possibility that the array could become full And remember that an array of objects really stores references to those objects Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 17

18. Implementing Stacks with an Array An array of object references: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 18

19. Managing Capacity The number of cells in an array is called its capacity It's not possible to change the capacity of an array in Java once it's been created Therefore, to expand the capacity of the stack, we'll create a new (larger) array and copy over the elements This will happen infrequently, and the user of the stack need not worry about it happening Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 19

20. Implementing Stacks with an Array By convention, collection class names indicate the underlying structure – So ours will be called ArrayStack – java.util.Stack is an exception to this convention Our solution will keep the bottom of the stack fixed at index 0 of the array A separate integer called top will indicate where the top of the stack is, as well as how many elements are in the stack currently Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 20

21. Implementing a Stack with an Array A stack with elements A, B, C, and D pushed on in that order: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 21

22. Pushing and Popping a Stack After pushing element E: After popping: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 22

23. Defining an Exception An EmptyCollectionException is thrown when a pop or a peek is attempted and the stack is empty The EmptyCollectionException is defined to extend RuntimeException By passing a string into its constructor, this exception can be used for other collections as well Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 23

24. package jsjf.exceptions; /** * Represents the situation in which a collection is empty. * * @author Java Foundations * @version 4.0 */ public class EmptyCollectionException extends RuntimeException { /** * Sets up this exception with an appropriate message. * @param collection the name of the collection */ public EmptyCollectionException(String collection) { super("The " + collection + " is empty."); } Code\chap12\jsjf\exceptions\EmptyCollectionException.java Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 24

25. package jsjf; import jsjf.exceptions.*; import java.util.Arrays; /** * An array implementation of a stack in which the * bottom of the stack is fixed at index 0. * * @author Java Foundations * @version 4.0 */ public class ArrayStack implements StackADT { private final static int DEFAULT_CAPACITY = 100; private int top; private T[] stack; Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 25

26. /** * Creates an empty stack using the default capacity. */ public ArrayStack() { this(DEFAULT_CAPACITY); } /** * Creates an empty stack using the specified capacity. * @param initialCapacity the initial size of the array */ public ArrayStack(int initialCapacity) { top = 0; stack = (T[])(new Object[initialCapacity]); } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 26

27. Creating an Array of a Generic Type You cannot instantiate an array of a generic type directly Instead, create an array of Object references and cast them to the generic type Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 27

28. /** * Adds the specified element to the top of this stack, expanding * the capacity of the array if necessary. * @param element generic element to be pushed onto stack */ public void push(T element) { if (size() == stack.length) expandCapacity(); stack[top] = element; top++; } /** * Creates a new array to store the contents of this stack with * twice the capacity of the old one. */ private void expandCapacity() { stack = Arrays.copyOf(stack, stack.length * 2); } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 28 https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#copyOf(T[],%20int)

29. /** * Removes the element at the top of this stack and returns a * reference to it. * @return element removed from top of stack * @throws EmptyCollectionException if stack is empty */ public T pop() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException("stack"); top--; T result = stack[top]; stack[top] = null; return result; } /** * Returns a reference to the element at the top of this stack. * The element is not removed from the stack. * @return element on top of stack * @throws EmptyCollectionException if stack is empty */ public T peek() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException("stack"); return stack[top-1]; } Code\chap12\jsjf\ArrayStack.javaCode\chap12\jsjf\ArrayStack.java Java Foundations, 3rd Edition, Lewis/DePasquale/Chase12 - 29

30. Chapter 13 Linked Structures - Stacks

31. Chapter Scope Object references as links Linked vs. array-based structures Managing linked lists Linked implementation of a stack Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 31

32. Linked Structures An alternative to array-based implementations are linked structures A linked structure uses object references to create links between objects Recall that an object reference variable holds the address of an object Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 32

33. Link”able” node Public class Person { private String name; private String address; private Person next; // link to another person object } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 33

34. Linked Structures A Person object, for instance, could contain a reference to another Person object A series of Person objects would make up a linked list: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 34

35. Linked Structures Links could also be used to form more complicated, non-linear structures Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 35

36. Linked Lists There are no index values built into linked lists To access each node in the list you must follow the references from one node to the next Person current = first; while (current != null) { System.out.println(current); current = current.next; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 36

37. Linked Lists Care must be taken to maintain the integrity of the links To insert a node at the front of the list, first point the new node to the front node, then reassign the front reference Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 37 http://scanftree.com/Data_Structure/Insertion-in-linked-list

38. Linked Lists To delete the first node, reassign the front reference accordingly If the deleted node is needed elsewhere, a reference to it must be established before reassigning the front pointer Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 38 http://scanftree.com/Data_Structure/Deletion-in-linked-list

39. Linked Lists So far we've assumed that the list contains nodes that are self-referential ( Person points to a Person ) But often we'll want to make lists of objects that don't contain such references Solution: have a separate Node class that forms the list and holds a reference to the objects being stored Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 39

40. Linked Lists There are many variations on the basic linked list concept For example, we could create a doubly-linked list with next and previous references in each node and a separate pointer to the rear of the list Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 40

41. Stacks Revisited In the previous chapter we developed our own array-based version of a stack, and we also used the java.util.Stack class from the Java API The API's stack class is derived from Vector, which has many non-stack abilities It is, therefore, not the best example of inheritance, because a stack is not a vector It's up to the user to use a Stack object only as intended Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 41

42. Stacks Revisited Stack characteristics can also be found by using the Deque interface from the API The LinkedList class implements the Deque interface Deque stands for double-ended queue, and will be explored further later For now, we will use the stack characteristics of a Deque to solve the problem of traversing a maze Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 42

43. Traversing a Maze Suppose a two-dimensional maze is represented as a grid of 1 (path) and 0 (wall) Goal: traverse from the upper left corner to the bottom right (no diagonal moves) Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 43 9 13 1 1 1 0 1 1 0 0 0 1 1 1 1 1 0 0 1 1 0 1 1 1 1 0 0 1 1 1 1 1 1 0 1 0 1 0 1 0 0 0 0 0 0 1 1 1 0 1 0 1 1 1 1 1 1 0 1 1 1 0 1 0 1 1 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

44. Stack algorithm for maze Start location (x,y) Repeat until Stack is empty or Maze solved (at finish location x,y) ( from current location  push all possible next moves onto stack (left, right, up and down) pop stack and move to that location ) Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 44

45. Traversing a Maze Using a stack, we can perform a backtracking algorithm to find a solution to the maze An object representing a position in the maze is pushed onto the stack when trying a path If a dead end is encountered, the position is popped and another path is tried We'll change the integers in the maze grid to represent tried-but-failed paths (2) and the successful path (3) Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 45

46. import java.util.*; import java.io.*; /** * Maze represents a maze of characters. The goal is to get from the * top left corner to the bottom right, following a path of 1's. Arbitrary * constants are used to represent locations in the maze that have been TRIED * and that are part of the solution PATH. * * @author Java Foundations * @version 4.0 */ public class Maze { private static final int TRIED = 2; private static final int PATH = 3; private int numberRows, numberColumns; private int[][] grid; Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 46

47. /** * Constructor for the Maze class. Loads a maze from the given file. * Throws a FileNotFoundException if the given file is not found. * * @param filename the name of the file to load * @throws FileNotFoundException if the given file is not found */ public Maze(String filename) throws FileNotFoundException { Scanner scan = new Scanner(new File(filename)); numberRows = scan.nextInt(); numberColumns = scan.nextInt(); grid = new int[numberRows][numberColumns]; for (int i = 0; i < numberRows; i++) for (int j = 0; j < numberColumns; j++) grid[i][j] = scan.nextInt(); } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 47

48. /** * Marks the specified position in the maze as TRIED * * @param row the index of the row to try * @param col the index of the column to try */ public void tryPosition(int row, int col) { grid[row][col] = TRIED; } /** * Return the number of rows in this maze * * @return the number of rows in this maze */ public int getRows() { return grid.length; } /** * Return the number of columns in this maze * * @return the number of columns in this maze */ public int getColumns() { return grid[0].length; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 48

49. /** * Marks a given position in the maze as part of the PATH * * @param row the index of the row to mark as part of the PATH * @param col the index of the column to mark as part of the PATH */ public void markPath(int row, int col) { grid[row][col] = PATH; } /** * Determines if a specific location is valid. A valid location * is one that is on the grid, is not blocked, and has not been TRIED. * * @param row the row to be checked * @param column the column to be checked * @return true if the location is valid */ public boolean validPosition(int row, int column) { boolean result = false; // check if cell is in the bounds of the matrix if (row >= 0 && row < grid.length && column >= 0 && column < grid[row].length) // check if cell is not blocked and not previously tried if (grid[row][column] == 1) result = true; return result; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 49

50. /** * Returns the maze as a string. * * @return a string representation of the maze */ public String toString() { String result = "\n"; for (int row=0; row < grid.length; row++) { for (int column=0; column < grid[row].length; column++) result += grid[row][column] + ""; result += "\n"; } return result; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 50

51. import java.util.*; /** * MazeSolver attempts to traverse a Maze using a stack. The goal is to get from the * given starting position to the bottom right, following a path of 1's. Arbitrary * constants are used to represent locations in the maze that have been TRIED * and that are part of the solution PATH. * * @author Java Foundations * @version 4.0 */ public class MazeSolver { private Maze maze; /** * Constructor for the MazeSolver class. */ public MazeSolver(Maze maze) { this.maze = maze; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 51

52. /** * Attempts to traverse the maze using a stack. Inserts special * characters indicating locations that have been TRIED and that * eventually become part of the solution PATH. * * @param row row index of current location * @param column column index of current location * @return true if the maze has been solved */ public boolean traverse() { boolean done = false; int row, column; Position pos = new Position(); Deque stack = new LinkedList (); stack.push(pos); while (!(done) && !stack.isEmpty()) { pos = stack.pop(); maze.tryPosition(pos.getx(),pos.gety()); // this cell has been tried if (pos.getx() == maze.getRows()-1 && pos.gety() == maze.getColumns()-1) done = true; // the maze is solved else { push_new_pos(pos.getx() - 1,pos.gety(), stack); push_new_pos(pos.getx() + 1,pos.gety(), stack); push_new_pos(pos.getx(),pos.gety() - 1, stack); push_new_pos(pos.getx(),pos.gety() + 1, stack); } return done; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 52

53. /** * Push a new attempted move onto the stack * @param x represents x coordinate * @param y represents y coordinate * @param stack the working stack of moves within the grid * @return stack of moves within the grid */ private void push_new_pos(int x, int y, Deque stack) { Position npos = new Position(); npos.setx(x); npos.sety(y); if (maze.validPosition(x,y)) stack.push(npos); } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 53

54. import java.util.*; import java.io.*; /** * MazeTester determines if a maze can be traversed. * * @author Java Foundations * @version 4.0 */ public class MazeTester { /** * Creates a new maze, prints its original form, attempts to * solve it, and prints out its final form. */ public static void main(String[] args) throws FileNotFoundException { Scanner scan = new Scanner(System.in); System.out.print("Enter the name of the file containing the maze: "); String filename = scan.nextLine(); Maze labyrinth = new Maze(filename); System.out.println(labyrinth); MazeSolver solver = new MazeSolver(labyrinth); if (solver.traverse()) System.out.println("The maze was successfully traversed!"); else System.out.println("There is no possible path."); System.out.println(labyrinth); } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 54

55. Implementing a Stack using Links Let's now implement our own version of a stack that uses a linked list to hold the elements Our LinkedStack class stores a generic type T and implements the same StackADT interface used previously A separate LinearNode class forms the list and hold a reference to the element stored An integer count will store how many elements are currently in the stack Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 55

56. Implementing a Stack using Links Since all activity on a stack happens on one end, a single reference to the front of the list will represent the top of the stack Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 56

57. Implementing a Stack using Links The stack after A, B, C, and D are pushed, in that order: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 57

58. Implementing a Stack using Links After E is pushed onto the stack: Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 58

59. package jsjf; /** * Represents a node in a linked list. * * @author Java Foundations * @version 4.0 */ public class LinearNode { private LinearNode next; private T element; /** * Creates an empty node. */ public LinearNode() { next = null; element = null; } /** * Creates a node storing the specified element. * @param elem element to be stored */ public LinearNode(T elem) { next = null; element = elem; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 59

60. /** * Returns the node that follows this one. * @return reference to next node */ public LinearNode getNext() { return next; } /** * Sets the node that follows this one. * @param node node to follow this one */ public void setNext(LinearNode node) { next = node; } /** * Returns the element stored in this node. * @return element stored at the node */ public T getElement() { return element; } /** * Sets the element stored in this node. * @param elem element to be stored at this node */ public void setElement(T elem) { element = elem; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 60

61. package jsjf; import jsjf.exceptions.*; import java.util.Iterator; /** * Represents a linked implementation of a stack. * * @author Java Foundations * @version 4.0 */ public class LinkedStack implements StackADT { private int count; private LinearNode top; /** * Creates an empty stack. */ public LinkedStack() { count = 0; top = null; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 61

62. /** * Adds the specified element to the top of this stack. * @param element element to be pushed on stack */ public void push(T element) { LinearNode temp = new LinearNode (element); temp.setNext(top); top = temp; count++; } /** * Removes the element at the top of this stack and returns a * reference to it. * @return element from top of stack * @throws EmptyCollectionException if the stack is empty */ public T pop() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException("stack"); T result = top.getElement(); top = top.getNext(); count--; return result; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 62

63. Implementing a Stack using Links Java Foundations, 3rd Edition, Lewis/DePasquale/Chase13 - 63