Stack Questions at Morgan Stanley: What to Expect

Stack questions appear in 7 of Morgan Stanley's 53 tagged problems, making them a consistent and significant part of their technical interview process. For a firm where system reliability, real-time data processing, and managing complex transaction flows are paramount, the stack's core properties—Last-In, First-Out (LIFO) order, efficient O(1) insertion/removal, and its role in managing state—are directly applicable. Interviewers use these problems to assess a candidate's fundamental understanding of data structures, their ability to manage nested structures or undo operations, and their skill in writing clean, bug-free code under pressure. Mastering stacks is non-negotiable for passing the technical screen.

What to Expect — Types of Problems

Morgan Stanley's stack problems typically fall into a few key categories that test both basic comprehension and applied problem-solving.

• Syntax & Validation Parsing: This is the most classic application. Expect questions like validating parentheses, brackets, and braces (()[]{}) in strings, which mirrors parsing financial data formats or code. You may also see problems involving HTML/XML tag validation or evaluating arithmetic expressions (e.g., Reverse Polish Notation).
• State Tracking & History: Problems where you need to track a previous state, often for an "undo" or "next greater element" operation. The "Min Stack" problem, where you must support push, pop, top, and retrieving the minimum element all in O(1) time, is a prime example and a known favorite.
• Algorithmic Building Blocks: Stacks are often a key component in more complex algorithms you might encounter. This includes Depth-First Search (DFS) traversals on trees or graphs, stock span problems, or finding the largest rectangle in a histogram. While the overall algorithm might be advanced, the stack portion tests your ability to use the structure efficiently within a broader context.

The problems will often be framed in a way that feels relevant to financial systems, such as processing a sequence of transactions or validating a stream of data.

How to Prepare — Study Tips with One Code Example

First, ensure you can implement a stack from scratch using a list or dynamic array and explain its operations and time complexities. Then, focus on pattern recognition.

The universal pattern for stack problems is: Iterate through your input (e.g., a string, array, or list). For each element, decide if it "opens" a new context (push it) or "closes" a previous one (pop and check for a match). The stack maintains the active or pending contexts.

Consider the classic Valid Parentheses problem. The pattern is clear: opening symbols push, closing symbols must match the top of the stack.

def isValid(s: str) -> bool:
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}

    for char in s:
        if char in mapping:  # It's a closing bracket
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:  # It's an opening bracket
            stack.append(char)
    return not stack  # Stack must be empty at the end

Recommended Practice Order

Build competence progressively:

1. Fundamentals: Implement a stack, then solve Valid Parentheses and Min Stack.
2. Core Patterns: Practice Daily Temperatures (next greater element pattern) and Evaluate Reverse Polish Notation.
3. Advanced Integration: Tackle problems where the stack is a component, like Binary Tree Inorder Traversal (iterative, using a stack) or Largest Rectangle in Histogram.
4. Morgan Stanley Specific: Finally, solve all 7 stack-tagged problems on the platform to familiarize yourself with their exact phrasing and difficulty.

Practice Stack at Morgan Stanley