NCERT Solutions Class 12 Computer Science Chapter 3 Stack

The NCERT Solutions for Class 12 Computer Science Chapter 3 Stack cover all 7 exercise questions, according to the latest 2026-27 CBSE syllabus. Every answer follows the textbook's own flow: the LIFO rule of a stack, PUSH and POP with Python lists, and how a stack reverses strings, matches parentheses, and evaluates and converts arithmetic expressions.

• All 7 NCERT questions solved with Python code, dry-run traces, and an Expert Solution per question that adds exam strategy and common-trap warnings.
• Full coverage of LIFO, overflow and underflow, infix to postfix conversion, postfix evaluation, and parenthesis matching that the CBSE board paper tests directly.
• Answers aligned with the 2026-27 CBSE Class 12 Computer Science syllabus and useful for JEE and CUET data-structure questions; no NEET references because Computer Science is not a medical subject.

Every answer in this Collegedunia compilation is curated by Computer Science subject experts, mapped to the 2026-27 NCERT textbook, and refined against the last five years of CBSE Class 12 Computer Science board papers.

What the NCERT Solutions for Class 12 Computer Science Chapter 3 Stack Cover

This chapter answers one question: what is a stack, and how do you use it to solve real problems? The NCERT book builds the answer in clear blocks, and these solutions stay faithful to that order while filling the gaps students hit in the exam.

• Stack basics and the LIFO rule: a stack is a linear structure where you PUSH and POP only at the top, so the last item in is the first item out.
• Overflow and underflow: PUSH on a full stack causes overflow; POP on an empty stack causes underflow. These two words are the most common 1-mark trap.
• Stack with Python lists: append() is PUSH and pop() is POP, so a list is a ready-made stack.
• Applications: reversing a string, matching parentheses, infix to postfix conversion, and postfix evaluation, all worked with step-by-step stack traces.

Exercise-wise Breakdown of the Stack Chapter NCERT Solutions

Chapter 3 of NCERT Class 12 Computer Science carries 7 end-of-chapter exercise questions. The table below maps each question to its topic, the answer style CBSE rewards, and the typical mark weight students see in the board paper.

The two program questions (Q 3 and Q 7) and the conversion question (Q 6) carry the heaviest marks. Students who show the PUSH and POP loops clearly and draw the stack trace consistently score full marks.

Stack and the LIFO Rule: PUSH, POP, Overflow and Underflow

A stack is a linear data structure with one open end, called the top. You add and remove items only at the top, so the item added last is the item removed first. This is the LIFO rule: Last In, First Out. A pile of plates is the classic picture, where you take the top plate first.

• PUSH: add an item to the top of the stack. In Python, stack.append(x).
• POP: remove and return the top item. In Python, stack.pop().
• Overflow: trying to PUSH when the stack has no free space. Only PUSH can cause it.
• Underflow: trying to POP when the stack is already empty. Only POP can cause it.

Because a stack hands items back in reverse order, it is the natural tool for any task that needs reversal or back-tracking. The next sections show four such tasks straight from the NCERT exercise.

Stack with Python Lists: append() and pop()

The NCERT chapter uses a Python list as a stack, so you do not have to build one from scratch. append(x) adds x at the end of the list, which acts as the top, and pop() with no argument removes and returns that same end. This makes the list both the storage and the stack pointer.

stack = []
stack.append(10)     # PUSH 10  -> [10]
stack.append(20)     # PUSH 20  -> [10, 20]
top = stack.pop()    # POP      -> returns 20, list is [10]
empty = len(stack) == 0   # test for empty stack

Tracing Q 2 makes the LIFO order concrete. After append(40) the list [10,20,30,40] has 40 on top, so the first pop() returns 40 and the second returns 30, giving result = 70. In part (b), pushing 'T', 'A', 'M' and popping returns M, A, T, so the string builds up to MAT.

Reversing a String and Matching Parentheses Using a Stack

Two of the most asked applications are string reversal and parenthesis matching. Both rely on the same LIFO behaviour, and both appear almost every year in some form.

Reverse a string (Q 3)

PUSH every character of the string, then POP until the stack is empty. The first character popped is the last one pushed, so reading the popped characters gives the string backwards.

def reverse_string(text):
    stack = []
    for ch in text:
        stack.append(ch)            # PUSH every character
    reversed_text = ""
    while len(stack) != 0:          # until the stack is empty
        reversed_text = reversed_text + stack.pop()   # POP top char
    return reversed_text

For input HELLO the program prints OLLEH. Python can also reverse with slicing (text[::-1]), but if the question says "using stack" then slicing earns no method marks because it skips the data structure.

Match parentheses (Q 4)

