Evaluate Postfix Expression Using Stack in DSA Javascript - Build from Scratch

Evaluate Postfix Expression Using Stack

📖 Scenario: You are building a simple calculator that reads a postfix expression (also called Reverse Polish Notation) and calculates the result. Postfix expressions are used in calculators and computer science to avoid parentheses and operator precedence confusion.For example, the postfix expression 23+ means 2 + 3, and 52- means 5 - 2.

🎯 Goal: Build a program that uses a stack to evaluate a postfix expression given as a string. You will push numbers on the stack and pop them when you see an operator, then push the result back.

📋 What You'll Learn

Create a stack as an empty array called stack

Create a string variable called expression with the exact value '231*+9-'

Use a for loop with variable char to iterate over expression

Use if to check if char is a digit and push it as a number to stack

Use else to handle operators +, -, *, and /

Pop two numbers from stack, apply the operator, and push the result back

Print the final result which is the only number left in stack

💡 Why This Matters

🌍 Real World

Postfix expressions are used in calculators and computer programs to simplify expression evaluation without worrying about parentheses or operator precedence.

💼 Career

Understanding stack-based expression evaluation is important for software developers working on compilers, interpreters, calculators, and expression parsers.

1

Create the stack and postfix expression

Create an empty array called stack to use as the stack. Create a string variable called expression and set it to the exact value '231*+9-'.

DSA Javascript

# Create an empty array called stack
# Create a string variable called expression with value '231*+9-'

Hint

Use [] to create an empty array for the stack. Assign the string '231*+9-' exactly to expression.

2

Set up the loop to read each character

Use a for loop with variable char to iterate over each character in the string expression.

DSA Javascript

const stack = [];
const expression = '231*+9-';

// Use a for loop with char to iterate over expression

Hint

Use for (const char of expression) to get each character one by one.

3

Implement the core logic to evaluate postfix

Inside the loop, use if to check if char is a digit using !isNaN(char). If yes, push Number(char) to stack. Otherwise, use else to pop two numbers from stack, apply the operator char on them, and push the result back to stack. Handle operators +, -, *, and /.

DSA Javascript

const stack = [];
const expression = '231*+9-';

for (const char of expression) {
    // Check if char is digit and push to stack
    // Else pop two numbers, apply operator, push result
}

Hint

Use !isNaN(char) to check if char is a number. Use stack.pop() twice to get the last two numbers. Apply the operator and push the result back.

4

Print the final result

After the loop, print the only number left in stack using console.log(stack[0]).

DSA Javascript

const stack = [];
const expression = '231*+9-';

for (const char of expression) {
    if (!isNaN(char)) {
        stack.push(Number(char));
    } else {
        const b = stack.pop();
        const a = stack.pop();
        let result;
        if (char === '+') {
            result = a + b;
        } else if (char === '-') {
            result = a - b;
        } else if (char === '*') {
            result = a * b;
        } else if (char === '/') {
            result = a / b;
        }
        stack.push(result);
    }
}

// Print the final result

Hint

The final result is the only number left in the stack. Use console.log(stack[0]) to print it.

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