CSC 231 Stacks 1 Devon M. Simmonds University of North Carolina, Wilmington TIME: Tuesday/Thursday 11:11:50am in 1012 & Thursday 3:30-5:10pm in 2006. Office.

CSC231

Stacks

1

Devon M. SimmondsUniversity of North Carolina, Wilmington

TIME: Tuesday/Thursday 11:11:50am in 1012 & Thursday 3:30-5:10pm in 2006. Office hours: TR 1-2pm or by appointment. Office location: CI2046. Email: simmondsd[@]uncw.edu

CSC231

Objectives

2

Describe the stack ADT Understand pre and post

conditions for stack operations. Apply the stack ADT to real

world applications. Explain how the Python virtual

machine uses a stack to support function and method calls

CSC2313

Summary of Lists

CSC231

Lists• A list is an ordered collection of zero or more

references to Python data objects. • Lists are written as comma-delimited values

enclosed in square brackets. • The empty list is simply [ ].

4

CSC2315

Creating Lists

list1 = list() # Create an empty listlist2 = list([2, 3, 4]) # Create a list with elements 2, 3, 4list3 = list(["red", "green", "blue"]) # Create a list with stringslist4 = list(range(3, 6)) # Create a list with elements 3, 4, 5list5 = list("abcd") # Create a list with characters a, b, c

list1 = [] # Same as list()list2 = [2, 3, 4] # Same as list([2, 3, 4]) list3 = ["red", "green"] # Same as list(["red", "green"])

Creating list using the list class

For convenience, you may create a list using the following syntax:

CSC2316

list Methods

list

append(x: object): None

insert(index: int, x: object): None

remove(x: object): None

index(x: object): int

count(x: object): int

sort(): None

reverse(): None

extend(l: list): None

pop([i]): object

Add an item x to the end of the list.

Insert an item x at a given index. Note that the first element in the list has index 0.

Remove the first occurrence of the item x from the list.

Return the index of the item x in the list.

Return the number of times item x appears in the list.

Sort the items in the list.

Reverse the items in the list.

Append all the items in L to the list.

Remove the item at the given position and return it. The square bracket denotes that parameter is optional. If no index is specified, list.pop() removes and returns the last item in the list.

CSC231

Typical Operations on Lists• Finding length of list• Finding the smallest value• Finding the largest value• Summing the elements in the list• Slicing a list• Sorting a list• Testing membership• List comprehension• Splitting a string into a list

7

CSC231

• …

8

Stacks – a last in first out data

structure.

CSC231

Abstract Data Types (ADTs)

•An ADT is the specification of:▫A set of objects (data) and▫A set of operations performed on the

objects

•ADT is specified without regard to:▫Programming language▫Implementation nuances

9

CSC231

Stacks

• A stack is a linear list in which items are added and removed from one end of the list called its top.

• The Stack ADT (LIFO)▫ Stack S = {s1 s2 s3 … sN}

▫ Operations: push(item) - adds a new item to the stack. pop():item - removes and return item at the top of the stack. peek ():item- returns item at top of stack, stack unchanged.

Peek is sometine called top isEmpty() – returns True when the stack is empty. size() - returns the number of items on the stack.

10

CSC231

Overview of Stacks

•Stack: LIFO structure in which access is completely restricted to just one end, called the top▫Basic operations: push and pop

from Fundamentals of Python: From First Programs Through Data Structures

11

CSC231

List/Array implementation of stacks

• A stack type is not built into Python• To implement a stack, items are inserted and

removed at the same end (called the top)• Efficient list implementation requires that the top of

the stack be towards the center of the array, not fixed at one end

• To use a list to implement a stack, you need both the array itself and an integer

• The integer tells you either:▫Which location is currently the top of the stack, or▫How many elements are in the stack

12

CSC231Pushing and popping

• If the bottom of the stack is at location 0, then an empty stack is represented by top = -1 or count = 0

• To add (push) an element, either:▫ Increment top and store the element in stk[top]], or▫ Store the element in stk[count]] and increment count

• To remove (pop) an element, either:▫ Get the element from stk[top]] and decrement top, or▫ Decrement count and get the element in stk[count]]

13

top = 3 or count = 4

