NCERT Solutions Class 12 Computer Science Chapter 4 Queue

The NCERT Solutions for Class 12 Computer Science Chapter 4 Queue cover all 8 exercise questions, according to the latest 2026-27 CBSE syllabus. Every answer follows the textbook's own flow: the FIFO rule of a queue, ENQUEUE and DEQUEUE with Python lists, and how a deque adds and removes from both ends to check palindromes and manage a shuttlecock box.

• All 8 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 FIFO, ENQUEUE and DEQUEUE, front and rear ends, overflow and underflow, deque operations, and the queue versus stack comparison 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 4 Queue Cover

This chapter answers one question: what is a queue, 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.

• Queue basics and the FIFO rule: a queue is a linear structure where you ENQUEUE at the rear and DEQUEUE from the front, so the first item in is the first item out.
• Overflow and underflow: ENQUEUE on a full queue causes overflow; DEQUEUE on an empty queue causes underflow. These two words are the most common 1-mark trap.
• Queue with Python lists: append() is ENQUEUE and pop(0) is DEQUEUE, so a list is a ready-made queue.
• Deque and applications: the double ended queue, the queue versus stack contrast, a menu driven shuttlecock box, and a palindrome check, all worked with step-by-step queue traces.

Exercise-wise Breakdown of the Queue Chapter NCERT Solutions

Chapter 4 of NCERT Class 12 Computer Science carries 8 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 4 and Q 8) carry the heaviest marks, while the two trace questions (Q 6 and Q 7) reward a clean step-by-step layout. Students who use pop(0) for the front and draw the queue after every line score full marks.

Queue and the FIFO Rule: ENQUEUE, DEQUEUE, Overflow and Underflow

A queue is a linear data structure with two open ends. New items join at the rear and leave from the front, so the item added first is the item removed first. This is the FIFO rule: First In, First Out. A line of people at a ticket counter is the classic picture, where the first to arrive is served first.

• ENQUEUE: add an item at the rear of the queue. In Python, queue.append(x).
• DEQUEUE: remove and return the front item. In Python, queue.pop(0).
• Overflow: trying to ENQUEUE when the queue has no free space. Only ENQUEUE can cause it.
• Underflow: trying to DEQUEUE when the queue is already empty. Only DEQUEUE can cause it.

Because a queue hands items back in arrival order, it is the natural tool for any task that needs fairness by arrival, such as print jobs, CPU scheduling, or breadth-first search. The next sections show the deque extension and the four worked exercise tasks.

Queue with Python Lists: append() and pop(0)

The NCERT chapter uses a Python list as a queue, so you do not have to build one from scratch. append(x) adds x at the end of the list, which acts as the rear, and pop(0) removes and returns the item at index 0, which is the front. Reading the front without removing it is queue[0], the PEEK operation.

queue = []
queue.append(10)     # ENQUEUE 10 -> [10]
queue.append(20)     # ENQUEUE 20 -> [10, 20]
front = queue.pop(0) # DEQUEUE    -> returns 10, list is [20]
peek = queue[0]      # PEEK       -> reads 20, list unchanged
empty = len(queue) == 0   # test for empty queue

Tracing Q 6 makes the FIFO order concrete. After several ENQUEUE and DEQUEUE calls the queue keeps the oldest element at the front, so each DEQUEUE removes the value that has waited longest. Two DEQUEUE calls on an empty queue both cause underflow, leaving the final queue as [1].

Queue versus Stack and the Deque Data Structure

Two of the most asked theory questions compare a queue with a stack (Q 2) and a queue with a deque (Q 5). Both rely on where each operation acts, so keep the ends clear.

Queue versus stack (Q 2)

A stack and a queue are both linear and both restrict access to the ends, and both can overflow and underflow. The difference is the order: a stack is LIFO and uses one end (the top) for PUSH and POP, while a queue is FIFO and uses two ends, the rear for ENQUEUE and the front for DEQUEUE.

• Push A, B, C onto a stack then pop, and you get C, B, A. Enqueue A, B, C then dequeue, and you get A, B, C.
• Use a stack for undo, function calls, and expression evaluation; use a queue for print jobs, CPU scheduling, and breadth-first search.

Queue versus deque (Q 5)

A deque, short for double ended queue, lets you insert and delete at either end, the front or the rear, but never the middle. So a deque has four operations (insertFront, insertRear, deletionFront, deletionRear) while a plain queue has just two (ENQUEUE, DEQUEUE). A queue is really a restricted deque.

Tip: If the question lets you delete from the rear, it is a deque, not a queue. Count the operations to tell them apart quickly.

Queue and Deque Programs: Shuttlecock Box and Palindrome Check

The two program questions, Q 4 and Q 8, are where most marks sit. Both use Python lists, but one models a plain queue and the other a deque, so keep their operations separate.

Menu driven shuttlecock box (Q 4)

A box of shuttlecocks behaves like a queue: the first one put in is the first one taken out. Use append() to add at the rear, pop(0) to remove from the front, and guard every removal with an empty-box check so an underflow never crashes the menu.

def dequeue(box):
    if len(box) == 0:
        print("Box is empty. Underflow, nothing to take out.")
    else:
        s = box.pop(0)             # remove from the front
        print("Shuttlecock", s, "taken out of the box.")

The full answer wraps each action (enqueue, dequeue, peek, display) in a function and runs them from a while True menu loop that breaks only on Exit. The complete program with a sample run is solved below.

Palindrome check with a deque (Q 8)

A deque is the right tool to check a palindrome because you can remove a character from the front and one from the rear in the same loop. Load every character, then pop both ends and compare until one or zero characters remain.

def is_palindrome(text):
    dq = []
    for ch in text:
        dq.append(ch)              # load every character
    while len(dq) > 1:             # at least two to compare
        if dq.pop(0) != dq.pop():  # front vs rear
            return False
    return True                    # all pairs matched

Common Mistakes Students Make in the Queue Chapter

How to Use the Queue NCERT Solutions PDF for Board Prep

The Queue chapter is short but trap-heavy, mostly around the two ends. The best approach is two passes: one for the FIFO concept and the Python methods, one for tracing the queue and deque operations by hand.

First pass: concept and methods (1 hour)

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

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

Work Q 6 and Q 7 on paper first, drawing the queue and the deque after every operation with the front on the left. Then open these solutions and check your traces. Pay attention to the peek rule and to the underflow calls near the end, because these two specifics decide full marks.

JEE and CUET angle

For students preparing competitive exams, queues and deques appear in data-structure questions in JEE-level programming rounds and in CUET Computer Science. FIFO scheduling and palindrome checks are exactly the kind of questions those papers reuse, so the work here doubles as competitive prep.

Previous Year Question Trends from the Queue Chapter

The Queue chapter is tested in CBSE board papers mainly through trace questions and a program on the shuttlecock box or a palindrome. 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 4 Queue

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 4 Queue 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 4 Queue with Step-by-Step Solutions

def is_empty(box):
    return len(box) == 0           # box has no shuttlecock

def enqueue(box):
    s = int(input("Enter shuttlecock number to add: "))
    box.append(s)                  # add at the rear
    print("Shuttlecock", s, "added to the box.")

def dequeue(box):
    if is_empty(box):
        print("Box is empty. Underflow, nothing to take out.")
    else:
        s = box.pop(0)             # remove from the front
        print("Shuttlecock", s, "taken out of the box.")

def peek(box):
    if is_empty(box):
        print("Box is empty.")
    else:
        print("Front shuttlecock is:", box[0])

def display(box):
    if is_empty(box):
        print("Box is empty.")
    else:
        print("Box (front to rear):", box)

box = []
while True:
    print("\n--- Shuttlecock Box Menu ---")
    print("1. Add shuttlecock (Enqueue)")
    print("2. Take out shuttlecock (Dequeue)")
    print("3. See front shuttlecock (Peek)")
    print("4. Display box")
    print("5. Exit")
    choice = int(input("Enter your choice (1-5): "))
    if choice == 1:
        enqueue(box)
    elif choice == 2:
        dequeue(box)
    elif choice == 3:
        peek(box)
    elif choice == 4:
        display(box)
    elif choice == 5:
        print("Exiting. Goodbye!")
        break
    else:
        print("Wrong choice. Enter a number from 1 to 5.")

Enter your choice (1-5): 1
Enter shuttlecock number to add: 101
Shuttlecock 101 added to the box.
Enter your choice (1-5): 1
Enter shuttlecock number to add: 102
Shuttlecock 102 added to the box.
Enter your choice (1-5): 3
Front shuttlecock is: 101
Enter your choice (1-5): 2
Shuttlecock 101 taken out of the box.
Enter your choice (1-5): 4
Box (front to rear): [102]
Enter your choice (1-5): 5
Exiting. Goodbye!

enqueue(34)
enqueue(54)
dequeue()
enqueue(12)
dequeue()
enqueue(61)
peek()
dequeue()
dequeue()
dequeue()
dequeue()
enqueue(1)

peek()
insertFront(12)
insertRear(67)
deletionFront()
insertRear(43)
deletionRear()
deletionFront()
deletionRear()

def is_palindrome(text):
    dq = []
    for ch in text:
        dq.append(ch)              # put every character in the deque
    while len(dq) > 1:             # at least two characters to compare
        front = dq.pop(0)          # remove from the front
        rear = dq.pop()            # remove from the rear
        if front != rear:          # a mismatched pair
            return False
    return True                    # all pairs matched

s = input("Enter a string: ")
if is_palindrome(s):
    print(s, "is a palindrome.")
else:
    print(s, "is not a palindrome.")

Enter a string: MADAM
MADAM is a palindrome.

Enter a string: HELLO
HELLO is not a palindrome.