NCERT Notes Class 12 Computer Science Chapter 4 Queue

These Notes for Class 12 Computer Science Chapter 4 Queue give you a fast, concept-first revision of the whole chapter, built on the latest 2026-27 CBSE syllabus. They cover the FIFO rule, the two ends of a queue, the enqueue and dequeue operations, overflow and underflow, the Python list implementation, and the double ended deque with its palindrome check.

• Every operation explained with a one-line meaning, a short Python code block, and a traced status table so you can answer the output questions the board asks.
• Full coverage of enqueue, dequeue, peek, isEmpty, overflow, underflow and the deque operations insertFront, insertRear, deletionFront and deletionRear.
• Notes 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.

These Collegedunia revision notes are 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 Notes for Class 12 Computer Science Chapter 4 Queue Cover

This chapter answers one question: how does a program serve many requests in the exact order they arrived? 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.

• The FIFO rule: First In First Out, the single idea that defines a queue and separates it from a stack.
• The two ends: items enter at the rear and leave from the front, never the other way round in a plain queue.
• The operations: enqueue, dequeue, peek, isEmpty, size, and the two error states overflow and underflow.
• The Python list build and the deque: how append() and pop(0) make a queue, and how a double ended queue powers the palindrome check.

What Is a Queue and the FIFO Rule in Class 12 Computer Science

A queue is an ordered linear list of elements in which you add items at one end and remove them from the other end. You already use one every day: the line at a bank counter or the row of cars at a fuel pump. The person who joins first is served first, and new people join only at the back. A queue in programming copies that exact idea.

The rule a queue follows is First In First Out, written as FIFO. The element that entered the queue first is the first one to leave it. The same rule is also called First Come First Served (FCFS), which is FIFO seen from the customer's side. Compare this with a stack, which is Last In First Out, and the whole chapter falls into place.

• Items are kept in the order they arrive, so a queue remembers its sequence.
• The item that has waited the longest is always the next to leave.
• A queue is the natural fit whenever many requests must be served fairly, in arrival order.

Inside a computer the same idea is everywhere. A web server that handles only a few requests at a time queues the rest and serves them FIFO. A CPU runs one job at a time, so the operating system queues the waiting jobs and gives the processor to them in arrival order. A printer takes print jobs one by one from a queue, which is the everyday print spooler.

Front and Rear: The Two Ends of a Queue

Every queue has exactly two named ends, and keeping them straight is the single most common exam need. The rear is where items enter; it is also called the tail or the back. The front is where items leave; it is also called the head. Mixing these two up is the fastest way to lose marks on this chapter.

The order is fixed: a new element joins at the rear and waits behind everyone already in line, while the oldest element sits at the front and is the next to leave. Because the two jobs happen at two separate ends, a plain queue never mixes them up.

Queue Operations: Enqueue, Dequeue, Peek and Helpers

A data structure is only useful if it supports a clear set of operations. A queue defines two operations that move data, plus a few helpers that keep those moves safe. Getting the names right is worth easy marks, because the board often asks "what is insertion in a queue called?"

The two operations that actually change a queue are enqueue and dequeue. They are mirror images: one adds at the rear, the other removes from the front, and each works at its own fixed end.

Overflow and Underflow in a Queue

Two error conditions can arise while operating a queue, and both have exact names you must use in the exam. Trying to add to a full queue raises an overflow. Trying to remove from an empty queue raises an underflow. The names sound similar, so students mix them up under pressure.

There is one neat exception in the NCERT Python build. Because a Python list grows on demand, the list-based queue never becomes full, so it needs no isFull check and never overflows. You still guard every dequeue with isEmpty to prevent underflow, exactly as the cashier waits when the line is empty.

Implementing a Queue in Python with a List

NCERT implements a queue using Python's built-in list type. A list can grow and shrink, so it is a comfortable home for a queue. Two list methods do all the work, one for each end of the queue.

• append() adds an element at the end of the list, which is the rear, so it is the engine of enqueue.
• pop(0) removes the element at index 0, the start of the list, which is the front, so it is the engine of dequeue.
• len() backs both size and isEmpty, while indexing myQueue[0] backs peek.

We begin by creating an empty list and writing enqueue. Because Python lists grow automatically, this design never runs out of room, so there is no isFull function.

myQueue = list()          # an empty queue

def enqueue(myQueue, element):
    myQueue.append(element)   # append adds at the end = REAR

Before removing, we must know whether the queue has anything in it. The isEmpty function checks the length of the list, and dequeue removes the front element only when the queue is not empty. The key detail is pop(0), which deletes the element at index 0, the front of the queue.

def isEmpty(myQueue):
    if len(myQueue) == 0:
        return True
    else:
        return False

def dequeue(myQueue):
    if not isEmpty(myQueue):
        return myQueue.pop(0)   # pop(0) removes the FRONT
    else:
        print("Queue is empty")

Two small read-only helpers finish the toolkit. The size function counts the elements, and peek returns the front value without removing it. Notice that peek returns myQueue[0] but never changes the list, which is the difference between looking and taking.