17 23 97 44

0 1 2 3 4 5 6 7 8 9stk:

CSC231After popping

• When you pop an element, do you just leave the “deleted” element sitting in the array?

• The surprising answer is, “it depends”▫ If this is an array of primitives, or if you are programming in

C or C++, then doing anything more is just a waste of time▫ If you are programming in Java, and the array contains

objects, you should set the “deleted” array element to null▫ Why? To allow it to be garbage collected!

14


17 23 97 44

0 1 2 3 4 5 6 7 8 9stk:

CSC231

Sharing space• Of course, the bottom of the stack could be at

the other end

• Sometimes this is done to allow two stacks to share the same storage area

15


17239744

0 1 2 3 4 5 6 7 8 9stk:

topStk2 = 6

1723974449 57 3

0 1 2 3 4 5 6 7 8 9stks:

topStk1 = 2

CSC231

A Stack class

16

# Implementation of a stack ADTclass Stack: def __init__(self): self.items = [] def is_empty(self): return self.items == [] def push(self, item): self.items.append(item) def pop(self): return self.items.pop()

def peek(self): return self.items[len(self.items)-1] def size(self): return len(self.items)

def getStack(self): return self.items

def main(): s = Stack() print(s.is_empty()) for n in range(7): s.push(n*10) print(s.getStack())

main()

CSC231

Instantiating a Stack

•We assume that any stack class that implements this interface will also have a constructor that allows its user to create a new stack instance

•This is how we instantiate a stack: s = Stack()

Fundamentals of Python: From First Programs Through

Data Structures

17

CSC231

Applications of Stacks

•We now discuss other applications of stacks:▫Matching parentheses▫Converting decimal numbers to binary

numbers▫Evaluating arithmetic expressions▫Using stacks to solve backtracking

problems▫Using stacks in computer memory

management


Data Structures

18

CSC231

Example Application: Matching Parentheses•Compilers need to determine if the

bracketing symbols in expressions are balanced correctly

Fundamentals of Python: From First Programs Through Data Structures

19

CSC231

Example Application: Matching Parentheses (continued)• Approach 1: Count left and right parentheses

▫Does not work• Approach 2:

▫Scan expression; push left brackets onto a stack▫On encountering a closing bracket, if stack is

empty or if item on top of stack is not an opening bracket of the same type, we know the brackets do not balance

▫Pop an item off the top of the stack and, if it is the right type, continue scanning the expression

▫When we reach the end of the expression, stack should be empty; if not, brackets do not balance


Data Structures

20

CSC231

Decimal to Binary Number Conversion

•Algorithm▫Repeat until number is < 2

Divide number by 2 (modular arithmetic) Place remainder on stack Number becomes number mod 2

▫Push number on the stack▫Pop elements from stack and arrange so

that the last element on the stack is the first digit of the binary number


21

CSC231

Decimal to Binary Number Conversion

•In


22

CSC231Evaluating Arithmetic Expressions•In the infix form of an arithmetic

expression, each operator is located between its operands

•In the prefix form of an arithmetic expression, each operator comes immediately before its operands

•In the postfix form of an arithmetic expression, an operator immediately follows its operands


23

CSC231Evaluating Arithmetic Expressions• infix form of an arithmetic expression

▫A + B•prefix form of an arithmetic expression

▫+AB•postfix form of an arithmetic expression

▫AB+


24

CSC231Evaluating Arithmetic Expressions


25

Arithmetic ExpressionsINFIX PREFIX POSTFIXA+B +AB AB+

A+B*C +A*BC ABC*+(A+B)*C *+ABC AB+C*

A+B*C+D(A+B)*C+D

(A+B)*(C+D)A*B+C*DA+B+C+D

(A+B)*C-(D-E)*(F+G)

CSC231

Algorithm for postfix Evaluating

1. Create an empty stack2. Convert the postfix expression to a list using split3. Scan the token list from left to right

a. If the token is an operand, convert it from a string to an integer and push the value onto the stack.

b. If the token is an operator, *, ?, +, -, it needs two operands. Pop the stack twice. The first pop produces the second operand and the second pop produces the first operand.

c. Perform the arithmetic operation and push the result back on the stack.

