Dequeue Using Linked List in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add a new node at the front of the dequeue.

DSA Python

def add_front(self, data):
    new_node = Node(data)
    if self.front is None:
        self.front = self.rear = new_node
    else:
        new_node.next = [1]
        self.front.prev = new_node
        self.front = new_node

Drag options to blanks, or click blank then click option'

Aself.front

Bself.rear

Cnew_node

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Setting new_node.next to None instead of the current front.

Confusing front and rear pointers.

The new node's next should point to the current front node.

2fill in blank

medium

Complete the code to remove a node from the rear of the dequeue.

DSA Python

def remove_rear(self):
    if self.rear is None:
        return None
    data = self.rear.data
    self.rear = self.rear.prev
    if self.rear is not None:
        self.rear.next = [1]
    else:
        self.front = None
    return data

Drag options to blanks, or click blank then click option'

ANone

Bself.front

Cself.rear

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Setting rear.next to rear itself causing a cycle.

Not updating front when list becomes empty.

After removing the rear node, if rear exists, its next should be None.

3fill in blank

hard

Fix the error in the code to add a node at the rear of the dequeue.

DSA Python

def add_rear(self, data):
    new_node = Node(data)
    if self.rear is None:
        self.front = self.rear = new_node
    else:
        self.rear.next = new_node
        new_node.prev = [1]
        self.rear = new_node

Drag options to blanks, or click blank then click option'

Aself.front

Bself.rear

Cnew_node

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Setting new_node.prev to new_node causing self-reference.

Setting new_node.prev to front instead of rear.

The new node's prev should point to the current rear before updating rear.

4fill in blank

hard

Fill both blanks to correctly remove a node from the front of the dequeue.

DSA Python

def remove_front(self):
    if self.front is None:
        return None
    data = self.front.data
    self.front = self.front.[1]
    if self.front is not None:
        self.front.[2] = None
    else:
        self.rear = None
    return data

Drag options to blanks, or click blank then click option'

Anext

Bprev

Cfront

Drear

Attempts:

3 left

💡 Hint

Common Mistakes

Setting front to front.prev which moves backward incorrectly.

Not clearing the prev pointer of the new front node.

To remove the front node, move front to front.next and set new front's prev to None.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each node's data to its position if data is positive.

DSA Python

def map_positive_nodes(self):
    result = {node.data[1]: idx for idx, node in enumerate(self.iterate()) if node.data [2] 0 and node.data is not [3] None}
    return result

Drag options to blanks, or click blank then click option'

A * 2

B>

C==

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '*' instead of '+' for key expression.

Using '==' instead of '>' for filtering positive data.

Checking data is None with '==' instead of 'is not'.

The comprehension maps node.data plus idx as key, filters nodes with data > 0, and excludes None data.

Practice

1. What is a dequeue (double-ended queue) implemented using a linked list?

easy

A. A queue where elements can only be added at the rear

B. A list that only allows insertion at the front

C. A stack implemented using arrays

D. A data structure where elements can be added or removed from both ends

Solution

1. Step 1: Understand dequeue operations

   A dequeue allows insertion and deletion from both front and rear ends.

2. Step 2: Linked list implementation

   Using a linked list, nodes can be added or removed from both ends efficiently.

3. Final Answer:

   A data structure where elements can be added or removed from both ends -> Option D

4. Quick Check:

   Dequeue = double-ended queue [OK]

Hint: Dequeue means double-ended queue, both ends allowed [OK]

Common Mistakes:

• Confusing dequeue with stack or simple queue
• Thinking insertion is only at one end
• Assuming array implementation only

2. Which of the following is the correct way to initialize an empty dequeue using a linked list in Python?

easy

A. class Dequeue: def __init__(self): self.front = None; self.rear = None

B. class Dequeue: def __init__(self): self.list = []

C. class Dequeue: def __init__(self): self.head = 0; self.tail = 0

D. class Dequeue: def __init__(self): self.front = 0; self.rear = 0

