Infix to Postfix Conversion Using Stack in DSA C++ - Time & Space Complexity

Time Complexity: Infix to Postfix Conversion Using Stack

O(n)

Understanding Time Complexity

We want to know how the time taken to convert an infix expression to postfix grows as the expression gets longer.

How does the number of steps change when the input expression size increases?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

string infixToPostfix(string infix) {
    stack<char> s;
    string postfix = "";
    for (char c : infix) {
        if (isalnum(c))
            postfix += c;
        else if (c == '(')
            s.push(c);
        else if (c == ')') {
            while (!s.empty() && s.top() != '(') {
                postfix += s.top();
                s.pop();
            }
            s.pop();
        } else {
            while (!s.empty() && precedence(s.top()) >= precedence(c)) {
                postfix += s.top();
                s.pop();
            }
            s.push(c);
        }
    }
    while (!s.empty()) {
        postfix += s.top();
        s.pop();
    }
    return postfix;
}
    

This code converts an infix expression (like "a+b*c") into postfix form (like "abc*+") using a stack to manage operators.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: One main loop that goes through each character of the input expression once.
• How many times: Exactly once for each character in the input (n times).
• Inside the loop, there can be smaller loops popping from the stack, but each operator is pushed and popped only once overall.

How Execution Grows With Input

As the input expression length (n) grows, the code processes each character once, plus some extra steps for operators pushed and popped from the stack.

Input Size (n)	Approx. Operations
10	About 10 main steps plus some stack operations (around 15 total)
100	About 100 main steps plus stack operations (around 150 total)
1000	About 1000 main steps plus stack operations (around 1500 total)

Pattern observation: The total steps grow roughly in a straight line with input size, meaning doubling input roughly doubles work.

Final Time Complexity

Time Complexity: O(n)

This means the time to convert grows linearly with the length of the input expression.

Common Mistake

[X] Wrong: "Because there is a nested loop popping from the stack, the time complexity is O(n²)."

[OK] Correct: Each operator is pushed and popped only once, so the inner popping loops do not multiply the total steps beyond linear growth.

Interview Connect

Understanding this linear time complexity helps you explain how efficient stack-based expression parsing is, a skill useful in many coding problems.

Self-Check

"What if the input expression included multi-digit numbers or variables with multiple characters? How would the time complexity change?"

Practice

1. What is the main purpose of using a stack in Infix to Postfix Conversion?

easy

A. To count the number of operators

B. To temporarily hold operators and manage their precedence

C. To reverse the order of the expression

D. To store operands permanently

Solution

1. Step 1: Understand the role of stack in conversion

   The stack is used to hold operators temporarily while processing the infix expression to respect operator precedence and associativity.

2. Step 2: Identify what is stored in the stack

   Operands are directly added to the output, while operators are pushed to the stack to manage order and precedence.

3. Final Answer:

   To temporarily hold operators and manage their precedence -> Option B

4. Quick Check:

   Stack holds operators = D [OK]

Hint: Stack holds operators to manage precedence [OK]

Common Mistakes:

• Thinking stack stores operands
• Believing stack reverses the entire expression
• Confusing stack role with counting operators

2. Which of the following is the correct syntax to push an operator onto a stack named st in C++?

easy

A. st.push(operator);

B. push(st, operator);

C. st.add(operator);

D. push.operator(st);

Solution

1. Step 1: Recall C++ stack push syntax

   In C++, the standard stack uses the member function push() to add elements.

2. Step 2: Match correct syntax

   The correct syntax is st.push(operator); where st is the stack object.

3. Final Answer:

   st.push(operator); -> Option A

4. Quick Check:

   Stack push method = st.push() [OK]

Hint: Use st.push(element) to add to stack [OK]

Common Mistakes:

• Using non-member functions like push(st, element)
• Using incorrect method names like add()
• Incorrect dot notation like push.operator()

3. What is the postfix expression for the infix expression A + B * C?

medium

A. A+BC*

B. AB+C*

C. ABC*+

D. *ABC+

Solution

1. Step 1: Apply operator precedence rules

   Multiplication (*) has higher precedence than addition (+), so B * C is evaluated first.

2. Step 2: Convert to postfix

   Postfix places operands first, then operator: B C * then A +, resulting in ABC*+.

3. Final Answer:

   ABC*+ -> Option C

4. Quick Check:

   Postfix of A + B * C = ABC*+ [OK]

Hint: Multiply before add, postfix: operands then operator [OK]

Common Mistakes:

• Ignoring operator precedence
• Placing operators before operands
• Confusing postfix with infix order

4. Given the following code snippet for infix to postfix conversion, what is the error?

std::stack<char> st;
std::string infix = "A+B*C";
std::string postfix = "";
for (char ch : infix) {
  if (isalnum(ch))
    postfix += ch;
  else {
    while (!st.empty() && st.top() >= ch) {
      postfix += st.top();
      st.pop();
    }
    st.push(ch);
  }
}
while (!st.empty()) {
  postfix += st.top();
  st.pop();
}

medium

A. Operator precedence comparison is incorrect

B. Operands are not added to postfix

C. Stack is not used for operators

D. Postfix string is not initialized

Solution

1. Step 1: Analyze operator precedence check

   The code compares operators using >= directly on characters, which does not correctly reflect operator precedence.

2. Step 2: Identify correct precedence handling

   Operator precedence should be checked using a function that assigns precedence values, not character comparison.

3. Final Answer:

   Operator precedence comparison is incorrect -> Option A

4. Quick Check:

   Operator precedence needs function, not char compare [OK]

Hint: Use precedence function, not char comparison [OK]

Common Mistakes:

• Comparing operators as characters
• Ignoring precedence rules
• Not popping stack correctly

5. Convert the infix expression (A+B)*(C-D)/E to postfix using stack. What is the correct postfix expression?

hard

A. AB+CD-E/*

B. AB+CD-E*/

C. AB+CD-*/E

D. AB+CD-*E/

Solution

1. Step 1: Handle parentheses and operator precedence

   Parentheses force A+B and C-D to be evaluated first, then multiply results, then divide by E.

2. Step 2: Convert step-by-step to postfix

   A B + (for A+B), C D - (for C-D), then multiply: AB+CD-*, finally divide by E: AB+CD-*E/.

3. Final Answer:

   AB+CD-*E/ -> Option D

4. Quick Check:

   Postfix of (A+B)*(C-D)/E = AB+CD-*E/ [OK]

Hint: Process parentheses first, then operators by precedence [OK]

Common Mistakes:

• Ignoring parentheses order
• Mixing operator order
• Placing division before multiplication