Auckland Programming Algorithms and Performance Meetup about Stacks & LeetCode Problems

Stacks
Rodrigo Villarreal && Paulo Almeida
Auckland Data Structures and
Algorithms

Agenda
● Introduction to Stacks
○ Design
○ Real-world applications
● Practice
○ Examples
○ Let’s get our hands dirty!
● What’s next?

What is a Stack ?
A stack is an abstract data type that serves as a collection of
elements, with two principal operations:
1 1 2 3 5 6bottom top

What is a Stack ?
1 1 2 3 5
6
pop()bottom

What is a Stack ?
1 1 2 3 5
8
push(x)
bottom

What is a Stack ?
1 1 2 3 5 8
Both operations change the top of the stack.
bottom top

What is a Stack ?
This behaviour is sometimes referred as LIFO (Last in, First
out).

What is a Stack ?
This behaviour is sometimes referred to as LIFO (Last in, First
out).
1
push(x)
bottom top

What is a Stack ?
out).
1
push(x)
1
bottom

What is a Stack ?
out).
1
push(x)
2
1bottom

What is a Stack ?
out).
1
push(x)
3
1 2bottom

What is a Stack ?
out).
1 31 2bottom top

What is a Stack ?
out).
1 pop()
3
1 2bottom

What is a Stack ?
out).
1 pop()
2
1bottom

What is a Stack ?
out).
1 pop()
1
bottom

What is a Stack ?
out).
1
pop()
bottom top

What is a Stack ?
Like in a stack of books. One can
only add or remove from the
top of the stack.
….
(Or push/pop respectively)

Big O
Time Complexity (Avg/Worst)
Search: O(n)
Access: O(n)
Insertion: O(1)
Deletion: O(1)
Space Complexity (Worst): O(n)

Where would I use Stacks in the real world ?
I’m glad you asked :)

Real life examples
Parsing mathematical expressions
String expr = ( 9 + ( 4 / 2 ) ) * 2

