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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this postfix evaluation code?

Consider the postfix expression "231*+9-". What will be the final result after evaluating it using a stack?

DSA Javascript

function evaluatePostfix(expression) {
  const stack = [];
  for (const char of expression) {
    if (!isNaN(char)) {
      stack.push(Number(char));
    } else {
      const b = stack.pop();
      const a = stack.pop();
      switch (char) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(a - b); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(Math.floor(a / b)); break;
      }
    }
  }
  return stack.pop();
}

console.log(evaluatePostfix("231*+9-"));

A −3

B −2

C −4

D 4

💡 Hint

Remember to process the expression left to right, pushing numbers and applying operators to the top two stack values.

The postfix expression is evaluated step-by-step: push 2, push 3, push 1, multiply top two (3*1=3), stack now [2,3], add top two (2+3=5), stack now [5], push 9, subtract top two (5-9=-4), final result is -4.

🧠 Conceptual

intermediate

How many items remain in the stack after processing the postfix expression "82/3-"?

Given the postfix expression "82/3-", how many items are left in the stack after fully evaluating it?

A 1

B 0

C 2

D 3

💡 Hint

The stack should have exactly one item after complete evaluation of a valid postfix expression.

After evaluating the expression, all operations reduce the stack until only one final result remains.

❓ Predict Output

advanced

What is the output of this postfix evaluation code?

What will this code produce when evaluating the postfix expression "34+5*6"?

DSA Javascript

function evaluatePostfix(expression) {
  const stack = [];
  for (const char of expression) {
    if (!isNaN(char)) {
      stack.push(Number(char));
    } else {
      const b = stack.pop();
      const a = stack.pop();
      switch (char) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(a - b); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(Math.floor(a / b)); break;
      }
    }
  }
  return stack.pop();
}

console.log(evaluatePostfix("34+5*6"));

A TypeError: Cannot read property 'pop' of undefined

B No error, outputs 6

C TypeError: Cannot read property 'pop' of null

D TypeError: Cannot read property 'pop' of undefined (when stack is empty)

💡 Hint

Simulate the stack step-by-step. The code does not validate if the expression is correct; it just processes each character.

The expression "34+5*6" is not a fully valid postfix expression (should reduce to one value), but the code runs without error: push 3, push 4, + → [7]; push 5, * → [35]; push 6 → [35,6]; pop returns 6.

🚀 Application

advanced

Which postfix expression evaluates to 15 using the stack evaluation method?

Select the postfix expression that evaluates to 15 when processed by a stack-based postfix evaluator.

A "54+6+"

B "75+3*"

C "93+"

D "82/3+"

💡 Hint

Evaluate each expression step-by-step or mentally simulate the stack operations.

A: "93+" → 9+3=12 B: "75+3*" → (7+5)*3=36 C: "54+6+" → (5+4)+6=15 D: "82/3+" → (8/2)+3=7 (using floor division) Only C evaluates to 15.

🧠 Conceptual

expert

What is the time complexity of evaluating a postfix expression of length n using a stack?

Given a postfix expression with n characters, what is the time complexity of evaluating it using a stack-based algorithm?

A O(n log n)

B O(log n)

C O(n^2)

D O(n)

💡 Hint

Each character is processed once with constant time stack operations.

Each character in the postfix expression is processed exactly once, and stack operations (push/pop) take constant time, so total time is linear in n.

Practice

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

easy

A. Linked List

B. Queue

C. Stack

D. Array

Solution

1. Step 1: Understand postfix evaluation process

   Postfix expressions are evaluated using a stack to hold operands until an operator is encountered.

2. Step 2: Identify the correct data structure

   The stack allows pushing operands and popping them for operations, which fits postfix evaluation perfectly.

3. Final Answer:

   Stack -> Option C

4. Quick Check:

   Postfix evaluation uses stack = Stack [OK]

Hint: Postfix uses stack to hold operands until operators appear [OK]

Common Mistakes:

• Choosing queue instead of stack
• Using array without stack operations
• Confusing with infix evaluation

2. Which of the following is the correct way to push an element onto a stack in JavaScript?

