Symbol Table Implementation - Problem

Implement a symbol table that supports nested scopes using a Binary Search Tree (BST). Your symbol table should support the following operations:

Operations:

enterScope() - Enter a new scope
exitScope() - Exit the current scope
declare(name, value) - Declare a variable in the current scope
lookup(name) - Find the value of a variable (searches current scope, then parent scopes)

Each scope maintains its own BST for fast variable lookups. When looking up a variable, search the current scope first, then parent scopes in order until found.

Input: A sequence of operations as an array of arrays. Each operation is ["operation_name", ...args]

Output: An array containing the results of all lookup operations (null for other operations)

Input & Output

Example 1 — Basic Scope Operations

$ Input: operations = [["enterScope"], ["declare", "x", 10], ["lookup", "x"], ["enterScope"], ["declare", "x", 20], ["lookup", "x"], ["exitScope"], ["lookup", "x"]]

› Output: [null, null, 10, null, null, 20, null, 10]

💡 Note: Enter scope, declare x=10, lookup returns 10. Enter nested scope, declare x=20 (shadows parent), lookup returns 20. Exit scope, lookup finds parent x=10.

Example 2 — Variable Shadowing

$ Input: operations = [["declare", "y", 5], ["enterScope"], ["declare", "y", 15], ["lookup", "y"], ["exitScope"], ["lookup", "y"]]

› Output: [null, null, null, 15, null, 5]

💡 Note: Declare y=5 globally, enter scope, declare y=15 (shadows global), lookup finds 15. Exit scope, lookup finds original y=5.

Example 3 — Missing Variable

$ Input: operations = [["enterScope"], ["declare", "a", 1], ["lookup", "b"]]

› Output: [null, null, null]

💡 Note: Enter scope, declare variable 'a', but lookup for 'b' returns null since 'b' doesn't exist in any scope.

Constraints

1 ≤ operations.length ≤ 10⁴
Variable names are non-empty strings with lowercase letters only
-10⁶ ≤ variable values ≤ 10⁶
Lookup operations will only occur when at least one scope exists
ExitScope operations will not make scopes empty (global scope always remains)

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 10 f Meta 8

The key insight is using a Binary Search Tree for each scope to achieve O(log n) lookups while maintaining a stack of scopes for proper variable shadowing. The optimal approach creates a BST per scope and searches from current scope up to parent scopes. Time: O(log n × d), Space: O(n × d).

Common Approaches

✓ BST in Each Scope

⏱️ Time: O(log n × d) Space: O(n × d)

Implement each scope as a Binary Search Tree where variables are stored by name alphabetically. For lookup operations, search the BST of current scope in O(log n), then move to parent scope BST if not found.

Linear Search in Each Scope

⏱️ Time: O(n×d) Space: O(n×d)

Maintain each scope as an array of (name, value) pairs. For lookup, iterate through current scope array linearly, then move to parent scope and repeat until variable is found or no more parent scopes exist.

BST in Each Scope — Algorithm Steps

Create BST for each scope with variables sorted by name
For lookup: search current scope BST in O(log n)
If not found, move to parent scope BST
Continue until found or no parent scopes exist

Visualization

Tap to expand

Step-by-Step Walkthrough

BST Search

Search current scope BST in O(log n)

Parent BST

Move to parent scope BST if not found

Found

Return value from appropriate scope

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    printf("[null,null,null,10,null,20,null,null,10]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n × d)

BST search takes O(log n) across d scope levels

✓ Linear Growth

Space Complexity

O(n × d)

BST nodes store n variables across d nested scopes

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Symbol Table Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BST in Each Scope — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler