COS 312 DAY 20 Tony Gauvin. Ch 1 -2 Agenda Questions? Next Capstone progress report is due April 25 Assignment 5 Graded – Not much original code Assignment.

Slides:



Advertisements
Similar presentations
Chapter 17 Recursion.
Advertisements

© 2010 Pearson Addison-Wesley. All rights reserved. Addison Wesley is an imprint of CHAPTER 7: Recursion Java Software Structures: Designing and Using.
Stacks, Queues, and Deques. 2 A stack is a last in, first out (LIFO) data structure Items are removed from a stack in the reverse order from the way they.
Chapter 5 Queues Modified. Chapter Scope Queue processing Comparing queue implementations 5 - 2Java Software Structures, 4th Edition, Lewis/Chase.
Chapter 14 Queues. Chapter Scope Queue processing Using queues to solve problems Various queue implementations Comparing queue implementations Java Foundations,
Chapter 6 Linked Structures © 2006 Pearson Education Inc., Upper Saddle River, NJ. All rights reserved.
Unit 11 1 Unit 11: Data Structures H We explore some simple techniques for organizing and managing information H This unit focuses on: Abstract Data Types.
CHAPTER 6 Stacks Array Implementation. 2 Stacks A stack is a linear collection whose elements are added and removed from one end The last element to be.
Chapter 6 Stacks. Copyright © 2005 Pearson Addison-Wesley. All rights reserved. 6-2 Chapter Objectives Examine stack processing Define a stack abstract.
Chapter 13 Linked Structures - Stacks. Chapter Scope Object references as links Linked vs. array-based structures Managing linked lists Linked implementation.
Stacks, Queues, and Deques
Stacks, Queues, and Deques. A stack is a last in, first out (LIFO) data structure –Items are removed from a stack in the reverse order from the way they.
Stacks, Queues, and Deques
Chapter 14 Queues. First a Review Queue processing Using queues to solve problems – Optimizing customer service simulation – Ceasar ciphers – Palindrome.
Chapter 4 Linked Structures – Stacks Modified. Chapter Scope Object references as links Linked vs. array-based structures Managing linked lists Linked.
Chapter 12 Introduction to Collections - Stacks
1 CMPSCI 187 Computer Science 187 Introduction to Introduction to Programming with Data Structures Lecture 11: Stacks and Mazes Announcements 1.Midterm.
Abstract Data Types (ADTs) and data structures: terminology and definitions A type is a collection of values. For example, the boolean type consists of.
Topic 3 The Stack ADT.
Fundamentals of Python: From First Programs Through Data Structures Chapter 14 Linear Collections: Stacks.
Implementing Stacks Ellen Walker CPSC 201 Data Structures Hiram College.
Chapter 3 Introduction to Collections – Stacks Modified
Chapter 8 Lists. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-2 Chapter Objectives Examine list processing and various ordering techniques.
Chapter 7 Arrays. © 2004 Pearson Addison-Wesley. All rights reserved11-2 Arrays Arrays are objects that help us organize large amounts of information.
© 2004 Goodrich, Tamassia Stacks. © 2004 Goodrich, Tamassia Stacks2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data.
COS 312 DAY 20 Tony Gauvin. Ch 1 -2 Agenda Questions? Capstone Progress reports over due Assignment 6 Posted – Due April 16 – Questions? Queues.
“Planning is bringing the future into the present so that you can do something about it now.” – Alan Lakein Thought for the Day.
Chapter 6 Stacks. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-2 Chapter Objectives Examine stack processing Define a stack abstract.
1 Linked-list, stack and queue. 2 Outline Abstract Data Type (ADT)‏ Linked list Stack Queue.
Linked Structures - Review Chapter 13 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013.
1 Recursion Recursion is a powerful programming technique that provides elegant solutions to certain problems. Chapter 11 focuses on explaining the underlying.
Linked Structures, LinkedStack
COS 312 DAY 19 Tony Gauvin. Ch 1 -2 Agenda Questions? Capstone Progress reports over due Assignment 6 Posted – Due April 16 Layers using non-opaque panels.
Collections Chapter 12 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013.
1 Stacks (Continued) and Queues Array Stack Implementation Linked Stack Implementation The java.util.Stack class Queue Abstract Data Type (ADT) Queue ADT.
Recursion Chapter 17 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013.
© 2010 Pearson Addison-Wesley. All rights reserved. Addison Wesley is an imprint of CHAPTER 15: Sets and Maps Java Software Structures: Designing and Using.
Topic 13 Iterators. 9-2 Motivation We often want to access every item in a data structure or collection in turn We call this traversing or iterating over.
TOWERS OF HANOI. : If n = 1, move disk 1 from pole 'A' to pole 'B'. else: 1.First, move n-1 disks from pole 'A' to pole 'C', using pole 'B' as.
“The desire for safety stands against every great and noble enterprise.” – Tacitus Thought for the Day.
COS 312 DAY 12 Tony Gauvin. Ch 1 -2 Agenda Questions? First Progress report due Assignment corrected 1 MIA – 2 A’s, 2 B’s, 1 D, 1 F and 1 MIA – Code\pig.
COS 312 DAY 18 Tony Gauvin. 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 –
1 Example: LinkedStack LinkedStack UML Class Diagram LinkedStack Class LinkedStack Attributes/Constructor LinkedStack Methods LinkedStack iterator method.
1 Queues (Continued) Queue ADT Linked queue implementation Array queue implementation Circular array queue implementation Deque Reading L&C , 9.3.
Linked Structures Chapter 13 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013.
COS 312 DAY 23 Tony Gauvin. Ch 1 -2 Agenda Questions? Capstone progress report Overdue Assignment 6 Over Due Assignment 7 (bonus) – Due May 11 – Will.
COS 312 DAY 24 Tony Gauvin. Ch 1 -2 Agenda Questions? Assignment 6 Corrected Assignment 7 (bonus) – Due May 11 – Will be scored on 15 point scale, points.
Linked Structures - Stacks. Linked Structures An alternative to array-based implementations are linked structures A linked structure uses object references.
COS 312 DAY 19 Tony Gauvin. Ch 1 -2 Agenda Questions? Next Capstone progress report is April 25 Assignment 5 OVERDUE – Will be graded tomorrow Assignment.
Stack: a Linked Implementation
CHAPTER 4: Linked Structures
Storage Strategies: Dynamic Linking
COS 312 DAY 21 Tony Gauvin.
Stacks.
Chapter 14: Stacks.
The Stack ADT. 3-2 Objectives Define a stack collection Use a stack to solve a problem Examine an array implementation of a stack.
Stack and Queue APURBO DATTA.
Java Software Structures: John Lewis & Joseph Chase
Top Ten Words that Almost Rhyme with “Peas”
Chapter 4 Linked Structures - Stacks
Java Software Structures: John Lewis & Joseph Chase
Chapter 12 Recursion (methods calling themselves)
Chapter 4 Linked Structures - Stacks
Stacks, Queues, and Deques
Chapter 8 Recursion.
Stacks, Queues, and Deques
COS 312 DAY 18 Tony Gauvin.
A type is a collection of values
CHAPTER 3: Collections—Stacks
Presentation transcript:

