Enqueue Using Linked List in DSA Python - Build from Scratch

Enqueue Using Linked List

📖 Scenario: Imagine you are managing a line of customers waiting to buy tickets. You want to add new customers to the end of the line efficiently. This line is represented using a linked list.

🎯 Goal: Build a simple linked list queue and add new elements to the end using the enqueue operation.

📋 What You'll Learn

Create a Node class with data and next attributes

Create a Queue class with front and rear attributes initialized to None

Implement an enqueue method to add nodes at the end of the queue

Print the queue elements from front to rear after enqueue operations

💡 Why This Matters

🌍 Real World

Queues are used in real life to manage lines, like customers waiting or tasks waiting to be processed.

💼 Career

Understanding linked list queues helps in software development for managing tasks, requests, or data streams efficiently.

1

Create Node and Queue classes

Create a class called Node with an __init__ method that takes data and sets self.data = data and self.next = None. Also create a class called Queue with an __init__ method that sets self.front = None and self.rear = None.

DSA Python

# Your code here

Hint

Define two classes: Node for each element and Queue to manage the linked list.

2

Add enqueue method to Queue

Inside the Queue class, create a method called enqueue that takes self and data. Inside it, create a new Node with data. If self.rear is None, set both self.front and self.rear to the new node. Otherwise, set self.rear.next to the new node and then update self.rear to the new node.

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

# Add enqueue method inside Queue class
# Your code here

Hint

Check if the queue is empty by testing self.rear. If empty, set both front and rear to the new node. Otherwise, link the new node at the end and update rear.

3

Add method to print queue elements

Inside the Queue class, create a method called print_queue that starts from self.front and prints each node's data followed by ' -> ' until it reaches None. After the loop, print 'None'.

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 = new_node
            self.rear = new_node
        else:
            self.rear.next = new_node
            self.rear = new_node

# Add print_queue method inside Queue class
# Your code here

Hint

Use a loop to go through each node starting from front and print the data with arrows until the end.

4

Enqueue elements and print the queue

Create a Queue object called q. Use q.enqueue(10), q.enqueue(20), and q.enqueue(30) to add three elements. Then call q.print_queue() to display the queue.

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 = new_node
            self.rear = new_node
        else:
            self.rear.next = new_node
            self.rear = new_node

    def print_queue(self):
        current = self.front
        while current is not None:
            print(str(current.data) + ' -> ', end='')
            current = current.next
        print('None')

# Create queue object q, enqueue 10, 20, 30, then print queue
# Your code here

Hint

Create the queue, add three numbers, then print the queue to see the order.