16. Java stacks and queues

Stack and Queue
Software University
http://softuni.bg
SoftUni Team
Technical Trainers

Table of Contents
1. Stack - Last In First Out (LIFO)
• Stack Functionality
• Java Stack Implementation
• Overview of All Operations
2. Queue - First In First Out (FIFO)
• Queue Functionality
• Java Stack Implementation
• Overview of All Operations
3. Priority Queue

sli.do
#java-advanced
Have a Question?

 Describes performance of particular algorithm
 Runtime and memory consumption based on the input size N
 We usually care about the worst-case performance
 We measure the complexity as the Big O notation
 Numerical function depending on the input size O(N)
 We measure time as the number of simple steps
 We measure memory as input data N by it's type size
Algorithmic Complexity

 O(1) – Constant time – time does not depend on N
 O(log(N)) – Logarithmic time – grows with rate as log(N)
 O(N) – Linear time grows at the same rate as N
 O(N^2),O(N^3) – Quadratic, Cubic grows as square or cube of N
 O(2^N) – Exponential grows as N becomes the exponent worst
algorithmic complexity
 For input size of 10 - 1024 steps
 For input size of 100 – 1267650600228229401496703205376
steps
 http://bigocheatsheet.com/
Algorithmic Complexity

 Calculate maximum steps to find sum of even elements in an array
 Assume that a single step is a single CPU instruction:
 assignments, array lookups, comparisons, arithmetic operations
Get Sum Number of Steps
int getSumEven(int[] array) {
int sum = 0;
for (int i = 0; i < array.length; i++)
if (array[i] % 2 == 0) sum += array[i];
return sum;
}
Solution:
T(n) = 9n + 3
Counting maximum steps is
called worst-case analysis

 Worst-case
 An upper bound on the running time
 Average-case
 Average running time
 Best-case
 The lower bound on the running time
(the optimal case)
Time Complexity

 Why don't use Stack and Queue?
 Implementation details which make unsecure usability
 In many cases those structures will decrease the performance
 Why to use ArrayDeque?
 Implementation which makes the structure more secure
 Better performance and usability
 Methods which operate as those structures suggest
Stacks And Queue vs. ArrayDeque

Stack
Last In First Out (LIFO)

 Stacks provide the following functionality:
 Pushing an element at the top of the stack
 Popping element from the top fo the stack
 Getting the topmost element without removing it
Stack Functionality
2
10
5
2
10
5
2
10
5
Push Pop Peek

ArrayDeque<E> – Java Stack Implementation
 Creating a Stack
 Adding elements at the top of the stack
 Removing elements
 Getting the value of the topmost element
stack.push(element);
ArrayDeque<Integer> stack = new ArrayDeque<>();
Integer element = stack.pop();
Integer element = stack.peek();

Stack – Utility Methods
int size = stack.size();
boolean isEmpty = stack.isEmpty();
boolean exists = stack.contains(2);

012
5
3
210515
13
Stack – Overview of All Operations
size():
5
-7
45
132
push()
pop()
peek()
Stack<Integer>

 Write a program which takes 2 types of browser instructions:
 Normal navigation: a URL is set, given by a string
 The string "back" that sets the current URL to the last set URL
Problem: Browser History
https//softuni.bg/
back
https//softuni.bg/trainings/courses
back
https//softuni.bg/trainings/2056
back
https//softuni.bg/trainings/live
https//softuni.bg/trainings/live/details
Home
Input
https//softuni.bg/
no previous URLs
https//softuni.bg/trainings/courses
https//softuni.bg/
https//softuni.bg/trainings/2056
https//softuni.bg/
https//softuni.bg/trainings/live
https//softuni.bg/trainings/live/details
Output

Scanner scanner = new Scanner(System.in);
ArrayDeque<String> browser = new ArrayDeque<>();
String line = scanner.nextLine();
String current = "";
// continue…
Solution: Browser History (1)
Check your solution here: https://judge.softuni.bg/Contests/1437/Stacks-and-Queues-Lab

while(!line.equals("Home")) {
if(line.equals("back")) {
if(!browser.isEmpty()) {current = browser.pop();
} else {
System.out.println("no previous URLs");
line = scanner.nextLine();
continue;}
} else {
if(!current.equals("")) { browser.push(current); }
current = line; }
System.out.println(current);
line = scanner.nextLine(); }
Solution: Browser History (2)

 Implement a simple calculator that can evaluate simple
expressions (only addition and subtraction)
Problem: Simple Calculator
2 + 5 + 10 - 2 - 1
Input
2 - 2 + 5
14
Output
5

Solution: Simple Calculator (1)
String[] tokens = scanner.nextLine().split("s+");
Deque<String> stack = new ArrayDeque<>();
Collections.addAll(stack, tokens);
// continues…
Split by regex
Adds a collection to
another collection

Solution: Simple Calculator (2)
while (stack.size() > 1) {
int first = Integer.valueOf(stack.pop());
String op = stack.pop();
int second = Integer.valueOf(stack.pop());
switch (op)
case "+": stack.push(String.valueOf(first + second));
break;
case "-": stack.push(String.valueOf(first - second));
break;
}
System.out.println(stack.pop());

 Create a converter which takes a decimal number and