Real life examples
String expr =
(
push(x)
bottom top
( 9 + ( 4 / 2 ) ) * 2

String expr =
(bottom top
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom
push(x)
9
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9
push(x)
+
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9 +
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9 +
push(x)
(
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9 + (
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9 + (
push(x)
4
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9 + ( 4
( 9 + ( 4 / 2 ) ) * 2
Real life examples

String expr =
(bottom 9 + ( 4
( 9 + ( 4 / 2 ) ) * 2
push(x)
/
Real life examples

String expr =
(bottom 9 + ( 4
( 9 + ( 4 / 2 ) ) * 2
/
Real life examples

String expr =
(bottom 9 + ( 4
( 9 + ( 4 / 2 ) ) * 2
/
push(x)
2
Real life examples

String expr =
(bottom 9 + ( 4
( 9 + ( 4 / 2 ) ) * 2
/ 2
Real life examples

String expr =
(bottom 9 + ( 4
( 9 + ( 4 / 2 ) ) * 2
/ 2
pop()pop()pop()pop()
Real life examples

String expr =
(bottom 9 +
( 9 + ( 4 / 2 ) ) * 2
push(x)
2
Real life examples

String expr =
(bottom 9 +
( 9 + ( 4 / 2 ) ) * 2
2
Real life examples

String expr =
(bottom 9 +
( 9 + ( 4 / 2 ) ) * 2
2
pop()pop()pop()pop()
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11
push(x)
top
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11 top
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11
push(x)
*
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11 *
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11 *
push(x)
2
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11 * 2
Real life examples

String expr =
bottom
( 9 + ( 4 / 2 ) ) * 2
11 * 2
pop()pop()pop()
Real life examples

String expr = ( 9 + ( 4 / 2 ) ) * 2
bottom 22
push(x)
top
Real life examples

Using Stacks in Java
Declare stack:
Stack<Type> stack = new Stack<>();
Push element:
stack.push(element);
Pop element:
stack.pop();

Valid Parentheses (L #20)
Given a string containing just the characters
determine if the input string is valid.
An input string is valid if:
● Open brackets must be closed by the same type of brackets.
● Open brackets must be closed in the correct order.
( ) { } [ ]

Test cases
Example Output
“()” true
“()[]{}” true
“(]” false
“([)]” false
“{[]}” true

Time Complexity = O(n)
Space Complexity = O(n)

Still not convinced… where else would I use
stacks?
Can you relate to this example?

Real life examples
Back / Forward Browser Button
Back Stack Forward Stack

Real life examples
www.google.comcurrent

Real life examples
www.google.com
www.facebook.comcurrent

Real life examples
www.google.com
www.facebook.com
current www.twitter.com

Real life examples
www.google.com
www.facebook.com
current
www.twitter.com
www.meetup.com

Real life examples
www.google.com
www.facebook.com
current
www.twitter.com
www.meetup.com
www.linkedin.com

Real life examples
www.google.com
www.facebook.com
www.meetup.com
www.linkedin.com

Real life examples

Real life examples
What happens if I write a new URL while I am in Twitter?
www.google.com
www.facebook.com
www.meetup.com
www.linkedin.com

Real life examples
Forward Stack gets cleared
www.google.com
www.facebook.com
current
www.twitter.com
www.gmail.com

Remove All Adjacent Duplicates In String (L
#1047)
Given a string S of lowercase letters, a duplicate removal consists of choosing two adjacent and equal
letters, and removing them.
We repeatedly make duplicate removals on S until we no longer can.
Return the ﬁnal string after all such duplicate removals have been made. It is guaranteed the answer is
unique.
Input: "abbaca"
Output: "ca"
Explanation: For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal,
and this is the only possible move. The result of this move is that the string is "aaca", of which only "aa" is
possible, so the ﬁnal string is "ca".

#1047)
Test cases
Input: "abbaca"
Output: "ca"
Input: "abcdeedcba"
Output: ""
Input: "abcdefg"
Output: "abcdefg"

#1047)
Approach #1
Iterate the string and remove the adjacents. If we ﬁnd a pair, we set a ﬂag to true indicating we
need to iterate again (since we have created a new string)
Input: "abcdeedcba"
Iteration #1: "abcddcba" Iteration #5: "abba"
Iteration #2: "abccba" Iteration #6: "aa"
Iteration #3: "abccba" Iteration #7 : ""
Iteration #4: "abccba"

#1047)
Approach #1
Time Complexity = O(n^2)

#1047)
Approach #2
We’ll use a stack this time as our support tool to solve this problem. We’ll iterate the string and
we’ll check if the stack has elements and if top of the stack (the previous char) is equal to the
element we’re currently checking.
If the previous statement is false, add the char to the stack
If the previous statement is true, pop the previous char and don’t add the current to the stack

#1047)
a b b a c a
Input
Stack

#1047)
a b b a c a
Input
Stack
a

#1047)
a b b a c a
Input
Stack
a b

#1047)
a b b a c a
Input
Stack
c

#1047)
a b b a c a
Input
Stack
c a

#1047)
Final Result
c a

#1047)
Approach #1
Approach #2

#1047)
Approach #1
Approach #2 ← Winner!

Auckland Programming Algorithms and Performance Meetup about Stacks & LeetCode Problems

Leetcode Problems
Easy
Remove All Adjacent Duplicates In String (Leetcode #1047)
Valid Parentheses (Leetcode #20)
Min Stack (Leetcode #155)
Decode String (Leetcode #394)
Medium
Design Browser History (Leetcode #1472)
Remove K Digits (Leetcode #402)
Online Stock Span (Leetcode #901)
Hard
Basic Calculator (Leetcode #224)

What next?
The next session will be about Trees!

Auckland Programming Algorithms and Performance Meetup about Stacks & LeetCode Problems

More Related Content

What's hot (19)

Similar to Auckland Programming Algorithms and Performance Meetup about Stacks & LeetCode Problems (20)

Recently uploaded (20)

Auckland Programming Algorithms and Performance Meetup about Stacks & LeetCode Problems