Evaluate Postfix Expression Using Stack in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Postfix Expression Evaluation

What is the output of the following C# code that evaluates a postfix expression using a stack?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static int EvaluatePostfix(string expr) {
        Stack<int> stack = new Stack<int>();
        foreach (char c in expr) {
            if (char.IsDigit(c)) {
                stack.Push(c - '0');
            } else {
                int val2 = stack.Pop();
                int val1 = stack.Pop();
                switch (c) {
                    case '+': stack.Push(val1 + val2); break;
                    case '-': stack.Push(val1 - val2); break;
                    case '*': stack.Push(val1 * val2); break;
                    case '/': stack.Push(val1 / val2); break;
                }
            }
        }
        return stack.Pop();
    }

    static void Main() {
        string postfix = "231*+9-";
        Console.WriteLine(EvaluatePostfix(postfix));
    }
}

A 8

B 7

C 2

D -4

💡 Hint

Trace the expression step by step: 2 3 1 * + 9 -

The postfix expression evaluates as follows: 3*1=3, then 2+3=5, then 5-9=-4.

❓ Predict Output

intermediate

Result of Postfix Expression with Division

What is the output of this C# code evaluating a postfix expression with division?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static int EvaluatePostfix(string expr) {
        Stack<int> stack = new Stack<int>();
        foreach (char c in expr) {
            if (char.IsDigit(c)) {
                stack.Push(c - '0');
            } else {
                int val2 = stack.Pop();
                int val1 = stack.Pop();
                switch (c) {
                    case '+': stack.Push(val1 + val2); break;
                    case '-': stack.Push(val1 - val2); break;
                    case '*': stack.Push(val1 * val2); break;
                    case '/': stack.Push(val1 / val2); break;
                }
            }
        }
        return stack.Pop();
    }

    static void Main() {
        string postfix = "82/3-";
        Console.WriteLine(EvaluatePostfix(postfix));
    }
}

A 1

B 3

C 0

D 2

💡 Hint

Remember integer division truncates towards zero.

The expression evaluates as 8/2=4, then 4-3=1. But integer division 8/2=4, so final result is 1.

🔧 Debug

advanced

Identify the Error in Postfix Evaluation Code

What error will this C# code produce when evaluating the postfix expression "1+"?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static int EvaluatePostfix(string expr) {
        Stack<int> stack = new Stack<int>();
        foreach (char c in expr) {
            if (char.IsDigit(c)) {
                stack.Push(c - '0');
            } else {
                int val2 = stack.Pop();
                int val1 = stack.Pop();
                switch (c) {
                    case '+': stack.Push(val1 + val2); break;
                    case '-': stack.Push(val1 - val2); break;
                    case '*': stack.Push(val1 * val2); break;
                    case '/': stack.Push(val1 / val2); break;
                }
            }
        }
        return stack.Pop();
    }

    static void Main() {
        string postfix = "1+";
        Console.WriteLine(EvaluatePostfix(postfix));
    }
}

A No error, output is 3

B DivideByZeroException

C InvalidOperationException due to popping from empty stack

D Compilation error due to missing semicolon

💡 Hint

Check the order of popping operands from the stack.

The code pops operands in wrong order: val1 = stack.Pop() then val2 = stack.Pop(). This reverses operand order causing wrong calculation or empty stack pop.

🧠 Conceptual

advanced

Stack Behavior in Postfix Evaluation

Which statement best describes the role of the stack in evaluating a postfix expression?

A The stack stores operands and intermediate results for operations

B The stack stores operators until operands are found

C The stack stores the entire expression as a string

D The stack is used to reverse the postfix expression before evaluation

💡 Hint

Think about what you push and pop during evaluation.

In postfix evaluation, operands are pushed onto the stack. When an operator is encountered, operands are popped, operation done, and result pushed back. So stack holds operands and intermediate results.

❓ Predict Output

expert

Output of Complex Postfix Expression Evaluation

What is the output of this C# code evaluating the postfix expression "345+*62/-"?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static int EvaluatePostfix(string expr) {
        Stack<int> stack = new Stack<int>();
        foreach (char c in expr) {
            if (char.IsDigit(c)) {
                stack.Push(c - '0');
            } else {
                int val2 = stack.Pop();
                int val1 = stack.Pop();
                switch (c) {
                    case '+': stack.Push(val1 + val2); break;
                    case '-': stack.Push(val1 - val2); break;
                    case '*': stack.Push(val1 * val2); break;
                    case '/': stack.Push(val1 / val2); break;
                }
            }
        }
        return stack.Pop();
    }

    static void Main() {
        string postfix = "345+*62/-";
        Console.WriteLine(EvaluatePostfix(postfix));
    }
}

A 12

B 24

C 3

D 9

💡 Hint

Evaluate stepwise: 3 (4+5) * then 6 2 / -

Stepwise evaluation: 4+5=9, then 3*9=27, then 6/2=3, then 27-3=24.

Practice

1. What is the main data structure used to evaluate a postfix expression?

easy

A. Array

B. Queue

C. Stack

D. Linked List

Solution

1. Step 1: Understand postfix evaluation process

   Postfix expressions are evaluated by pushing operands onto a stack and popping them when an operator is encountered. The stack allows last-in, first-out access which is perfect for postfix evaluation.

2. Final Answer:

   Stack -> Option C

3. Quick Check:

   Postfix evaluation uses stack [OK]

Hint: Postfix needs last-in-first-out structure: stack [OK]

Common Mistakes:

• Confusing stack with queue
• Using array without stack logic
• Thinking linked list is primary structure

2. Which of the following C# code snippets correctly pushes an integer operand onto a stack named stack?

easy

A. stack.Push(operand);

B. stack.Add(operand);

C. stack.Insert(operand);

D. stack.Enqueue(operand);

Solution

1. Step 1: Recall C# Stack.Push method

   In C#, the method to add an element to a stack is Push. Enqueue is for queues; Add and Insert are not stack methods.

2. Final Answer:

   stack.Push(operand); -> Option A

3. Quick Check:

   Use Push() to add to stack [OK]

Hint: Use Push() to add items to stack in C# [OK]

Common Mistakes:

• Using Enqueue which is for queues
• Using Add or Insert which are not stack methods
• Confusing stack with list methods

3. What is the output of the following C# code that evaluates the postfix expression "23+5*"?

string expr = "23+5*";
Stack<int> stack = new Stack<int>();
foreach (char c in expr)
{
    if (char.IsDigit(c))
        stack.Push(c - '0');
    else
    {
        int b = stack.Pop();
        int a = stack.Pop();
        if (c == '+') stack.Push(a + b);
        else if (c == '*') stack.Push(a * b);
    }
}
Console.WriteLine(stack.Pop());

medium

A. 25

B. 15

C. 10

D. Error

Solution

1. Step 1: Trace code execution

   Push 2, push 3; '+' pops b=3, a=2, push 5. Push 5; '*' pops b=5, a=5, push 25. Final pop prints 25.

2. Final Answer:

   25 -> Option A

3. Quick Check:

   (2+3)*5 = 25 [OK]

Hint: Calculate stepwise: operands pushed, operators pop two values [OK]

Common Mistakes:

• Mixing operand order when popping
• Confusing '+' and '*' operations
• Forgetting to convert char digits to int

4. Identify the error in the following C# code snippet that evaluates a postfix expression:

string expr = "82/";
Stack<int> stack = new Stack<int>();
foreach (char c in expr)
{
    if (char.IsDigit(c))
        stack.Push(c - '0');
    else
    {
        int a = stack.Pop();
        int b = stack.Pop();
        if (c == '/') stack.Push(b / a);
    }
}
Console.WriteLine(stack.Pop());

medium

A. Stack is not initialized

B. Operands are popped in wrong order

C. Division operator is not handled

D. Digits are not converted to integers

Solution

1. Step 1: Trace popping and computation for division

   Push 8, push 2 (top=2). For '/', b=Pop()=2 (right), a=Pop()=8 (left), but pushes b/a=2/8=0 instead of a/b=8/2=4. Operands popped correctly but used/applied in wrong order for non-commutative division.

2. Final Answer:

   Operands are popped in wrong order -> Option B

3. Quick Check:

   Pop right first (b), left second (a), compute a / b [OK]

Hint: Pop second operand first, then first operand for correct order [OK]

Common Mistakes:

• Swapping operand order causing wrong division
• Not handling division operator
• Forgetting to convert char to int

5. Given the postfix expression "6523+8*+3+*", what is the final result after evaluation using a stack?

hard

A. 2880

B. Incorrect expression

C. None (runtime error)

D. 288

Solution

1. Step 1: Evaluate postfix step-by-step

   Push 6,5,2,3; '+' pops 3&2 push 5 (stack:6,5,5); push 8; '*' pops 8&5 push 40 (6,5,40); '+' pops 40&5 push 45 (6,45); push 3 (6,45,3); '+' pops 3&45 push 48 (6,48); '*' pops 48&6 push 288.

2. Final Answer:

   288 -> Option D

3. Quick Check:

   Stepwise postfix evaluation = 288 [OK]

Hint: Evaluate postfix stepwise, push operands, apply operators [OK]

Common Mistakes:

• Misordering operands during pop
• Skipping steps in complex expressions
• Confusing operator precedence in postfix