Stacks. Gaddis 18.1, Molly A. O'Neil CS 2308 :: Spring 2016

Size: px

Start display at page:

Download "Stacks. Gaddis 18.1, Molly A. O'Neil CS 2308 :: Spring 2016"

Annabella Ray
6 years ago
Views:

1 Stacks Gaddis 18.1, 18.3 Molly A. O'Neil CS 2308 :: Spring 2016

The Stack ADT A stack is an abstract data type that stores a collection of elements of the same type The elements of a stack are accessed in LIFO (last in, first out) order No random access to

2 The Stack ADT A stack is an abstract data type that stores a collection of elements of the same type The elements of a stack are accessed in LIFO (last in, first out) order No random access to non-first elements You can only access or remove the most-recently-added element Analogy: A stack of plates or trays in a cafeteria. Clean plates/trays are put on top of the stack, and the next person takes the plate/try on top of the stack. 2

3 Stack Operations The stack ADT supports the following operations: push: add a value onto the top of the stack If it's a size-limited stack, first make sure the stack isn't full pop: remove the value at the top of the stack Depending on the implementation, sometimes pop returns the value as well isempty: returns true if the stack contains no elements Optionally, a stack can also support the following operations: peek: return the value currently at the top of the stack (without popping it from the stack) isfull: if the stack is size-limited, returns true if the stack has no more space to hold additional elements 3

4 Stack Illustrated stack.push(3) stack.push(2) stack.push(5) stack.push(1) x = stack.pop()

5 Stack Illustrated stack.push(3) 1 stack.push(2) stack.push(5) stack.push(1) x = stack.pop() 5 2 x 3 5

6 Stack Illustrated stack.push(3) stack.push(2) stack.push(5) stack.push(1) x = stack.pop() 5 x 1 y = stack.pop() 2 3 6

7 Stack Illustrated stack.push(3) 5 stack.push(2) stack.push(5) stack.push(1) y x = stack.pop() y = stack.pop() 2 3 7

8 Stack Illustrated stack.push(3) stack.push(2) stack.push(5) stack.push(1) x = stack.pop() 4 6 y 5 y = stack.pop() 2 stack.push(6) 3 stack.push(4) z = stack.pop() 8

9 Stack Illustrated stack.push(3) 4 stack.push(2) stack.push(5) stack.push(1) x = stack.pop() y = stack.pop() stack.push(6) stack.push(4) z = stack.pop() z 9

10 Stack Illustrated stack.push(3) stack.push(2) stack.push(5) stack.push(1) x = stack.pop() 6 z 4 y = stack.pop() 2 stack.push(6) 3 stack.push(4) z = stack.pop() 10

11 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input

12 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input = 9 12

13 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input

14 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input 7-2 =

15 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input

16 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input 9 * 5 = 45 16

17 Stack Applications Syntax parsing (e.g., bracket matching, cf. Project 7) Compilers have to do this Evaluating arithmetic expressions in post-fix notation * is equivalent to (4 + 5) * (7-2) Algorithm: Parse input from L to R As you encounter operands, push them onto the stack If you encounter an operator, pop two operands from the stack and apply the operation, then push the result onto the stack Keep going until no more input Precedence rules and parentheses are never needed! 17

18 Stack Applications "Undo" feature in text editors Recent text changes are kept in a stack Backtracking Imagine you must write code to guide a robot through a maze or labyrinth Every time you reach a decision point, choose a direction you haven't explored yet. If you hit a dead end, you must backtrack......but backtrack to where? To the previous decision point! Algorithm: At every decision point, push all possible choices onto the stack. Pop a choice and go that route. If you hit a dead end, pop the next choice from the stack. 18

19 Backtracking Decision E4: - choices: North, South H G F E D C B A E4: South E4: North 19

20 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South H G F E D C B A D6: South D6: North E4: North 20

21 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South D6: South Dead End! Backtrack: H G F E D C B A D6: North E4: North 21

22 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South D6: South Dead End! Backtrack: D6: North H G F E D C B A E4: North 22

