Stack — NCERT Solutions

Given: Postfix expression: $AB+C*$, where A=3, B=5, C=1

Concept for Postfix Evaluation using Stack:

• Scan expression left to right.
• If the token is an operand → PUSH onto stack.
• If the token is an operator → POP two operands (first pop = operand2, second pop = operand1), apply the operator: result = operand1 op operand2, then PUSH result back.
• Final value remaining in stack is the answer.

Step-by-step evaluation:

Final Result: The value remaining in the stack = $\boxed{8}$

Verification: $AB+C* = (A+B)*C = (3+5)*1 = 8*1 = 8$ ✓

Given: Postfix expression: $AB*C/D*$, where A=3, B=5, C=1, D=4

Concept: Same as above — scan left to right; PUSH operands, on operator POP two operands, compute, PUSH result.

Step-by-step evaluation:

Final Result: The value remaining in the stack = $\boxed{60}$

Verification: $AB*C/D* = ((A*B)/C)*D = ((3*5)/1)*4 = (15/1)*4 = 15*4 = 60$ ✓

Given: Infix expression: $A + B - C * D$

Concept — Infix to Postfix conversion rules:

• Scan left to right.
• If token is an operand → append directly to output string.
• If token is an operator:
• While stack is not empty AND top of stack has greater or equal precedence than current operator → POP and append to output.
• PUSH current operator onto stack.
• If token is ( → PUSH onto stack.
• If token is ) → POP and append until ( is found; discard (.
• At end → POP all remaining operators from stack to output.

Precedence: * and / have higher precedence (2) than + and - (1).

Step-by-step conversion:

Postfix Expression: $\boxed{AB+CD*-}$

Verification: $A+B-C*D$ → Postfix: $AB+CD*-$ ✓

Given: Infix expression: $A * ((C + D)/E)$

Concept: Same rules as above. ( is pushed onto stack; on encountering ), pop until matching ( is found.

Step-by-step conversion:

Postfix Expression: $\boxed{ACD+E/*}$

Verification: $A*((C+D)/E)$ → Postfix: $ACD+E/*$ ✓

Concept:

• Use a Python list as a stack.
• Accept numbers from the user; push only odd numbers onto the stack.
• To find the largest: pop elements one by one, compare each with a variable largest, update if current element is greater.
• Since popping empties the stack, store elements in a temporary list to display stack contents.

Python Program:

# Program to store odd numbers in a Stack and find the largest

# Step 1: Create an empty stack
oddStack = []

# Step 2: Accept numbers from user
n = int(input("How many numbers do you want to enter? "))
for i in range(n):
    num = int(input("Enter number: "))
    if num % 2 != 0:          # Check if number is odd
        oddStack.append(num)  # PUSH odd number onto stack

# Step 3: Display the stack contents
if len(oddStack) == 0:
    print("No odd numbers were entered. Stack is empty.")
else:
    print("\nStack contents (bottom to top):", oddStack)

    # Step 4: Find the largest odd number using stack
    # Use a temporary copy to preserve stack for display
    tempStack = oddStack.copy()
    largest = tempStack.pop()   # POP first element as initial largest

    while len(tempStack) != 0:
        top = tempStack.pop()   # POP next element
        if top > largest:
            largest = top       # Update largest if needed

    print("Largest odd number in the Stack:", largest)

Sample Output:

How many numbers do you want to enter? 6
Enter number: 4
Enter number: 7
Enter number: 12
Enter number: 9
Enter number: 3
Enter number: 15

Stack contents (bottom to top): [7, 9, 3, 15]
Largest odd number in the Stack: 15

Explanation:

• Numbers 4 and 12 are even, so they are not pushed.
• Odd numbers 7, 9, 3, 15 are pushed onto the stack.
• A copy of the stack is used to find the largest by popping elements one by one.
• The largest element found is 15.