easy

A. stack.push(element);

B. stack.add(element);

C. stack.insert(element);

D. stack.enqueue(element);

Solution

1. Step 1: Recall JavaScript stack operations

   JavaScript arrays use push() to add elements to the end, simulating stack push.

2. Step 2: Match correct method

   push() is the standard method; add(), insert(), enqueue() are incorrect for stack push.

3. Final Answer:

   stack.push(element); -> Option A

4. Quick Check:

   Push uses push() method = stack.push(element); [OK]

Hint: Use push() to add elements to stack in JavaScript [OK]

Common Mistakes:

• Using add() or insert() which don't exist
• Confusing enqueue() with queue operation
• Using pop() instead of push()

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

function evaluatePostfix(expr) {
  const stack = [];
  for (const ch of expr) {
    if (!isNaN(ch)) {
      stack.push(Number(ch));
    } else {
      const b = stack.pop();
      const a = stack.pop();
      if (ch === '+') stack.push(a + b);
      else if (ch === '*') stack.push(a * b);
    }
  }
  return stack.pop();
}
console.log(evaluatePostfix("23+5*"));

medium

A. 25

B. 15

C. 10

D. Error

Solution

1. Step 1: Evaluate postfix expression "23+5*" step-by-step

   Push 2, push 3, then '+' operator: pop 3 and 2, add = 5, push 5. Push 5, then '*' operator: pop 5 and 5, multiply = 25, push 25.

2. Step 2: Final stack value

   Only one value 25 remains, which is returned and printed.

3. Final Answer:

   25 -> Option A

4. Quick Check:

   2+3=5, 5*5=25 = 25 [OK]

Hint: Calculate stepwise: operands pushed, operators pop two and push result [OK]

Common Mistakes:

• Mixing operand order in subtraction/division
• Forgetting to convert char to number
• Confusing operator precedence

4. Identify the error in the following postfix evaluation code snippet:

function evalPostfix(expr) {
  const stack = [];
  for (const ch of expr) {
    if (ch >= '0' && ch <= '9') {
      stack.push(ch);
    } else {
      const b = stack.pop();
      const a = stack.pop();
      if (ch === '+') stack.push(a + b);
      else if (ch === '-') stack.push(a - b);
    }
  }
  return stack.pop();
}

medium

A. Stack pop order is reversed

B. Operands are pushed as strings, not numbers

C. Missing handling for multiplication operator

D. Loop does not iterate over expression

Solution

1. Step 1: Check how operands are pushed

   The code pushes characters directly without converting to numbers, so operands are strings.

2. Step 2: Effect of pushing strings on arithmetic

   Adding strings with '+' concatenates instead of numeric addition, causing wrong results.

3. Final Answer:

   Operands are pushed as strings, not numbers -> Option B

4. Quick Check:

   Push operands as numbers, not strings = Operands are pushed as strings, not numbers [OK]

Hint: Convert chars to numbers before pushing to stack [OK]

Common Mistakes:

• Pushing chars without Number()
• Ignoring operator cases
• Assuming pop order is wrong

5. Given the postfix expression "82/3-4*", what is the correct evaluation result using a stack-based approach?

hard

A. 6

B. 0

C. 8

D. 4

Solution

1. Step 1: Evaluate "82/3-4*" step-by-step

   Push 8, push 2, '/' operator: 8 / 2 = 4, push 4. Push 3, '-' operator: 4 - 3 = 1, push 1. Push 4, '*' operator: 1 * 4 = 4, push 4.

2. Step 2: Final stack value

   Only one value 4 remains, but check carefully: The last '*' uses 1 and 4, result 4.

3. Step 3: Re-check calculation

   Actually, after '-' operation, stack has 1. Then push 4, then '*': 1 * 4 = 4.

4. Final Answer:

   4 -> Option D

5. Quick Check:

   8/2=4, 4-3=1, 1*4=4 = 4 [OK]

Hint: Evaluate stepwise: divide, subtract, then multiply [OK]

Common Mistakes:

• Mixing operand order in division
• Skipping operator precedence
• Incorrect stack pop sequence