Expression Evaluator - Problem

Write a function to evaluate a mathematical expression string containing the operators +, -, *, / and parentheses () using two stacks - one for operators and one for operands.

The expression will always be valid and contain only integers, the four basic arithmetic operators, and parentheses. Division should return integer results (truncate towards zero).

Examples:

"2+3*4" should return 14 (not 20, due to operator precedence)
"(2+3)*4" should return 20
"10-2*3" should return 4

Input & Output

Example 1 — Basic Expression with Precedence

$ Input: expression = "2+3*4"

› Output: 14

💡 Note: Multiplication has higher precedence: 3*4 = 12, then 2+12 = 14 (not 20)

Example 2 — Parentheses Override Precedence

$ Input: expression = "(2+3)*4"

› Output: 20

💡 Note: Parentheses first: (2+3) = 5, then 5*4 = 20

Example 3 — Complex Expression

$ Input: expression = "10-2*3"

› Output: 4

💡 Note: Multiplication first: 2*3 = 6, then 10-6 = 4

Constraints

1 ≤ expression.length ≤ 3 × 10⁵
expression consists of integers and operators (+, -, *, /, (, ))
All intermediate calculations fit within 32-bit integers
Division is integer division (truncate towards zero)

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 🍎 Apple 25

The key insight is using two stacks to naturally handle operator precedence and parentheses. The optimal approach uses an operand stack and operator stack, processing the expression left-to-right while comparing precedence to decide when to push or pop operators. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Recursive Parsing

⏱️ Time: O(n²) Space: O(n²)

Parse the expression character by character and recursively evaluate sub-expressions. This approach tries to handle parentheses but doesn't properly implement operator precedence, leading to incorrect results for complex expressions.

Two Stacks with Proper Precedence

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

Maintain two stacks - one for operands and one for operators. Process the expression left-to-right, pushing operands to operand stack. For operators, compare precedence with top of operator stack and pop/calculate when necessary.

Brute Force Recursive Parsing — Algorithm Steps

Parse expression character by character
Recursively evaluate parentheses
Apply operations left-to-right without precedence

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Left-to-Right

Process operators as encountered

Ignore Precedence

Apply operations immediately

Wrong Result

Incorrect due to precedence violation

Code -

solution.c — C

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

int evaluateSimple(char* expr) {
    int result = 0;
    char currentNum[20] = "";
    int numIdx = 0;
    char op = '+';
    int len = strlen(expr);
    
    for (int i = 0; i <= len; i++) {
        char c = (i < len) ? expr[i] : '+';
        if (isdigit(c)) {
            currentNum[numIdx++] = c;
            currentNum[numIdx] = '\0';
        } else {
            int num = (numIdx > 0) ? atoi(currentNum) : 0;
            switch (op) {
                case '+': result += num; break;
                case '-': result -= num; break;
                case '*': result *= num; break;
                case '/': if (num != 0) result /= num; break;
            }
            memset(currentNum, 0, sizeof(currentNum));
            numIdx = 0;
            op = c;
        }
    }
    return result;
}

int solution(char* expression) {
    int len = strlen(expression);
    while (strchr(expression, '(') != NULL) {
        int start = -1;
        for (int i = 0; i < len; i++) {
            if (expression[i] == '(') {
                start = i;
            } else if (expression[i] == ')') {
                char inner[100];
                strncpy(inner, expression + start + 1, i - start - 1);
                inner[i - start - 1] = '\0';
                int value = evaluateSimple(inner);
                
                char temp[200];
                strncpy(temp, expression, start);
                temp[start] = '\0';
                sprintf(temp + start, "%d%s", value, expression + i + 1);
                strcpy(expression, temp);
                len = strlen(expression);
                break;
            }
        }
    }
    return evaluateSimple(expression);
}

int main() {
    char expression[200];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    int result = solution(expression);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple recursive calls and string manipulations for each character

⚠ Quadratic Growth

Space Complexity

O(n²)

Deep recursion stack and multiple substring creations

⚠ Quadratic Space

34.2K Views

High Frequency

~25 min Avg. Time

856 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

Expression Evaluator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursive Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler