Enqueue Using Linked List in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA Go

newNode := &Node{data: [1], next: nil}

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

Atail

Bnil

Cvalue

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil instead of the value for the data field.

Confusing next pointer with data.

The new node should store the given value in its data field.

2fill in blank

medium

Complete the code to check if the queue is empty before enqueue.

DSA Go

if [1] == nil { head = newNode; tail = newNode } else { tail.next = newNode; tail = newNode }

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

Ahead

Btail

CnewNode

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Checking tail instead of head.

Checking newNode which is always non-nil.

We check if the head is nil to know if the queue is empty.

3fill in blank

hard

Fix the error in updating the tail pointer after enqueue.

DSA Go

tail = [1]

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

Ahead

BnewNode

Cnil

Dtail.next

Attempts:

3 left

💡 Hint

Common Mistakes

Setting tail to head or nil.

Setting tail to tail.next before linking.

After adding the new node, tail should point to it.

4fill in blank

hard

Fill both blanks to link the new node and update tail correctly.

DSA Go

tail.[1] = [2]

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

Anext

Bhead

CnewNode

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of newNode.

Using prev which is not defined.

We set tail.next to newNode to link it, then update tail to newNode.

5fill in blank

hard

Fill all three blanks to complete the enqueue function using linked list.

DSA Go

func enqueue(value int) {
    newNode := &Node{data: [1], next: nil}
    if [2] == nil {
        head = newNode
        tail = newNode
    } else {
        tail.[3] = newNode
        tail = newNode
    }
}

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

Avalue

Bhead

Cnext

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using tail instead of head in the if condition.

Forgetting to set tail.next to newNode.

The new node stores the value. We check if head is nil to see if queue is empty. Then we link tail.next to newNode.

Practice

1. What does the enqueue operation do in a queue implemented using a linked list?

easy

A. Deletes the last element from the linked list

B. Adds a new element at the end of the linked list

C. Removes the first element from the linked list

D. Checks if the linked list is empty

Solution

1. Step 1: Understand enqueue operation

   Enqueue means adding an element to the queue.

2. Step 2: Enqueue in linked list context

   In a linked list queue, enqueue adds the new node at the end (tail).

3. Final Answer:

   Adds a new element at the end of the linked list -> Option B

4. Quick Check:

   Enqueue = Add at end [OK]

Hint: Enqueue always adds at the tail of the linked list [OK]

Common Mistakes:

• Confusing enqueue with dequeue operation
• Adding element at the head instead of tail
• Thinking enqueue removes elements
• Assuming enqueue checks emptiness

2. Which of the following is the correct syntax to create a new node and enqueue it in Go using a linked list?

easy

A. node := &Node{data: value, next: nil}
queue.tail.next = node
queue.tail = node

B. node := Node{value, nil}
queue.head = node

C. node := &Node{value}
queue.head.next = node

D. node := Node{data: value}
queue.tail = node.next

Solution

1. Step 1: Create new node correctly

   Use pointer to Node with data and next set to nil.

2. Step 2: Link new node at tail and update tail

   Set current tail's next to new node, then update tail pointer.

3. Final Answer:

   node := &Node{data: value, next: nil} queue.tail.next = node queue.tail = node -> Option A

4. Quick Check:

   New node pointer + update tail = A [OK]

Hint: Always use pointer and update tail's next and tail itself [OK]

Common Mistakes:

• Not using pointer for new node
• Assigning new node to head instead of tail
• Forgetting to update tail pointer
• Incorrect struct initialization syntax

3. What will be the state of the queue after executing the following Go code?

type Node struct {
    data int
    next *Node
}

type Queue struct {
    head *Node
    tail *Node
}

func (q *Queue) enqueue(value int) {
    node := &Node{data: value}
    if q.tail == nil {
        q.head = node
        q.tail = node
    } else {
        q.tail.next = node
        q.tail = node
    }
}

func main() {
    q := &Queue{}
    q.enqueue(10)
    q.enqueue(20)
    q.enqueue(30)
    // Print queue
    current := q.head
    for current != nil {
        fmt.Print(current.data, " -> ")
        current = current.next
    }
    fmt.Print("null")
}

medium

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

B. null

C. 10 -> 30 -> 20 -> null

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

Solution

1. Step 1: Enqueue elements in order

   Elements 10, 20, 30 are added at the tail one by one.

2. Step 2: Traverse from head to tail

   Traversal prints nodes in order: 10, then 20, then 30, then null.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option D

4. Quick Check:

   Enqueue order preserved in linked list [OK]

Hint: Enqueue adds at tail, print from head to tail [OK]

Common Mistakes:

• Assuming new elements added at head
• Printing tail to head order
• Forgetting to print 'null' at end
• Confusing enqueue with dequeue output

4. Identify the error in the following Go enqueue function for a linked list queue and select the fix.

func (q *Queue) enqueue(value int) {
    node := &Node{data: value}
    if q.head == nil {
        q.head = node
    } else {
        q.tail.next = node
    }
}

medium

A. Missing update of q.tail to new node after adding

B. Should check q.tail == nil instead of q.head == nil

C. Node should be created without pointer

D. Should assign q.head.next = node instead of q.tail.next

Solution

1. Step 1: Analyze enqueue logic

   Function sets head if empty, else links new node after tail.

2. Step 2: Check tail pointer update

   Function does not update q.tail to new node, so tail remains old node.

3. Final Answer:

   Missing update of q.tail to new node after adding -> Option A

4. Quick Check:

   Update tail pointer after enqueue [OK]

Hint: Always update tail pointer after adding new node [OK]

Common Mistakes:

• Not updating tail pointer after enqueue
• Checking wrong pointer for empty queue
• Creating node without pointer
• Linking new node to head instead of tail

5. You want to implement a queue using a linked list in Go that supports enqueue and dequeue efficiently. Which of the following changes will improve the enqueue operation's time complexity from O(n) to O(1)?

hard

A. Add new nodes at the head instead of the tail

B. Use a doubly linked list instead of singly linked list

C. Maintain a tail pointer to the last node and update it on enqueue

D. Traverse the list to find the last node each time before enqueue

Solution

1. Step 1: Understand enqueue time complexity

   Without tail pointer, enqueue requires traversal to last node, O(n).

2. Step 2: Using tail pointer

   Maintaining tail pointer allows direct access to last node, making enqueue O(1).

3. Final Answer:

   Maintain a tail pointer to the last node and update it on enqueue -> Option C

4. Quick Check:

   Tail pointer reduces enqueue to O(1) [OK]

Hint: Keep tail pointer to avoid traversal on enqueue [OK]

Common Mistakes:

• Thinking doubly linked list alone improves enqueue
• Adding at head breaks queue order
• Traversing list each time causes O(n) complexity
• Ignoring tail pointer update