Lesson 3

Hello once again, champion of code! In this session, we will delve into the world of coding interviews by focusing on stack-based problems. We endeavor to decode interview questions that leverage the Last-In, First-Out (LIFO) magic of stacks to offer elegantly efficient solutions. After today, not only will you be able to handle stacks with ease, but you'll also be able to articulate and apply this knowledge when faced with interview questions that dig for depth in data structure understanding.

Consider a sequence of integers like the peaks and valleys of a mountain range. Each peak has a height represented by an integer, and you're hiking from left to right, recording peaks shorter than the one you're currently on. For each peak, we want to find out the height of the nearest preceding peak that's lower than it — a classic problem where stacks excel.

Envision analyzing daily temperatures over several months. You're interested in knowing the last cooler day for each day you examine. This mirrors our array problem, where we're seeking the previous smaller number before each entry in the array. It’s these kinds of time-sensitive queries that stack operations handle without breaking a sweat.

You might be tempted to approach this problem with the vigor of a brute force assault — looking behind each element to find a smaller one. However, this could mean reviewing multiple times and spending unforgiving time as you consider each element repeatedly. In a vast data set, this would be akin to retracing your steps on each day's hike to find a shorter peak, an exhausting proposition!

Enter the stack — our trusty Sherpa. As we progress through the array, we push peaks onto the stack. When we encounter a peak (`arr[i]`

), we pop entries from the stack that aren't shorter than the current one. The stack's top now reveals the nearest preceding smaller peak, which we note before adding the current peak to the stack.

Let's lace up our boots and start the ascent by iterating through the array of peak heights and interacting with our stack.

Java`1import java.util.Stack; 2 3public class PrecedingSmallerElements { 4 public static int[] findPrecedingSmallerElements(int[] arr) { 5 int[] result = new int[arr.length]; 6 Stack<Integer> stack = new Stack<>(); 7 8 for (int i = 0; i < arr.length; i++) { 9 while (!stack.isEmpty() && stack.peek() >= arr[i]) { 10 stack.pop(); 11 } 12 result[i] = stack.isEmpty() ? -1 : stack.peek(); 13 stack.push(arr[i]); 14 } 15 16 return result; 17 } 18 19 public static void main(String[] args) { 20 int[] arr = {3, 7, 1, 5, 4, 3}; 21 int[] result = findPrecedingSmallerElements(arr); 22 for (int n : result) { 23 System.out.print(n + " "); 24 } 25 // Output: -1 3 -1 1 1 1 26 } 27}`

In our code, we trek through each element in the array (`arr`

). Our conditions within the loop perform the 'pop' work — discarding any peak that isn't lower than our current one, ensuring that only useful candidates remain. Then, we notate the result — either `-1`

if no such peak exists or the last peak remaining on the stack. Before moving on, we add our current peak to the stack.

Think about a real-time inventory tracking system in a warehouse where items are stacked based on the order of arrival. However, you must keep an ongoing record of the lightest item in stock for quick retrieval. This scenario highlights the need for a system that efficiently maintains a snapshot of the minimum item as stack operations proceed.

Consider tagging each item with its weight and then brute-forcing through the stack to find the minimum every time it's needed. However, this is like rummaging through the entire stock each time a request is made — an excessive and inefficient undertaking.

The stroke of genius here is using not one but two stacks. The secondary stack acts as a memory, holding the minimum value attained with each element pushed to the primary stack. This way, when the current minimum leaves the stack, the next one in line is right at the top of the auxiliary stack, ready to be the new champion.

It's time to manifest this brainchild into Java code. Here's the skeletal structure of our `MinStack`

, waiting to be imbued with functionality:

Java`1import java.util.Stack; 2 3public class MinStack { 4 private Stack<Integer> stack = new Stack<>(); 5 private Stack<Integer> minValues = new Stack<>(); 6 7 // The push method is where most of our logic resides. 8 public void push(int x) { 9 if (minValues.isEmpty() || x <= minValues.peek()) { 10 minValues.push(x); 11 } 12 stack.push(x); 13 } 14 15 // Each pop requires careful coordination between our two stacks. 16 public void pop() { 17 if (!stack.isEmpty() && stack.peek().equals(minValues.peek())) { 18 minValues.pop(); 19 } 20 if (!stack.isEmpty()) { 21 stack.pop(); 22 } 23 } 24 25 // The top method reveals the peak of our stack cable car. 26 public int top() { 27 return stack.isEmpty() ? -1 : stack.peek(); 28 } 29 30 // getMin serves as our on-demand minimum value provider. 31 public int getMin() { 32 return minValues.isEmpty() ? -1 : minValues.peek(); 33 } 34}`

The `push`

method introduces the key player — our `minValues`

stack, which retains the minimum value observed so far every time we add a new entry. Meanwhile, the `pop`

operation is like a relay race transition, handing off the title "minimum" to the next contender when the current titleholder is knocked off the podium.

Simulating the pushing of various elements onto the stack and invoking `getMin`

would yield the correct minimum every time, thanks to our additional stack, `minValues`

.

Our expedition through stack-land today has shown us that stacks can be the clever trick up your sleeve for certain types of interview questions. We have seen how to keep track of past element states with 'Preceding Smaller Elements' and maintain instant access to the minimum element in our 'MinStack'. From trails to inventory — stacks reveal their flexibility and efficiency. Thus, your toolbox of algorithms has just received a shiny new set of tools, bolstering your confidence for what lies ahead — practice!