4. When the list is empty, and the expression has been completely processed, the result is on the stack. Pop the stack and return the result.


26


6undamentals of Python: 6rom 6irst Programs Through 2ata Structures

27

3rithmetic ExpressionsINFIX POSTFIX

3+4 34+3+4*5 345*+

(3+4)*5 34+5*3+4*5+2 345*+2+

(3+4)*5+2 34+5*2+(3+4)*(5+2) 34+52+*

3*4+5*2 34*52*+3+4+5+2 34+5+2+

(3+4)*5-(9-6)*(6+7) 34+5*96-67+*-

CSC231Pre and Post Conditions for Stack Operations

• Precondition – a condition that must be true before the operation executes.

• Postcondition – a condition that must be true after the operation executes.

• The Stack ADT (LIFO)▫ push(item) - add a new item to the stack.

Pre: Post:

▫ pop(item) - remove and return last item added. Pre: Post:

▫ peek ()- remove and return last item added. Pre: Post:

▫ isEmpty() - checks whether the stack is empty. Pre: Post:

▫ size() - returns the number of items on the stack. Pre: Post:

28

CSC231

Error checking• There are two stack errors that can occur:

▫ Underflow: trying to pop (or peek at) an empty stack

▫ Overflow: trying to push onto an already full stack• For underflow, you should throw an exception• If you don’t catch it yourself, an

“OutOfBound” exception my be thrown.• You could create your own, more informative

exception• For overflow, you could do the same things• Or, you could check for the problem, and copy

everything into a new, larger array

29

CSC231

Summary

30

Describe the stack ADT Understand pre and post conditions

for stack operations. Apply the stack ADT to real world

applications. Balancing parentheses Decimal to binary conversion

Explain how the Python virtual machine uses a stack to support function and method calls

CSC23131

______________________Devon M. Simmonds

Computer Science Department

University of North Carolina Wilmington

_____________________________________________________________

Qu es ti ons?

Reading for next class?

CSC231Pre and Post Conditions for Stack Operations

• Precondition – a condition that must be true before the operation executes.• Postcondition – a condition that must be true after the operation executes.• The Stack ADT (LIFO)

▫ push(item) - adds a new item to the stack. Pre: Stack is not full Post: item is at the top of the stack

▫ pop() - removes and return item at the top of the stack. Pre: stack is not empty Post: size()@pre – 1 == size()@post and peek()@pre == item removed

▫ peek ()- returns item at the top of the stack. Stack is unchanged. Pre: None Post: Stack unchanged

▫ isEmpty() – returns True when the stack is empty. Pre: None Post: Stack unchanged

▫ size() - returns the number of items on the stack. Pre: None Post: result = # of items@pre, stack unchanged

32



33

Arithmetic ExpressionsINFIX PREFIX POSTFIXA+B +AB AB+

A+B*C +A*BC ABC*+(A+B)*C *+ABC AB+C*

A+B*C+D ++A*BCD ABCD*++(A+B)*C+D +*+ABCD AB+C*D+

(A+B)*(C+D) *+AB+CD AB+CD+*A*B+C*D +*AB*CD AB*CD*+A+B+C+D +++ABCD AB+C+D+

(A+B)*C-(D-E)*(F+G) -*+ABC*-DE+FG AB+C*DE-FG+*-

CSC231

Algorithm for postfix Evaluating

1. Create an empty stack2. Convert the postfix expression to a list3. Scan the token list from left to right

a. If the token is an operand, convert it from a string to an integer and push the value onto the stack.

b. If the token is an operator, *, ?, +, -, it needs two operands. Pop the stack twice. The first pop produces the second operand and the second pop produces the first operand.

c. Perform the arithmetic operation and push the result back on the stack.

4. When the list is empty, and the expression has been completely processed, the result is on the stack. Pop the stack and return the result.


34

CSC 231 Stacks 1 Devon M. Simmonds University of North Carolina, Wilmington TIME: Tuesday/Thursday 11:11:50am in 1012 & Thursday 3:30-5:10pm in 2006. Office.

Documents

stack operations

stack unchanged

linear list

list 7csc2318stacks

stack adtunderstand

green creating list

stack adt lifostack

list classfor convenience