converts it into a binary number
Problem: Decimal To Binary Converter
10
Input
1024
1010
Output
10000000000

Solution: Decimal To Binary Converter
int decimal = Integer.valueOf(scanner.nextLine());
// TODO: check if number is 0
while (decimal != 0)
stack.push(decimal % 2);
decimal /= 2;
while (!stack.isEmpty())
System.out.print(stack.pop());

 We are given an arithmetical expression with brackets (with nesting)
 Goal: extract all sub-expressions in brackets
Problem: Matching Brackets
1 + (2 - (2 + 3) * 4 / (3 + 1)) * 5
(2 + 3)
(3 + 1)
(2 - (2 + 3) * 4 / (3 + 1))

Solution: Matching Brackets (1)
String expression = scanner.nextLine();
Deque<Integer> stack = new ArrayDeque<>();
// continue…

Solution: Matching Brackets (2)
for (int i = 0; i < expression.length(); i++) {
char ch = expression.charAt(i);
if (ch == '(')
stack.push(i);
else if (ch == ')')
int startIndex = stack.pop();
String contents =
expression.substring(startIndex, i + 1);
System.out.println(contents);
}

Queues
First In First Out (FIFO)

 First In First Out
Queue
26
210 5

 Queues provide the following functionality:
 Adding an element at the end of the queue
 Removing the first element from the queue
 Getting the first element of the queue without removing it
Queue – Abstract Data Type
210 5
210 5
210 5

 Creating a Queue
 Adding elements at the end of the queue
 add() – throws exception if queue is full
 offer() – returns false if queue is full
ArrayDeque<E> – Java Queue Implementation
ArrayDeque<Integer> queue = new ArrayDeque<>();
queue.add(element);
queue.offer(element);

 Removing elements
 remove() - throws exception if queue is empty
 poll() - returns null if queue is empty
 Check first element
ArrayDeque<E> – Java Queue Implementation (2)
element = queue.remove();
element = queue.poll();
element = queue.peek();

 Adds an element to the queue
add() / offer()
-315121
32104
5
size():Queue<Integer>

 Returns and removes first element
remove() / poll()
423
5
size():Queue<Integer>
-315121

 Children form a circle and pass a hot potato clockwise
 Every nth toss a child is removed until only one remains
 Upon removal the potato is passed forward
 Print the child that remains last
Problem: Hot Potato
Mimi Pepi Toshko
2
Input
Removed Pepi
Removed Mimi
Last is Toshko
Output

Solution: Hot Potato (1)
String[] children = scanner.nextLine().split("s+");
int n = Integer.valueOf(scanner.nextLine());
ArrayDeque<String> queue = new ArrayDeque<>();
for (String child : children)
queue.offer(child);
// continue…

Solution: Hot Potato (2)
while (queue.size() > 1) {
for (int i = 1; i < n; i++)
queue.offer(queue.poll());
System.out.println("Removed " + queue.poll());
}
System.out.println("Last is " + queue.poll());

 Utility Methods
 peek() - checks the value of the first element
 size() - returns queue size
 toArray() - converts the queue to an array
 contains() - checks if element is in the queue
ArrayDeque<E> – Java Queue Implementation (3)
Integer element = queue.peeк();
Integer size = queue.size();
Integer[] arr = queue.toArray();
boolean exists = queue.contains(element);

 Gets the first element without removing it
peek()
1515
2size():Queue<Integer>
121

 Rework the previous problem so that a child is removed only on
a prime cycle (cycles start from 1)
 If a cycle is not prime, just print the child's name
Problem: Math Potato
Mimi Pepi Toshko
2
Input
Removed Pepi
Prime Mimi
Prime Toshko
Removed Mimi
Last is Toshko
Output

Solution: Math Potato
int cycle = 1;
while (queue.size() > 1) {
for (int i = 1; i < n; i++)
queue.offer(queue.poll());
if (isPrime(cycle))
System.out.println("Prime " + queue.peek());
else
System.out.println("Removed " + queue.poll());
cycle++;
}
System.out.println("Last is " + queue.poll());

Queue – Overview of All Operations
5-315
4
121
012size():Queue<Integer>
5
3
15
peek() remove()add()

 Retains a specific order to the elements
 Higher priority elements are pushed to the
beginning of the queue
 Lower priority elements are pushed to the end of the queue
Priority Queue
AC B

 …
 …
 …
Summary
41
 Stack - Last In First Out (LIFO)
 push(), pop(), peek()
 Queue - First In First Out (FIFO)
 add(), poll(), peek()
 Priority Queue

 https://softuni.bg/modules/59/java-advanced

SoftUni Organizational Partners

 Software University – High-Quality Education and
Employment Opportunities
 softuni.bg
 Software University Foundation
 http://softuni.foundation/
 Software University @ Facebook
 facebook.com/SoftwareUniversity
 Software University Forums
 forum.softuni.bg
Trainings @ Software University (SoftUni)

 This course (slides, examples, demos, videos, homework, etc.)
is licensed under the "Creative Commons Attribution-NonCom
mercial-ShareAlike 4.0 International" license
License
46

16. Java stacks and queues

More Related Content

What's hot (20)

Similar to 16. Java stacks and queues (20)

More from Intro C# Book (20)

Recently uploaded (20)

16. Java stacks and queues