Enqueue Using Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after multiple enqueues in a linked list queue

What is the printed state of the queue after enqueuing 10, 20, and 30 in order?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = self.rear = new_node
            return
        self.rear.next = new_node
        self.rear = new_node

    def print_queue(self):
        current = self.front
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('null')

q = Queue()
q.enqueue(10)
q.enqueue(20)
q.enqueue(30)
q.print_queue()

A null

B 30 -> 20 -> 10 -> null

C 10 -> 30 -> 20 -> null

D 10 -> 20 -> 30 -> null

💡 Hint

Remember, enqueue adds to the rear of the queue.

Enqueue adds elements at the rear. So the order is 10, then 20, then 30, printed front to rear.

❓ Predict Output

intermediate

Output after enqueuing a single element in an empty queue

What is the printed state of the queue after enqueuing only the element 5?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = self.rear = new_node
            return
        self.rear.next = new_node
        self.rear = new_node

    def print_queue(self):
        current = self.front
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('null')

q = Queue()
q.enqueue(5)
q.print_queue()

A 5 -> null

B 5

C null

D Error

💡 Hint

Check how enqueue handles the empty queue case.

When the queue is empty, both front and rear point to the new node. So printing shows 5 -> null.

🔧 Debug

advanced

Identify the error in enqueue method

What error will occur when running this enqueue method code?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.rear == None:
            self.front = new_node
        else:
            self.rear.next = new_node
        self.rear = new_node

q = Queue()
q.enqueue(1)
q.enqueue(2)
print(q.front.data, q.rear.data)

A TypeError: unsupported operand type(s)

B AttributeError: 'NoneType' object has no attribute 'next'

C Prints: 1 2

D IndexError: list index out of range

💡 Hint

Check how the rear pointer is updated when the queue is empty.

The code correctly updates front and rear pointers. No error occurs. It prints '1 2'.

🧠 Conceptual

advanced

Why is rear pointer needed in linked list queue?

Why do we keep a rear pointer in a linked list implementation of a queue?

A To reverse the queue easily

B To allow enqueue operation in O(1) time by adding at the end directly

C To allow dequeue operation in O(1) time by removing from the end

D To keep track of the number of elements in the queue

💡 Hint

Think about how adding elements at the end works without rear pointer.

Rear pointer lets us add new nodes at the end quickly without traversing the whole list.

❓ Predict Output

expert

Final queue state after mixed enqueues and dequeues

Given the following operations, what is the printed queue state at the end?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = self.rear = new_node
            return
        self.rear.next = new_node
        self.rear = new_node

    def dequeue(self):
        if self.front is None:
            return None
        temp = self.front
        self.front = temp.next
        if self.front is None:
            self.rear = None
        return temp.data

    def print_queue(self):
        current = self.front
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('null')

q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
q.enqueue(4)
q.dequeue()
q.enqueue(5)
q.print_queue()

A 3 -> 4 -> 5 -> null

B 1 -> 2 -> 3 -> 4 -> 5 -> null

C 4 -> 5 -> null

D 2 -> 3 -> 4 -> 5 -> null

💡 Hint

Trace each enqueue and dequeue step carefully.

After dequeuing twice, 1 and 2 are removed. Then 3,4,5 remain in order.