def size(myQueue):
    return len(myQueue)

def peek(myQueue):
    if isEmpty(myQueue):
        print('Queue is empty')
        return None
    else:
        return myQueue[0]   # front element, not removed

Putting it together gives the NCERT bank-counter program (Program 4-1): people join the queue with codes, one is served, more arrive, and finally everyone left is served until the queue is empty. Running it proves FIFO, because the first person in is the first person out.

person removed from queue is: P1
Number of people in the queue is: 1
person removed from queue is: P2
person removed from queue is: P3
person removed from queue is: P4
person removed from queue is: P5

Tracing Queue Operations Step by Step

Exams love questions that give a list of operations and ask for the queue status after each one. The only safe method is to track the queue contents row by row, writing the front on the left and the rear on the right, and redrawing the whole queue after every single step.

The trace below is the exact Exercise Q6 operation list. Watch how a dequeue on an empty queue causes underflow, and how the final enqueue refills the empty queue.

The two dequeue calls on the empty queue both report underflow because there is nothing to remove. The final enqueue(1) then puts 1 into the now-empty queue, so the queue ends holding a single element. The peek() in the middle changed nothing, which is the point of the trap.

The Deque: A Double Ended Queue in Class 12 Computer Science

A deque, pronounced "deck", is short for double ended queue. Unlike a plain queue, a deque lets you add and remove from either end, the front or the rear, though never from the middle. Because of this freedom, one deque can behave like a stack or like a queue, depending on which ends you use.

Working at both ends means a deque needs four moving operations instead of two: two inserts and two deletes, one of each per end. It reuses the same helpers as a queue, namely isEmpty, peek and size.

In Python the front uses index 0 and the rear uses the end of the list. The only new pieces compared with a queue are insert(0, element) to push at the front and a bare pop() to remove from the rear.

def insertFront(myDeque, element):
    myDeque.insert(0, element)      # insert at index 0 = FRONT

def insertRear(myDeque, element):
    myDeque.append(element)         # append = REAR

def deletionFront(myDeque):
    if not isEmpty(myDeque):
        return myDeque.pop(0)       # remove FRONT
    else:
        print("Queue underflow")

def deletionRear(myDeque):
    if not isEmpty(myDeque):
        return myDeque.pop()        # remove REAR (last item)
    else:
        print("Queue underflow")

A subtle exam idea hides here. If you insert and delete from the same end of a deque, it acts like a stack (LIFO). If you insert at one end and delete from the opposite end, it acts like a queue (FIFO). The deque is the parent that both children come from.

Queue vs Stack and the Palindrome Check

Exercise Q2 asks you to compare and contrast a queue with a stack. The single biggest difference is the order rule: a queue is FIFO, a stack is LIFO. The table lays the two side by side so the contrast is exam-ready.

The most important deque program in the chapter is the palindrome check, built straight from NCERT Algorithm 4.1. The idea is neat: push every character to the rear, then repeatedly compare the front and rear characters while removing both. If every pair matches until 0 or 1 character is left, the string is a palindrome.

def isPalindrome(text):
    myDeque = list()
    for ch in text:
        myDeque.append(ch)             # push every character at rear
    while len(myDeque) > 1:
        first = myDeque.pop(0)         # remove from FRONT
        last = myDeque.pop()           # remove from REAR
        if first != last:
            return False               # mismatch: not a palindrome
    return True                        # all pairs matched

print(isPalindrome("madam"))
print(isPalindrome("queue"))

True
False

For "madam" the front m matches the rear m, then a matches a, leaving the middle d alone, so the function returns True. For "queue" the very first compare (q against e) fails, so it returns False at once.

How to Use the Queue Notes PDF for Board Revision

The Queue chapter is short but definition-heavy and trace-heavy. The best approach is two passes: one for the vocabulary and the operation names, one for tracing the small programs and operation lists by hand.

First pass: vocabulary and operations

Read these notes and note the FIFO rule, the front-versus-rear split, and the role of each operation: enqueue, dequeue, peek, isEmpty, size, plus the four deque moves. Say one line of meaning aloud for each so the words stick before you start tracing.

Second pass: trace the operations

Take the Exercise Q6 operation list above and trace it on paper, writing the front on the left and the rear on the right after each step. Do the same for the deque trace in Exercise Q7. That single drill covers the most common output question on this chapter.

JEE and CUET angle

For students preparing competitive exams, queues and deques appear in data-structure rounds and in CUET Computer Science. The FIFO-versus-LIFO contrast, the enqueue and dequeue ends, and the deque-as-stack-or-queue idea are exactly the concept questions those papers reuse, so this revision doubles as competitive prep.

Previous Year Question Trends from the Queue Chapter

The Queue chapter is tested in CBSE board papers mainly through definition, fill-in-the-blank and output questions, with a program question on a menu-driven queue or a deque palindrome. 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 4 Queue

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 4 Queue 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. The previous chapter is Stack and the next chapter is Sorting. Every chapter ships with the same concept-first notes style, full PDF download, and revision FAQ.