Download Stack

DATA STRUCTURE &
ALGORITHMS
CHAPTER 3: STACKS
Objectives
In this chapter, you will:
• Learn about stacks
• Examine various stack operations
• Discover stack applications
2
Stacks
• Stack: list of homogenous elements
– Addition and deletion occur only at one end,
called the top of the stack
• Example: in a cafeteria, the second tray can be
removed only if first tray has been removed
– Last in first out (LIFO) data structure
• Operations:
– Push: to add an element onto the stack
– Pop: to remove an element from the stack
3
Stacks (continued)
4
Stack Operations
• In the abstract class stackADT:
– initializeStack
– isEmptyStack
– isFullStack
– push
– top
– pop
6
Stack Application
Stack applications classified into 4 broad categories:
• Reversing data – e.g. reverse a list & convert decimal
to binary.
– Eg. 26 = 110102
• Parsing data – e.g. translate a source program to
machine language.
• Postponing data usage – e.g. evaluation,
transformation.
• Backtracking – e.g. computer gaming, decision
analysis, expert systems.
Implementation of Stacks as Arrays
• First element can go in first array position,
the second in the second position, etc.
• The top of the stack is the index of the last
element added to the stack
• Stack elements are stored in an array
• Stack element is accessed only through top
• To keep track of the top position, use a
variable called stackTop
8
Implementation of Stacks as Arrays
• Because stack is homogeneous
– You can use an array to implement a stack
• Can dynamically allocate array
– Enables user to specify size of the array
• The class stackType implements the
functions of the abstract class stackADT
9
Implementation of Stacks as Arrays
• C++ arrays begin with the index 0
– Must distinguish between:
• The value of stackTop
• The array position indicated by stackTop
• If stackTop is 0, the stack is empty
• If stackTop is nonzero, the stack is not
empty
– The top element is given by stackTop - 1
10
Implementation of Stacks as Arrays
11
Initialize Stack
12
Empty Stack
• If stackTop is 0, the stack is empty
Full Stack
• The stack is full if stackTop is equal to
maxStackSize
14
Push
• Store the newItem in the array component
indicated by stackTop
• Increment stackTop
• Must avoid an overflow
15
Push
16
Return the Top Element
17
Pop
• Simply decrement stackTop by 1
• Must check for underflow condition
18
Stacks Example
• Example
Suppose the following 6 elements are pushed, in order, onto
an empty stacks.
A, B, C, D, E, F
We write the stack:
STACK: A, B, C, D, E, F
Pseudocode for Array of Stacks
Procedure 3.1 PUSH(STACK, TOP, MAXSTK, ITEM)
This procedure pushes an ITEM onto a stack.
1. [Stack already filled ?]
If TOP = MAXSTK, then: Print:OVERFLOW, and
Return.
2. Set TOP := TOP + 1. [Increses TOP by 1]
3. Set STACK[TOP] :=ITEM. [Inserts ITEM in new TOP
position.
4. Return.
Pseudocode for Array of Stacks
•
Procedure 3.2 POP(STACK, TOP, ITEM)
This procedures deletes the top element of STACK
and assigns it to the variable ITEM.
1. [Stacks has an item to be removed?]
If TOP = 0, the Print: UNDERFLOW, and RETURN.
2. Set ITEM := STACK[TOP].[Assigns TOP elements
to ITEM.]
3. Set TOP := TOP – 1.[ Decreases TOP by 1]
4. Return.
Stack Exercise
Exercise 1:
Consider the following stack of characters, where STACK is allocated N = 8
memory cells :
STACK : A,C,D, F, K, _, _ , _
( For notational convenience, we use “_” to denote an empty memory cell).
Describe the stack as the following operations take place :
(a) POP (STACK, ITEM )
(e) POP (STACK, ITEM)
(b) POP (STACK,ITEM)
(f) PUSH(STACK, R)
(c) PUSH (STACK, L)
(g) PUSH(STACK, S)
(d) PUSH (STACK, P)
(h) POP(STACK, ITEM)
Stack Exercise
Exercise 2:
Consider the following stack, where STACK is allocated N = 6 memory
cells :
STACK : A, D, E, F, G, _______.
(a) PUSH(STACK, K)
(b) POP(STACK, ITEM )
(c) PUSH(STACK, L)
(d) PUSH(STACK,S)
(e) POP(STACK, ITEM)
(f) PUSH(STACK, M)
Copy Stack
25
Stack Header File
• Place definitions of class and functions
(stack operations) together in a file
26
Linked Implementation of Stacks
• Array only allows fixed number of elements
• If number of elements to be pushed exceeds
array size
– Program may terminate
• Linked lists can dynamically organize data
• In a linked representation, stackTop is
pointer to top element in stack
29
Default Constructor
• Initializes the stack to an empty state when a
stack object is declared
– Sets stackTop to NULL
31
Empty Stack and Full Stack
• In the linked implementation of stacks, the
function isFullStack does not apply
– Logically, the stack is never full
32
Initialize Stack
33
Push
• The newElement is added at the beginning
of the linked list pointed to by stackTop
34
Push (continued)
35
Push (continued)
36
Push (continued)
37
Push (continued)
• We do not need to check whether the stack
is full before we push an element onto the
stack
38
Return the Top Element
C++ Programming: Program Design Including Data Structures, Fourth Edition
39
.
Pop
• Node pointed to by stackTop is removed
40
Pop (continued)
C++ Programming: Program Design Including Data Structures, Fourth Edition
42
Copy Stack
43
Copy Stack
• Notice that this function is similar to the
definition of copyList for linked lists
44
Application of Stacks: Postfix
Expressions Calculator
• Infix notation: usual notation for writing
arithmetic expressions
– The operator is written between the operands
– Example: a + b
– The operators have precedence
• Parentheses can be used to override precedence
45
Application of Stacks: Postfix
Expressions Calculator
• Prefix (Polish) notation: the operators are
written before the operands
– Introduced by the Polish mathematician Jan
Lukasiewicz
• Early 1920s
– The parentheses can be omitted
– Example: + a b
46
Application of Stacks: Postfix
Expressions Calculator
• Reverse Polish notation: the operators follow
the operands (postfix operators)
– Proposed by the Australian philosopher and
early computer scientist Charles L. Hamblin
• Late 1950's
– Advantage: the operators appear in the order
required for computation
– Example: a + b * c
• In a postfix expression: a b c * +
47
Application of Stacks: Postfix
Expressions Calculator
48
Application of Stacks: Postfix
Expressions Calculator
• Postfix notation has important applications in
computer science
– Many compilers first translate arithmetic
expressions into postfix notation and then
translate this expression into machine code
• Evaluation algorithm:
– Scan expression from left to right
– When an operator is found, back up to get the
operands, perform the operation, and continue
49
Application of Stacks: Postfix
Expressions Calculator
• Example: 6 3 + 2 * =
– Read first symbol
• 6 is a number  push it onto the stack
– Read next symbol
• 3 is a number  push it onto the stack
50
Application of Stacks: Postfix
Expressions Calculator
• Example: 6 3 + 2 * =
– Read next symbol
• + is an operator (two operands)  pop stack
twice, perform operation, put result back onto stack
51
Application of Stacks: Postfix
Expressions Calculator
• Example: 6 3 + 2 * =
– Read next symbol
• 2 is a number  push it onto the stack
52
Application of Stacks: Postfix
Expressions Calculator
• Example: 6 3 + 2 * =
– Read next symbol
• * is an operator  pop stack twice, perform
operation, put result back onto stack
53
Application of Stacks: Postfix
Expressions Calculator
• Example: 6 3 + 2 * =
– Read next symbol
• = is an operator  indicates end of expression
• Print the result (pop stack first)
54
Application of Stacks: Postfix
Expressions Calculator
• Symbols can be numbers or anything else:
– +, -, *, and / are operators
• Pop stack twice and evaluate expression
• If stack has less than two elements  error
– If symbol is =, the expression ends
• Pop and print answer from stack
• If stack has more than one element  error
– If symbol is anything else
• Expression contains an illegal operator
55
Application of Stacks: Postfix
Expressions Calculator
• Examples:
7 6 + 3 ; 6 - =
• ; is an illegal operator
14 + 2 3 * =
• Does not have enough operands for +
14 2 3 + =
• Error: stack will have two elements when we
encounter equal (=) sign
56
Application of Stacks: Postfix
Expressions Calculator
• We assume that the postfix expressions are
in the following form:
#6 #3 + #2 * =
– If symbol scanned is #, next input is a number
– If the symbol scanned is not #, then it is:
• An operator (may be illegal) or
• An equal sign (end of expression)
• We assume expressions contain only +, -, *,
and / operators
57
Conclusions
• Stack: items are added/deleted from one end
– Last In First Out (LIFO) data structure
– Operations: push, pop, initialize, destroy, check for
empty/full stack
– Can be implemented as array or linked list
– Middle elements should not be accessed
• Postfix notation: operators are written after the
operands (no parentheses needed)
58
References
C++ Programming: Program Design Including
Data Structures, Fourth Edition
59