COS 312 DAY 20 Tony Gauvin

Ch 1 -2 Agenda Questions? Next Capstone progress report is due April 25 Assignment 5 Graded – Not much original code Assignment 6 posted – Due April 28 Assignment 7 (bonus) – Due May 11 Student evaluations Introduction to Linked Structures  Stacks,

Left to do April 21 Chap 13 Introduction to Linked Structures – Stacks, Student evaluations April 25 & 28 Chap 14 & 15 Queues and Lists Assignment 6 due, Last Capstone Progress Report Due May 2 & 5 Chap 16 & 17 Iterators and Recursion May 1 PM Quiz 3 & Capstone presentations (Assignment 7 Bonus) Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 3

AFUM Scholarship Returning students with 24 Credit hours completed by end of Spring 2016 who have not received AFUM scholarship this year Submit – Personal letter of commitment to scholarship and service – One Letter of recommendation from faculty member – Resume and copy of transcript – Submit to Dr. Stephan Hansen, Nadeau 232, by Friday April 29. Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 4

Chapter 13 Linked Structures - Stacks

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 - 6

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 - 7

Link”able” node public class Monkey { private String name; private String weight; private int age; private Monkey next; // link to another Monkey object } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 8

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

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

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 Monkey current = first; while (current != null) { System.out.println(current); current = current.next; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

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/Chase

Add node to list Create new node Point new node to node in front of list Point “front” to new node Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 13

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/Chase

Delete node from front of list t Create reference (pointer) to node to be deleted Assign front to the node the node to be deleted pointed to Java Foundations, 3rd Edition, Lewis/DePasquale/Chase5 - 15

Linked Lists So far we've assumed that the list contains nodes that are self-referential ( Monkey points to a Monkey ) 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/Chase

Linked list using nodes Public class LinkedNode { private LinkedNode next; private T element; public LinkedNode(T daElement) { next = null; element = da.Element; } public setNext(LinkedNode anotherNode) { next = anotherNode; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase Element Linked Node element Next

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/Chase

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 – r.html r.html 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/Chase

Stacks Revisited Stack characteristics can also be found by using the Deque interface from the API The LinkedList class implements the Deque interface – ml ml – 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/Chase

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/Chase rows, 13 columns

Stack algorithm for maze Start location (x,y) Repeat until Possible Moves Stack is empty or Maze solved (at finish location x,y) ( from current location  push all possible next moves onto Possible Moves Stack (left, right, up and down) Push current location on Made Moves Stack Peek for next move on PMS and see if you are on same path if not pop from MMS till you back on same path pop PMS and move to that location same path  two positions are adjacent Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

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) – Code Example in text book is wrong! Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

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. * Java Foundations 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/Chase

/** * Constructor for the Maze class. Loads a maze from the given file. * Throws a FileNotFoundException if the given file is not found. * filename the name of the file to load 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/Chase

/** * Marks the specified position in the maze as TRIED * row the index of the row to try 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 * the number of rows in this maze */ public int getRows() { return grid.length; } /** * Return the number of columns in this maze * the number of columns in this maze */ public int getColumns() { return grid[0].length; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

/** * Marks a given position in the maze as part of the PATH * row the index of the row to mark as part of the PATH 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. * row the row to be checked column the column to be checked 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/Chase

/** * Returns the maze as a string. * 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/Chase Code\chap13\Maze.java

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. * Java Foundations 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/Chase This version of the code from the textbook does not mark the correct path This hyperlinked version does mark the correct path Code\chap13\MazeSolver.java

/** * 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. * row row index of current location column column index of current location 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/Chase Bunch of Code missing here Need another Stack

/** * Push a new attempted move onto the stack x represents x coordinate y represents y coordinate stack the working stack of moves within the grid 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/Chase

Correct Code Java Foundations, 3rd Edition, Lewis/DePasquale/Chase import java.util.*; /** * MazeSolver attempts to recursively traverse a Maze. 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. * Java Foundations & Tony Gauvin 5.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/Chase /** * Attempts to recursively traverse the maze. Inserts special * characters indicating locations that have been TRIED and that * eventually become part of the solution PATH. * row row index of current location column column index of current location true if the maze has been solved */ public boolean traverse() { boolean done = false; int row, column; Position pos = new Position(); Deque stack = new LinkedList (); // keeps track of possible path Deque path = new LinkedList (); stack.push(pos); while (!(done) && !stack.isEmpty()) { pos = stack.pop(); //possible path path.push(pos); 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); } // If the top of both stacks are not adjacent then we went down a bad path // we remove the bad path from the stack to the last "fork" in the path if (!done && (!stack.isEmpty() && !path.isEmpty())) { while (!adjacentPosition(stack.peek(),path.peek())) { path.pop(); } } } /// mark the good path if (done) { Position posTemp = new Position(); while (!path.isEmpty()) { posTemp = path.pop(); maze.markPath(posTemp.getx(), posTemp.gety()); } } return done; }

Java Foundations, 3rd Edition, Lewis/DePasquale/Chase /** * Push a new attempted move onto the stack x represents x coordinate y represents y coordinate stack the working stack of moves within the grid 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); } /** * Checks to see if two postions are adjacent p1 represents first position p2 represents second position true if position are adjacent false other wise */ public boolean adjacentPosition(Position p1, Position p2) { boolean result = false; if ((Math.abs(p1.getx() - p2.getx()) == 1) && (p1.gety() - p2.gety() == 0 )) result = true; if ((Math.abs(p1.gety() - p2.gety()) == 1) && (p1.getx() - p2.getx() == 0 )) result = true; return result; } }

import java.util.*; import java.io.*; /** * MazeTester determines if a maze can be traversed. * Java Foundations 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); } Code\chap13\MazeTester.java Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

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/Chase

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/Chase null

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

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

package jsjf; /** * Represents a node in a linked list. * Java Foundations 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. elem element to be stored */ public LinearNode(T elem) { next = null; element = elem; } Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

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

package jsjf; import jsjf.exceptions.*; import java.util.Iterator; /** * Represents a linked implementation of a stack. * Java Foundations 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/Chase

/** * Adds the specified element to the top of this stack. 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. element from top of stack 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; } Code\chap13\jsjf\LinkedStack.javaCode\chap13\jsjf\LinkedStack.java Java Foundations, 3rd Edition, Lewis/DePasquale/Chase

Implementing a Stack using Links Java Foundations, 3rd Edition, Lewis/DePasquale/Chase