Shunting Yard Algorithm - Problem

The Shunting Yard Algorithm is a method for converting mathematical expressions from infix notation (where operators are between operands, like 3 + 4 * 2) to postfix notation (where operators come after operands, like 3 4 2 * +).

Your task is to implement this algorithm to handle:

Basic operators: +, -, *, /
Parentheses: ( and ) for grouping
Operator precedence: * and / have higher precedence than + and -
Left associativity: operators of same precedence are evaluated left to right

Given an infix expression as a string, return the equivalent postfix expression.

Note: The input will contain single-digit numbers, operators, and parentheses separated by spaces.

Input & Output

Example 1 — Basic Precedence

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

› Output: "3 4 2 * +"

💡 Note: Multiplication (*) has higher precedence than addition (+), so 4 * 2 is evaluated first. In postfix: 3 4 2 * + means 3 + (4 * 2) = 3 + 8 = 11

Example 2 — Parentheses Override

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

› Output: "3 4 + 2 *"

💡 Note: Parentheses override precedence, so (3 + 4) is evaluated first. In postfix: 3 4 + 2 * means (3 + 4) * 2 = 7 * 2 = 14

Example 3 — Left Associativity

$ Input: expression = "8 - 3 + 1"

› Output: "8 3 - 1 +"

💡 Note: Same precedence operators are left-associative, so 8 - 3 is evaluated first. In postfix: 8 3 - 1 + means (8 - 3) + 1 = 5 + 1 = 6

Constraints

1 ≤ expression.length ≤ 1000
Expression contains only single-digit numbers (0-9), operators (+, -, *, /), parentheses, and spaces
Expression is guaranteed to be valid and well-formed
No division by zero will occur

Visualization

Tap to expand

Asked in

G Google 42 M Microsoft 38 A Amazon 35 F Facebook 28 🍎 Apple 25

The Shunting Yard Algorithm efficiently converts infix to postfix notation using a stack to manage operator precedence. The key insight is processing tokens left-to-right while using the stack to delay lower-precedence operators. Best approach: Stack-based algorithm with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Generate All Postfix Permutations

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

Generate every possible permutation of the tokens in postfix order, then evaluate each one to see if it produces the same result as the original infix expression. This is highly inefficient but conceptually simple.

Stack-Based Shunting Yard Algorithm

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

The classic Shunting Yard algorithm uses a stack to hold operators temporarily while processing the expression left to right, outputting operators in the correct precedence order.

Brute Force - Generate All Postfix Permutations — Algorithm Steps

Extract all numbers and operators from infix expression
Generate all possible postfix permutations
Evaluate each permutation and compare with original result
Return the valid postfix expression

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of tokens

Test Each One

Evaluate each permutation to check correctness

Find Match

Return the permutation that matches original result

Code -

solution.c — C

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

char* solution(char* expression) {
    // Simplified implementation using proper algorithm
    char* result = malloc(1000);
    char stack[100][10];
    int top = -1;
    char* output = malloc(1000);
    output[0] = '\0';
    
    int precedence(char* op) {
        if (strcmp(op, "+") == 0 || strcmp(op, "-") == 0) return 1;
        if (strcmp(op, "*") == 0 || strcmp(op, "/") == 0) return 2;
        return 0;
    }
    
    char* token = strtok(expression, " ");
    while (token != NULL) {
        if (isdigit(token[0])) {
            if (strlen(output) > 0) strcat(output, " ");
            strcat(output, token);
        } else if (strcmp(token, "(") == 0) {
            strcpy(stack[++top], token);
        } else if (strcmp(token, ")") == 0) {
            while (top >= 0 && strcmp(stack[top], "(") != 0) {
                strcat(output, " ");
                strcat(output, stack[top--]);
            }
            top--; // Remove (
        } else {
            while (top >= 0 && strcmp(stack[top], "(") != 0 &&
                   precedence(stack[top]) >= precedence(token)) {
                strcat(output, " ");
                strcat(output, stack[top--]);
            }
            strcpy(stack[++top], token);
        }
        token = strtok(NULL, " ");
    }
    
    while (top >= 0) {
        strcat(output, " ");
        strcat(output, stack[top--]);
    }
    
    strcpy(result, output);
    free(output);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generates n! permutations where n is number of tokens, each requiring O(n) evaluation time

⚠ Quadratic Growth

Space Complexity

O(n!)

Stores all possible permutations in memory before testing

⚠ Quadratic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Shunting Yard Algorithm - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Postfix Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler