CS2006 - Data Structures I Chapter 6 Stacks I 2 Topics ADT Stack Stack Operations Using ADT Stack Line editor Bracket checking Special-Palindromes Implementation.

Slides:



Advertisements
Similar presentations
TK1924 Program Design & Problem Solving Session 2011/2012
Advertisements

1 Introduction to Computation and Problem Solving Class 23: Introduction to Data Structures: Stacks and Queues Prof. Steven R. Lerman and Dr. V. Judson.
Chapter 4 Linked Lists. © 2005 Pearson Addison-Wesley. All rights reserved4-2 Preliminaries Options for implementing an ADT List –Array has a fixed size.
Linked Lists Chapter 4.
Data Structures ADT List
Chapter 24 Lists, Stacks, and Queues
Data Structures Part 2 Stacks, Queues, Trees, and Graphs Briana B. Morrison CSE 1302C Spring 2010.
Review Pseudo Code Basic elements of Pseudo code
1 public class Newton { public static double sqrt(double c) { double epsilon = 1E-15; if (c < 0) return Double.NaN; double t = c; while (Math.abs(t - c/t)
Stack & Queues COP 3502.
Building Java Programs Chapter 14
Sample PMT online… Browse 1120/sumII05/PMT/2004_1/ 1120/sumII05/PMT/2004_1/
Stacks Chapter 11.
COSC 2006 Chapter 7 Stacks III
COMPSCI 105 S Principles of Computer Science 13 Stacks.
Lecture 5 Sept 15 Goals: stacks Implementation of stack applications Postfix expression evaluation Convert infix to postfix.
CMPT 225 Stacks.
Stacks. What is a stack? Last-in first-out data structure (LIFO) New objects are placed on top Removal restricted to top object Examples?
Stacks CS-240 Dick Steflik. Stacks Last In, First Out operation - LIFO As items are added they are chronologically ordered, items are removed in reverse.
Lecture 7 Sept 16 Goals: stacks Implementation of stack applications Postfix expression evaluation Convert infix to postfix.
Stacks.
Stacks Chapter 5. Chapter 5: Stacks2 Chapter Objectives To learn about the stack data type and how to use its four methods: push, pop, peek, and empty.
Lecture 6 Feb 12 Goals: stacks Implementation of stack applications Postfix expression evaluation Convert infix to postfix.
© 2006 Pearson Addison-Wesley. All rights reserved7A-1 Chapter 7 Stacks.
1 CSCD 326 Data Structures I Stacks. 2 Data Type Stack Most basic property: last item in (most recently inserted) is first item out LIFO - last in first.
Fall 2007CS 2251 Stacks Chapter 5. Fall 2007CS 2252 Chapter Objectives To learn about the stack data type and how to use its four methods: push, pop,
Stacks Chapter Chapter Contents Specifications of the ADT Stack Using a Stack to Process Algebraic Expressions Checking for Balanced Parentheses,
1 Lecture 24 Abstract Data Types (ADT) –I Overview  What is an Abstract Data type?  What is Stack ADT?  Stack ADT Specifications  Array Implementation.
Part-B1 Stacks. Stacks2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations.
Fall 2007CS 2251 Stacks Chapter 5. Fall 2007CS 2252 Chapter Objectives To learn about the stack data type and how to use its four methods: push, pop,
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.
Stack: Linked List Implementation Push and pop at the head of the list New nodes should be inserted at the front of the list, so that they become the top.
Chapter 6 Stacks. © 2005 Pearson Addison-Wesley. All rights reserved6-2 The Abstract Data Type Specifications of an abstract data type for a particular.
Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley. Ver Chapter 6: Stacks Data Abstraction & Problem Solving with C++
© 2006 Pearson Addison-Wesley. All rights reserved7A-1 Chapter 7 Stacks.
© 2006 Pearson Addison-Wesley. All rights reserved7A-1 Chapter 7 Stacks (and a bit of generics for flavor)
Topic 3 The Stack ADT.
Chapter 7 Stacks II CS Data Structures I COSC 2006
Implementing Stacks Ellen Walker CPSC 201 Data Structures Hiram College.
Chapter 7 Stacks I CS Data Structures I COSC 2006 April 22, 2017
Data Structures. The Stack: Definition A stack is an ordered collection of items into which new items may be inserted and from which items may be deleted.
Stack. Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations on the data.
COP3530 Data Structures600 Stack Stack is one the most useful ADTs. Like list, it is a collection of data items. Supports “LIFO” (Last In First Out) discipline.
Chapter 7 Stacks. © 2004 Pearson Addison-Wesley. All rights reserved 7-2 The Abstract Data Type: Developing an ADT During the Design of a Solution Specifications.
© 2004 Goodrich, Tamassia Stacks. © 2004 Goodrich, Tamassia Stacks2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data.
1 Stacks. 2 A stack has the property that the last item placed on the stack will be the first item removed Commonly referred to as last-in, first-out,
Chapter 8 Queue I CS Data Structures I COSC2006 April 24, 2017
Stacks and Queues Based on D.S. Malik, Java Programming: Program Design Including Data Structures.
CHAPTER 3 STACK CSEB324 DATA STRUCTURES & ALGORITHM.
Stacks Ellen Walker CPSC 201 Data Structures Hiram College.
Chapter 4 ADTs Stack and Queue. 4-2 Formal ADT Specifications The Java interface construct lets us collect together method interfaces into a syntactic.
M180: Data Structures & Algorithms in Java Stacks Arab Open University 1.
11/07/141 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: –Data stored –Operations on the.
Click to edit Master text styles Stacks Data Structure.
1 Stacks Abstract Data Types (ADTs) Stacks Application to the analysis of a time series Java implementation of a stack Interfaces and exceptions.
Chapter 7 Stacks © 2006 Pearson Addison-Wesley. All rights reserved 7A-1.
Chapter 6 A Stacks. © 2004 Pearson Addison-Wesley. All rights reserved6 A-2 The Abstract Data Type: Developing an ADT During the Design of a Solution.
Data Abstraction and Problem Solving with JAVA Walls and Mirrors Frank M. Carrano and Janet J. Prichard © 2001 Addison Wesley Data Abstraction and Problem.
CS Data Structures Chapter 6 Stacks Mehmet H Gunes
Stacks Chapter 6.
CC 215 Data Structures Stack ADT
Abstract Data Types (ADTs)
Stacks.
Stacks.
Stacks Data Structures and Problem Solving with C++: Walls and Mirrors, Carrano and Henry, © 2013.
Stacks Chapter 5 Adapted from Pearson Education, Inc.
Stacks Chapter 5.
Abstract Data Types (ADTs)
Chapter 7 (continued) © 2011 Pearson Addison-Wesley. All rights reserved.
Chapter 7 © 2011 Pearson Addison-Wesley. All rights reserved.
Presentation transcript:

CS Data Structures I Chapter 6 Stacks I

2 Topics ADT Stack Stack Operations Using ADT Stack Line editor Bracket checking Special-Palindromes Implementation of ADT Stack Using Arrays

3 Introduction Stack: Ordered group of homogeneous items Only one item can be accessed at a time (top) Items addition / removal take place only at the top Inserting an item is known as "pushing" onto the stack. Removing an item is known as "popping" off the stack. Has Last-In-First-Out (LIFO) behavior

4 Stack Of Cups Add a cup to the stack. bottom top C A B D E F Remove a cup from new stack. bottom top C A B D E

5 Introduction Real-life examples: Trays Pennies Folded shirts Books... Very useful in computer science Converting numeric strings into equivalent values Evaluating algebraic expressions

6 LIFO A stack is a LIFO (Last-in-first-out) list push pop top bottom stack depth = 5

7 Introduction Example: Line-editor a b c c d d d e e f f g means backspace will generate the following output: a b c d e f g Observations

8 Introduction Example: Line-editor Pseudocode: // Read the line, correcting mistakes along the way while (not end of line) { Read a new character ch if ( ch is not a ) Add ch to the ADT else Remove the most recently added item from the ADT } // end while

9 Introduction Writing the line: First Draft: // Write the line while (the ADT is not empty) { Remove most recently added item from the ADT Write item } // end while

10 Introduction Example: Line-editor The following operations are needed Determine if the line is empty Add a character Remove the most-recently added character Retrieve the most recently added item These are exactly the operations needed for a stack The ADT Stack can be used to perform the reading and correction of the line

11 The Stack Interface In Java We can define our own stack interface like this: public interface StackInterface { public boolean isFull(); // returns if the stack is full public boolean isEmpty(); // return if the stack is empty public Object top() // return the top element throws StackException; // if the stack is empty public void push(Object obj); // push obj onto the stack public void popAll (); public Object pop() // return and remove the // top element of the stack throws StackException; // if the stack is empty }

12 Using ADT Stack Read & Correct a text of line: Using stack operations +readAndCorrect( out aStack : Stack) // Reads input line and either enters characters onto stack S // or corrects contents if the character is the symbol aStack.createStack Read newChar while ( newChar != eoln ) {if ( newChar != ) aStack.Push( newChar) else if (! aStack.isEmpty()) aStack.Pop( ) read newChar } // end while

13 Using ADT Stack Write Backwards using ADT stack operations: +displayBackward ( in aStack ; Stack) // Displays input line in reverse order by writing // the contents of stack aStack while ( ! aStack.isEmpty ( ) ) {aStack.pop ( newChar ) write newChar } // end while

14 Stack Application Example: Balanced Braces Assumption All braces are of the same type Example: a b c { d e f g { i j k } { l { m n } } o p } q r Balanced a b c { d e f } } { g h I j { k l } m Unbalanced

15 Stack Application Balanced Braces Idea: keep track for unmatched { by pushing them onto a stack When } is encountered, pop one of the unmatched { from the stack Stop when The string and stack are both empty Success Stack is empty, but string still contains closing braces (}) Failure: more closing braces String is empty but stack still contains unmatched opening braces ({) Failure: more opening braces

16 Stack Application Balanced Braces: Pseudocode aStack.createStack ( ) balancedSoFar = true i = 0 while ( balancedSoFar and i < length of aString) {ch = character at position i ++ i if ( ch = {) aStack.push( { ) else if ( ch = } ) aStack.pop( ) // Pop a matching open brace elsebalancedSoFar = false // ignore all characters other that braces }// end while if ( balancedSoFar && aStack.isEmpty( ) ) aString has balanced braces else aString doesnt have balanced braces

17 Stack Application Balanced Braces: Examples { a { b } c } { a { b c } { a b } }

18 Stack Application How about math expression with 3 types of brackets () [] {}

19 Stack Application Algorithm Scan expression from left to right Each time a left bracket is encountered, push it onto stack When a right bracket is encountered, compare it with the top item on the stack If it is a match, pop the stack If not, report illegal bracketing If the stack id prematurely empty, report illegal If there are items left on the stack after the expression has been scanned, report illegal bracketing

20 Stack Application (3+4)*{7+[4/8]}

21 Stack Application Special-Palindromes L = { w $ w ' : w is either empty or any string not including $, and w ' = reverse (w) } Idea: Traverse the first half and push its elements onto the stack When $ is reached, ignore it and start traversing and matching each element from the input string with that on the stack Termination: Success: Both stack and string are empty Failure: Character on input doesn't match character on stack top String empty, but stack isn't Stack empty, but string isn't

22 Stack Application Special-Palindromes: Pseudocode using ADT Stack aStack.createStack ( ) // Push characters preceding $ onto stack i = 0ch = character at position i in string while ( ch != $) {aStack.Push ( ch ) ++ich = character at position i in string } // end while ++i// Skip the $ // match the reverse of w inLanguage = true // assume string is in language while ( inLanguage && i < length of aString) try {aStack.pop (StackTop) ch = character at position i in string if ( StackTop = ch ++i // Characters match elseinLanguage = false } // end try catch {// pop failed, stack empty (1st half of string shorter than 2nd half inLanguage = false } // end catch If (inLanguage && isEmpty()) aString is in language Else aString is not in language

23 ADT Stack Implementation implementations Arrays Linked lists ADT List Vector

24 ADT Stack Implementation ArrayLinked ListADT List Top Top Top

25 An Array-Based Stack We can use arrays for our stacks by requiring a maximum size N for our stack (e.g. N = 50) The stack would then consist of an N-element array, s, and the array index of the top element, t Array indices start at 0,so we will initialize t to -1 Pseudo-code: int size(): return t +1 boolean isEmpty(): return t < 0 Object top(): if isEmpty() then throw StackEmptyException else return s [t ]

26 Stack Interface public interface StackInterface { public boolean isEmpty(); public boolean isFull(); public void push(Object newItem) throws StackException; public Object pop() throws StackException; public void popAll(); public Object peek() throws StackException; } // end StackInterface

27 Stack Exception public class StackException extends java.lang.RuntimeException { public StackException(String s) { super(s); } // end constructor } // end StackException

28 Array Stack Implementation (1) public class ArrayStackBased implements StackInterface { final int MAX_STACK = 50; // maximum size of stack private Object items[ ]; private int top; public ArrayStackBased() { items = new Object[MAX_STACK]; top = -1; } // end default constructor public boolean isEmpty() { return top < 0; } // end isEmpty public boolean isFull() { return top == MAX_STACK-1; } // end isFull

29 Array Stack Implementation (2) public void push(Object newItem) throws StackException { if (!isFull()) { items[++top] = newItem; } else { throw new StackException("StackException on " + "push: stack full"); } // end if } // end push public void popAll() { items = new Object[MAX_STACK]; top = -1; } // end popAll

30 Array Stack Implementation (3) public Object pop() throws StackException { if (!isEmpty()) { return items[top--]; } else { throw new StackException("StackException on " + "pop: stack empty"); } // end if } // end pop public Object peek() throws StackException { if (!isEmpty()) { return items[top]; } else { throw new StackException("Stack exception on " + "peek - stack empty"); } // end if } // end peek } // end ArrayStack

31 Array Stack Test public class ArrayStackTest { public static final int MAX_ITEMS = 15; public static void main(String[ ] args) { ArrayStackBased stack = new ArrayStackBased(); Integer items[ ] = new Integer[MAX_ITEMS]; System.out.println("Pushing:"); for (int i=0; i<MAX_ITEMS; i++) { items[i] = new Integer(i); if (!stack.isFull()) { System.out.print(" "+i); stack.push(items[i]); } // end if } // end for System.out.println("\nPopping:"); while (!stack.isEmpty()) { // cast result of pop to Integer System.out.print(" "+(Integer)(stack.pop())); } // end while System.out.println(); } // end main } // end ArrayStackTest

32 Array Stack Test Output Pushing: Popping:

33 Array Stack Questions: Can we push/pop primitive type value onto the stack? Can we push/pop different objects onto the stack? Student Car How to access each object