CS 46B - Lecture 15

Cover page image

Pre-class reading

Sections 15.5-15.6
That's in the PDF of the content area, not the printed book

Stacks

Last-in first-out
Can only access top element
Operations push, pop, isEmpty

Queues

First-in first-out
Can only add to tail, remove from head
Operations add, remove, isEmpty

Working with Stacks

`Stack<Integer> s = new Stack<>();`	Constructs an empty stack.
`s.push(1); s.push(2); s.push(3);`	Adds to the top of the stack; `s` is now `[1, 2, 3]`. (Following the `toString` method of the `Stack` class, we show the top of the stack at the end.)
`int top = s.pop();`	Removes the top of the stack; `top` is set to 3 and `s` is now `[1, 2]`.
`head = s.peek();`	Gets the top of the stack without removing it; `head` is set to 2.
`boolean b = s.empty()`	Sets `b` to false. Same as `s.size() == 0`.

Working with Queues

`Queue<Integer> q = new LinkedList<>();`	The LinkedList class implements the Queue interface.
`q.add(1); q.add(2); q.add(3);`	Adds to the tail of the queue; `q` is now `[1, 2, 3]`
`int head = q.remove();`	Removes the head of the queue; `head` is set to 1 and `q` is `[2, 3]`
`head = q.peek();`	Gets the head of the queue without removing it; `head` is set to 2.
`boolean b = s.empty()`	Sets `b` to false. Same as `s.size() == 0`.

Priority Queues

Add elements in any order
Remove the most urgent one
Not a queue!

Working with Priority Queues

`PriorityQueue<Integer> q = new PriorityQueue<>();`	This priority queue holds Integer objects. In practice, you would use objects that describe tasks.
`q.add(3); q.add(1); q.add(2);`	Adds values to the priority queue.
`int first = q.remove(); int second = q.remove();`	Each call to remove removes the most urgent item: `first` is set to 1, `second` to 2.
`int next = q.peek();`

Lecture 15 Clicker Question 1

What does this code print?

Stack<Integer> s = new Stack<>();
Queue<Integer> q = new LinkedList<>();
PriorityQueue<Integer> p = new PriorityQueue<>();
s.push(1); s.push(3); s.push(2);
while (s.size() > 0) q.add(s.pop());
while (q.size() > 0) p.add(q.remove());
while (p.size() > 0) System.out.print(p.remove() + " ");

1 3 2
1 2 3
3 2 1
2 3 1

Application: Balancing Parentheses

Easy to check whether parentheses are balanced
Example: -(b * b - (4 * a * c ) ) / (2 * a)
Increment counter at (, decrement at )
Counter must be 0 at end and never < 0 in the middle
What if we have different kinds of parentheses?
–{ [b ⋅ b - (4 ⋅ a ⋅ c ) ] / (2 ⋅ a) }
Push them on a stack

Application: Balancing Parentheses

When you see an opening parenthesis, push it on the stack.
When you see a closing parenthesis, pop the stack.
If the opening and closing parentheses don’t match
   The parentheses are unbalanced. Exit.
If at the end the stack is empty
   The parentheses are balanced.
Else
   The parentheses are not balanced.

Application: Balancing Parentheses

Evaluating Reverse Polish Expressions

Infix operators need parentheses to specify what comes first: (3 + 4) * 5
Polish notation: Write operator before operands
* + 3 4 5
Invented by the Polish mathematician Jan Łukasiewicz
Reverse Polish: Write them after the operand
3 4 + 5 *
Used in classic pocket calculators and the Java virtual machine

Reverse Polish Notation

If you read a number
   Push it on the stack.
Else if you read an operand
   Pop two values off the stack.
   Combine the values with the operand.
   Push the result back onto the stack.
Else if there is no more input
   Pop and display the result.

Reverse Polish Notation

Lecture 15 Clicker Question 2

How do you write (3 + 4) x 5 + 6 in Reverse Polish?

3 4 5 x + 6 +
3 4 + 5 x 6 +
3 + 4 5 x + 6
None of the above

Evaluating Algebraic Expressions

Regular notation, not reverse polish
Push numbers on one stack, operators on another

Core step—evaluating the top:

Pop two numbers
Pop an operator
Apply operator to numbers
Push the result

Number stack	Operator stack	Unprocessed input	Comments
		3 + 4
3		+ 4
3	+	4
4 3	+	No more input	Evaluate the top
7			The result is 7

Operator Precedence

* has higher precedence than +
* and / have the same precedence

Don't push an operator if it has higher precedence than the top operator. Instead, evaluate the top.

Number stack	Operator stack	Unprocessed input	Comments
		3 * 4 + 5
3		* 4 + 5
3	*	4 + 5
4 3	*	+ 5	* has higher precedence Evaluate the top
12	+	5	Now push +
5 12	+	No more input	Evaluate the top
17			The result is 17

Parentheses

Push (

When encountering a ), evaluate the top until the ( reappears

Number stack	Operator stack	Unprocessed input	Comments
		3 * (4 + 5)
3		* (4 + 5)
3	*	(4 + 5)
	( *	4 + 5)
4 3	( *	+ 5)
4 3	+ ( *	5)
5 4 3	+ ( *	)
9 3	( *	No more input	Evaluate the top
9 3	*		Pop matching (
27			Evaluate the top—the result is 27

Complete Algorithm

If you read a number
	 Push it on the number stack.
Else if you read a (
	 Push it on the operator stack.
Else if you read an operator op
	 While the top of the stack has a higher precedence than op
		 Evaluate the top.
	 Push op on the operator stack.
Else if you read a )
	 While the top of the stack is not a (
		 Evaluate the top.
	 Pop the (.
Else if there is no more input
	 While the operator stack is not empty
		 Evaluate the top.

Backtracking

Escaping from a maze
Use a stack to remember all paths that still need to be tried
At an intersection, push all paths
Pop one and follow it
When a path is a dead end, pop the next one (that's the backtracking)
Repeat until exit
Can use a queue as well, but not as intuitive (you don't just go back to the last choice)

Maze Escape Example

Maze Escape Pseudocode

Push all paths from the point on which you are standing on a stack.
While the stack is not empty
	 Pop a path from the stack.
	 Follow the path until you reach an exit, intersection, or dead end.
	 If you found an exit
		 Congratulations!
	 Else if you found an intersection
		 Push all paths meeting at the intersection, except the current one, onto the stack.