NCERT Notes Class 12 Computer Science Chapter 3 Stack

These Notes for Class 12 Computer Science Chapter 3 Stack give you a fast, concept-first revision of the whole chapter, built on the latest 2026-27 CBSE syllabus. They explain what a stack is, the LIFO rule, the PUSH and POP operations with overflow and underflow, how a Python list works as a stack, and the three expression notations infix, prefix and postfix.

• Every operation explained with a one-line meaning, a short Python code block, and a traced example of the top moving up and down.
• Full coverage of LIFO, PUSH, POP, overflow, underflow and the infix-to-postfix conversion that the CBSE board paper tests directly.
• Notes aligned with the 2026-27 CBSE Class 12 Computer Science syllabus and useful for JEE and CUET programming questions; no NEET references because Computer Science is not a medical subject.

These Collegedunia revision notes are curated by Computer Science subject experts, according to the 2026-27 NCERT textbook, and refined against the last five years of CBSE Class 12 Computer Science board papers.

What the Notes for Class 12 Computer Science Chapter 3 Stack Cover

This chapter answers one question: how does a program store data so the last item added is the first item removed? These notes keep the NCERT order but compress it into revision-ready blocks, so you can read the whole chapter in one sitting and recall it fast in the exam.

• What a stack is: a linear data structure where insertion and deletion happen at one end only, called the top.
• The LIFO rule: Last-In-First-Out, the element added last is the one removed first, like a pile of plates.
• PUSH and POP: PUSH adds to the top and can cause overflow; POP removes from the top and can cause underflow.
• Notations: infix, prefix and postfix, and how a stack converts infix to postfix and then evaluates the postfix in one scan.

What a Stack Is and the LIFO Rule in Class 12 Computer Science

Before the operations, fix the vocabulary. A data structure is a way to store, organise and access data along with the operations on it. A stack is a linear data structure with only one open end. Getting this definition exact is what the first True or False question rewards.

• Linear data structure: elements sit one after another in a sequence; lists, strings, stacks and queues are all linear.
• The top: the only end where you add or remove. The bottom is never touched directly.
• LIFO rule: Last-In-First-Out. The element pushed last is popped first, the exact reverse of the order of entry.

Picture a pile of plates. You add a new plate on the top and you take a plate off the top. If you push Plate 1, Plate 2, Plate 3, then Plate 4, the removal order is Plate 4 first, then 3, then 2, and Plate 1 last. That reversed order is the heart of the LIFO rule, and a queue (the next chapter) does the opposite with FIFO.

Where Stacks Are Used in Computer Science

Stacks turn up in everyday life and in software far more often than students expect. The NCERT chapter lists plain real-life piles and several programming uses, and the programming ones carry the most marks in the exam.

The most important hidden stack is the call stack. When main() calls greet(), which calls message(), each call is pushed, so message() sits on top. The order of return is the exact reverse of the order of calling. If a function keeps calling itself with no base case, the call stack grows until it runs out of space, which is the real stack overflow error you may have heard about.

PUSH and POP Operations with Overflow and Underflow

A stack would be useless if you could only look at it. Two operations make it work: PUSH to add an element and POP to remove one. Both act on the top of the stack and nowhere else, and each has one error condition you must name correctly in the exam.

• PUSH: an insertion operation that places a new element on the top. If the stack is full, PUSH causes overflow.
• POP: a delete operation that removes and returns the topmost element. If the stack is empty, POP causes underflow.
• Top pointer: after a PUSH the top points to the new element; after a POP it falls back to the element below.

Trace the sequence push 1, push 2, pop, push 3, push 4, then pop everything. After two pushes the top holds 2. The pop removes 2, so the top falls back to 1. Push 3 and 4 raise the top to 4. The last pops remove 4, then 3, then 1, exactly the reverse of the order they came in. You never need to redraw the stack: pop order is push order reversed.

Implementing a Stack in Python with a List

Python has no built-in stack type, but a list already does almost everything a stack needs. The method append() adds an item at the right end and pop() removes an item from the right end. If we treat the right end of the list as the top, these two methods become PUSH and POP for free.

• append(x) is PUSH, pop() is POP, and list[-1] is the top.
• No separate top variable is needed because both methods work at the right end.
• A Python list grows as needed, so this stack effectively never sees overflow; it can still see underflow if you pop an empty list.

The book builds a stack of glasses with small helper functions. isEmpty checks the length, opPush appends, opPop checks for underflow before removing, and display prints from the top down. The handlers below are the exact code you should be able to reproduce in the exam:

glassStack = list()            # create an empty stack

def isEmpty(glassStack):
    return len(glassStack) == 0

def opPush(glassStack, element):
    glassStack.append(element)      # PUSH: add at the top

def opPop(glassStack):
    if isEmpty(glassStack):
        print('underflow')
        return None
    else:
        return glassStack.pop()     # POP: remove the top

The driver pushes two glasses, pops one, pushes another, then pops until empty. Because the list grows on demand, the only error you can hit is underflow, printed by opPop when the stack is empty:

Current number of elements: 2
Popped element is glass2
top element is glass3
Popped element is glass3
Popped element is glass1
underflow
Stack is empty now

Reverse a string using a stack

A classic use of a stack, and exercise question 3, is reversing a string. Push every character, then pop them all. Because pop returns items in the reverse order of pushing, the popped characters spell the word backwards.

def reverse_string(text):
    stack = list()
    for ch in text:          # PUSH each character
        stack.append(ch)
    result = ''
    while len(stack) > 0:    # POP until empty
        result = result + stack.pop()
    return result

print(reverse_string("STACK"))   # prints KCATS

Infix, Prefix and Postfix Notations Explained

You normally write sums like x + y with the operator between its operands. That is only one of three ways to write an expression. The three notations differ in just one thing: where the operator sits with respect to its two operands.

Infix is what humans read, but it needs brackets and the BODMAS precedence rule to remove ambiguity. The big win of prefix and postfix is that they need no parentheses: the position of each operator already fixes the order of evaluation. The mathematician Jan Lukasiewicz introduced prefix notation in the 1920s, and reversing the idea gives postfix.

Converting Infix to Postfix Using a Stack

Algorithm 3.1 of the NCERT book uses a stack to hold operators and a string to build the postfix result. The stack stores weaker operators until a stronger one or the end of input forces them off. The rules, in plain words:

1. If the character is an operand, append it to the result string.
2. If it is a left parenthesis (, push it on the stack.
3. If it is a right parenthesis ), pop and append operators until the matching ( is popped, then discard both brackets.
4. If it is an operator, pop operators of higher or equal precedence to the result, then push the new operator.
5. After the scan, pop any remaining operators and append them.

Convert (x + y) / (z * 8) the way Example 3.1 does. The table shows the stack and the result string after each character. Notice the operands keep their order and the brackets vanish in the final answer.

The final postfix expression is xy+z8*/. For an expression without brackets like A + B - C * D, precedence does all the work: the answer is AB+CD*-, because * binds tighter and stays on the stack until the end.

Evaluating a Postfix Expression and Common Exam Traps

Once an expression is in postfix form, a stack evaluates it in a single left-to-right pass with no brackets and no precedence checks. Algorithm 3.2 uses a stack of operands. Scan left to right and apply three simple rules.

• If the character is an operand, push it on the stack.
• If it is an operator, pop the top two operands, apply the operator, and push the result back.
• At the end, the single value left on the stack is the answer.

Take the postfix expression 7 8 2 * 4 / + from Example 3.2. Push 7, 8, 2. On * pop 8 and 2, compute 8 * 2 = 16, push 16. Push 4. On / pop 16 and 4, compute 16 / 4 = 4, push 4. On + pop 7 and 4, compute 7 + 4 = 11. The stack now holds the single value 11, which is the answer.

How to Use the Stack Notes PDF for Board Revision

The Stack chapter is short but definition-heavy and trace-heavy. The best approach is two passes: one for the vocabulary and the LIFO rule, one for tracing the small programs and the postfix conversions by hand.

First pass: vocabulary and the LIFO rule

Read these notes and lock the labels: stack, top, LIFO, PUSH, POP, overflow, underflow, and the three notations. Say one line of meaning aloud for each so the words stick before you start tracing code. Pay special attention to which operation pairs with which error.

Second pass: trace the programs and conversions

Take the PUSH-POP sequence and the (x + y) / (z * 8) conversion and trace them on paper. Write the stack and the result string after each symbol. That single exercise covers the most common 3-mark board question on this chapter.

JEE and CUET angle

For students preparing competitive exams, stacks appear in data-structure rounds and in CUET Computer Science. The LIFO rule, infix-to-postfix conversion, and postfix evaluation are exactly the kind of concept questions those papers reuse, so this revision doubles as competitive prep.

Previous Year Question Trends from the Stack Chapter

The Stack chapter is tested in CBSE board papers mainly through definition, output and conversion questions, with a program question on PUSH or POP. The table below maps the asked question types across recent board papers, so your revision can target the high-frequency areas.

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

Other Resources for Class 12 Computer Science Chapter 3 Stack

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

Notes for Class 12 Computer Science: All Chapters

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