23 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South D6: South Dead End! Backtrack: D6: North Dead End! Backtrack: H G F E D C B A E4: North 23

24 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South D6: South Dead End! Backtrack: D6: North Dead End! Backtrack: E4: North H G F E D C B A

25 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South D6: South Dead End! Backtrack: H G F E D C B A D6: North Dead End! Backtrack: E4: North Decision G4: - choices: East, West G4: West G4: East 25

26 Backtracking Decision E4: - choices: North, South E4: South Decision D6: - choices: North, South D6: South Dead End! Backtrack: D6: North Dead End! Backtrack: E4: North Decision G4: - choices: East, West G4: West H G F E D C B A G4: East 26

27 Backtracking Dead End! Backtrack: H G F E D C B A G4: East 27

28 Backtracking Dead End! Backtrack: G4: East H G F E D C B A

29 Backtracking Dead End! Backtrack: G4: East Success! H G F E D C B A This backtracking process is used for many other algorithms as well 29

30 Hardware Stacks We've already learned about one hardware application of a stack: where function local variables are stored in memory The stack is also used to store the return address during a function call This is how nested function calls work (remember the push/ pop behavior from the Dynamic Memory lecture?) When the function terminates, its stack frame is removed and the return address (where to resume executing code, i.e. where the function call was) is retrieved 30

31 Stack Terminology Stack overflow The condition resulting from trying to push an element onto a full stack if(!stack.isfull()) stack.push(item); Stack underflow The condition resulting from trying to pop an empty stack if(!stack.isempty()) stack.pop(); 31

32 Stack Implementations A stack is an ADT, which means it's defined only in terms of the properties of the data and the operations that can be performed on that data Like with the List ADT, there are several data structures we could use to implement a Stack: Linked list (...but really, you've already done this one!) Push == prepend node to list Pop == remove front node from list and return its value Fixed-size array Keep track of top index; stack has maximum size and can be full Dynamic array Keep track of top index; re-size/re-allocate array when full 32

33 A Fixed-Size Array Stack Class class IntStack { private: int *stackarray; // the stack array int stacksize; // the array size int top; // which array index is the stack top? public: IntStack(int); // constructor IntStack(const IntStack &) // copy constructor ~IntStack(); // destructor } void push(int); int pop(); bool isfull() const; bool isempty() const; 33

34 Stack: Constructors IntStack::IntStack(int size) { if(size <= 0) size = 1; // or error } stackarray = new int[size]; stacksize = size; top = -1; // empty IntStack::IntStack(const IntStack &rhs) { stackarray = new int[rhs.stacksize]; stacksize = rhs.stacksize; for(int i = 0; i < stacksize; i++) stackarray[i] = rhs.stackarray[i]; } top = rhs.top; 34

35 Stack: Destructor IntStack::~IntStack() { delete [] stackarray; } 35

36 Stack: Push void IntStack::push(int item) { assert(!isfull()); // stack overflow! } stackarray[++top] = item; The assert() statement will cause the program to terminate with an error if!isfull() returns false The best way to remember this: assert means "Make sure..." Really easy syntax for error checking & communication Just need to #include <cassert> Runtime error will include the line number of the assert() If you want a helpful error message, too, there's always this hack: assert(!isfull() && "Attempting to push to full stack!"); 36

37 Stack: Pop int IntStack::pop() { assert(!isempty()); // stack underflow! } return stackarray[top--]; 37

38 Stack: isfull & isempty bool IntStack::isFull() { return (top == stacksize - 1); // returns true if there is // no empty space on stack } bool IntStack::isEmpty() { return (top == -1); } // returns true if there are no // items on stack 38

! A data type for which: ! In fact, an ADT may be implemented by various. ! Examples:

! A data type for which: ! In fact, an ADT may be implemented by various. ! Examples: Ch. 8: ADTs: Stacks and Queues Abstract Data Type A data type for which: CS 8 Fall Jill Seaman - only the properties of the data and the operations to be performed on the data are specific, - not concerned