Scan the expression left to right. PUSH each ( and POP one ( on each ). Digits and operators are ignored. The brackets are balanced only if the stack ends empty and you never POP an empty stack.

• For ((2+3)*(4/2))+2, the stack rises to two openers, falls, rises again, and falls to empty.
• Two failure tests, not one: a ) arriving on an empty stack, or the scan ending with openers still on the stack.

Tip: State both failure tests in your answer to show full understanding, even when the given expression is balanced.

Infix to Postfix Conversion and Postfix Evaluation

The two expression questions, Q 5 and Q 6, are where most students lose marks. Both use a stack, but in different ways, so keep their rules separate.

Postfix evaluation (Q 5)

Scan left to right. PUSH each operand value. On each operator, POP the top two values, apply the operator, and PUSH the result. The value popped first is the right operand; the value popped second is the left operand. The single value left at the end is the answer.

• With A=3, B=5, C=1, D=4, the expression A B + C * gives 3+5=8, then 8×1, so the answer is 8.
• A B * C / D * gives 3×5=15, then 15÷1=15, then 15×4, so the answer is 60.
• Order matters only for subtraction and division: compute second-popped operator first-popped.

Infix to postfix (Q 6)

Keep an operator stack and an output string. An operand goes to the output. A ( is pushed. A ) pops to the output until the matching ( is removed. An operator pops every operator of higher or equal precedence first, then pushes itself, where * and / outrank + and -.

Common Mistakes Students Make in the Stack Chapter

How to Use the Stack NCERT Solutions PDF for Board Prep

The Stack chapter is short but trap-heavy. The best approach is two passes: one for the LIFO concept and the Python methods, one for tracing the four applications by hand.

First pass: concept and methods (1 hour)

Read the chapter and note the LIFO rule, the overflow versus underflow pair, and the two list methods append() and pop(). Write one line of meaning next to each so the words stick before you start tracing.

Second pass: trace the applications (1.5 to 2 hours)

Work Q 2, Q 4, Q 5 and Q 6 on paper first, drawing the stack after every symbol. Then open these solutions and check your traces. Pay attention to operand order in division and to brackets never reaching the postfix output, because these two specifics decide full marks.

JEE and CUET angle

For students preparing competitive exams, stacks appear in data-structure questions in JEE-level programming rounds and in CUET Computer Science. Postfix evaluation and parenthesis matching are exactly the kind of trace questions those papers reuse, so the work here doubles as competitive prep.

Previous Year Question Trends from the Stack Chapter

The Stack chapter is tested in CBSE board papers mainly through output and trace questions, with a program question on string reversal or the odd-number stack. The table below maps the asked question types across recent board papers.

Also Check: The full set of CBSE board paper questions for this chapter is included in the downloadable PDF above, updated for the 2026-27 cycle.

Other Resources for Class 12 Computer Science Chapter 3 Stack

Pair this NCERT Solutions PDF with the matching revision notes, handwritten notes and the official NCERT book chapter. All resources for Class 12 Computer Science Chapter 3 Stack are linked below.

NCERT Solutions for Class 12 Computer Science: All Chapters

Related Links: Use the table below to open the NCERT Solutions for the other chapters of Class 12 Computer Science. Every chapter ships with the same step-by-step answer style, full PDF download, and revision FAQ.

All NCERT Solutions for Class 12 Computer Science Chapter 3 Stack with Step-by-Step Solutions

result=0
numberList=[10,20,30]
numberList.append(40)
result=result+numberList.pop()
result=result+numberList.pop()
print("Result=",result)

answer=[]; output=''
answer.append('T')
answer.append('A')
answer.append('M')
ch=answer.pop()
output=output+ch
ch=answer.pop()
output=output+ch
ch=answer.pop()
output=output+ch
print("Result=",output)

Result= 70

Result= MAT

def reverse_string(text):
    stack = []
    for ch in text:
        stack.append(ch)            # PUSH every character
    reversed_text = ""
    while len(stack) != 0:          # until the stack is empty
        reversed_text = reversed_text + stack.pop()   # POP top char
    return reversed_text

s = input("Enter a string: ")
print("Reversed string:", reverse_string(s))

Enter a string: HELLO
Reversed string: OLLEH

stack = []
n = int(input("How many numbers? "))
for i in range(n):
    num = int(input("Enter number: "))
    if num % 2 != 0:            # keep only odd numbers
        stack.append(num)       # PUSH odd number on the stack

print("Stack contents (top to bottom):")
largest = None
while len(stack) != 0:          # pop till the stack is empty
    value = stack.pop()         # POP one element
    print(value)
    if largest is None or value > largest:
        largest = value         # hold the biggest odd seen so far

if largest is None:
    print("No odd number was entered.")
else:
    print("Largest odd number:", largest)

How many numbers? 6
Enter number: 12
Enter number: 7
Enter number: 5
Enter number: 20
Enter number: 9
Enter number: 4
Stack contents (top to bottom):
9
5
7
Largest odd number: 9