Solution

1. Step 1: Identify linked list pointers

   For linked list, front and rear pointers are initialized to None to indicate empty.

2. Step 2: Check options

   class Dequeue: def __init__(self): self.front = None; self.rear = None correctly initializes front and rear as None; others use incorrect types or structures.

3. Final Answer:

   class Dequeue: def __init__(self): self.front = None; self.rear = None -> Option A

4. Quick Check:

   Linked list empty pointers = None [OK]

Hint: Empty linked list pointers are None, not zero or list [OK]

Common Mistakes:

• Using list instead of linked list
• Initializing pointers with 0 instead of None
• Confusing front/rear with indices

3. What will be the output after performing these operations on an empty dequeue implemented with linked list?
dq.insert_rear(10)
dq.insert_front(20)
dq.insert_rear(30)
dq.delete_front()
Print the dequeue from front to rear.

medium

A. 20 -> 10 -> 30 -> null

B. 20 -> 30 -> null

C. 10 -> 30 -> null

D. 30 -> 10 -> 20 -> null

Solution

1. Step 1: Perform insert_rear(10) on empty dequeue

   Dequeue becomes: 10 -> null

2. Step 2: Perform insert_front(20)

   Dequeue becomes: 20 -> 10 -> null

3. Step 3: Perform insert_rear(30)

   Dequeue becomes: 20 -> 10 -> 30 -> null

4. Step 4: Perform delete_front()

   Remove 20 from front, dequeue becomes: 10 -> 30 -> null

5. Final Answer:

   10 -> 30 -> null -> Option C

6. Quick Check:

   After operations, front to rear = 10, 30 [OK]

Hint: Track each operation stepwise front to rear [OK]

Common Mistakes:

• Forgetting delete_front removes front element
• Mixing order of insert_front and insert_rear
• Printing rear to front instead of front to rear

4. Identify the error in this dequeue linked list method for deleting from rear:

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

medium

A. Does not check if dequeue is empty

B. Incorrectly moves rear pointer forward instead of backward

C. Returns data before deleting node

D. Uses wrong variable name for rear

Solution

1. Step 1: Understand rear pointer movement

   In linked list, rear points to last node; to delete rear, rear must move backward (to previous node).

2. Step 2: Analyze code

   Code moves rear to rear.next (forward), which is incorrect for rear deletion.

3. Final Answer:

   Incorrectly moves rear pointer forward instead of backward -> Option B

4. Quick Check:

   Rear deletion moves pointer backward [OK]

Hint: Rear deletion moves pointer backward, not forward [OK]

Common Mistakes:

• Moving rear pointer forward instead of backward
• Not handling empty dequeue properly
• Confusing front and rear pointers

5. You want to implement a dequeue using a doubly linked list to support these operations efficiently:
1. Insert at front
2. Insert at rear
3. Delete from front
4. Delete from rear

Which of the following is the best approach to maintain pointers for O(1) time complexity for all operations?

hard

A. Maintain front and rear pointers; each node has next and prev links

B. Maintain only front pointer; traverse list for rear operations

C. Use singly linked list with only next pointers and rear pointer

D. Use array to simulate linked list with indices

Solution

1. Step 1: Understand operation requirements

   All operations must be O(1), so no traversal allowed.

2. Step 2: Analyze pointer needs

   Doubly linked list with front and rear pointers allows insert/delete at both ends in O(1).

3. Step 3: Check options

   Maintain front and rear pointers; each node has next and prev links matches this approach; others require traversal or use arrays which are not linked lists.

4. Final Answer:

   Maintain front and rear pointers; each node has next and prev links -> Option A

5. Quick Check:

   Doubly linked list + front/rear pointers = O(1) ops [OK]

Hint: Use doubly linked list with front and rear pointers [OK]

Common Mistakes:

• Using singly linked list causing O(n) rear operations
• Maintaining only one pointer causing traversal
• Confusing arrays with linked lists