Enqueue Using Linked List in DSA Go - 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 queue using a linked list in Go. You will create the linked list nodes, keep track of the queue's front and rear, add new elements to the rear (enqueue), and finally print the queue.

📋 What You'll Learn

Create a linked list node struct called Node with an integer data and a pointer to the next node called next.

Create two variables called front and rear to track the start and end of the queue.

Write a function called enqueue that adds a new node with given data to the end of the queue.

Print the queue elements from front to rear.

💡 Why This Matters

🌍 Real World

Queues are used in many real-world systems like customer service lines, task scheduling, and printer job management. Using a linked list allows dynamic queue size without fixed limits.

💼 Career

Understanding how to implement queues with linked lists is fundamental for software engineers working on system design, backend services, and performance-critical applications.

1

Create Node struct and queue pointers

Create a struct called Node with an integer field data and a pointer field next of type *Node. Then create two variables called front and rear of type *Node and set them to nil.

DSA Go

type Node struct {
    data int
    next *Node
}

var front *Node = nil
var rear *Node = nil
// Your code here

Hint

Define the Node struct with data and next. Then declare front and rear as pointers to Node and initialize them to nil.

2

Create enqueue function

Create a function called enqueue that takes an integer parameter value. Inside the function, create a new Node with data set to value and next set to nil. Then add this node to the queue by updating front and rear accordingly.

DSA Go

package main

type Node struct {
    data int
    next *Node
}

var front *Node = nil
var rear *Node = nil

func enqueue(value int) {
    // Your code here
}

func main() {
    // Step 1 setup done
}

Hint

Create a new node with the given value. If the queue is empty (rear == nil), set both front and rear to the new node. Otherwise, link the new node at the end and update rear.

3

Enqueue values into the queue

In the main function, call enqueue three times to add the values 10, 20, and 30 to the queue.

DSA Go

package main

type Node struct {
    data int
    next *Node
}

var front *Node = nil
var rear *Node = nil

func enqueue(value int) {
    newNode := &Node{data: value, next: nil}
    if rear == nil {
        front = newNode
        rear = newNode
    } else {
        rear.next = newNode
        rear = newNode
    }
}

func main() {
    enqueue(10)
    enqueue(20)
    enqueue(30)
    // Your code here
}

Hint

Call enqueue three times with the values 10, 20, and 30 to add them to the queue.

4

Print the queue elements

Write a loop in the main function to print all the elements in the queue from front to rear. Print each data value followed by ->. After the last element, print nil.

DSA Go

package main

type Node struct {
    data int
    next *Node
}

var front *Node = nil
var rear *Node = nil

func enqueue(value int) {
    newNode := &Node{data: value, next: nil}
    if rear == nil {
        front = newNode
        rear = newNode
    } else {
        rear.next = newNode
        rear = newNode
    }
}

func main() {
    enqueue(10)
    enqueue(20)
    enqueue(30)
    current := front
    for current != nil {
        // Your code here
    }
}

Hint

Use a loop starting from front. Print each node's data followed by ->. After the loop, print nil to show the end of the queue.

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