Insert at End Tail Insert in DSA Go - Build from Scratch

Insert at End Tail Insert

📖 Scenario: You are managing a simple list of tasks to do. Each task is stored as a node in a linked list. You want to add new tasks at the end of the list so that tasks are done in the order they are added.

🎯 Goal: Build a singly linked list in Go and write code to insert new nodes at the end (tail) of the list.

📋 What You'll Learn

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

Create a variable head to represent the start of the linked list, initially nil.

Create a function insertAtEnd that takes a pointer to the head node and an integer value, and inserts a new node with that value at the end of the list.

Print the linked list after inserting nodes to show the order of nodes.

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like task scheduling, undo functionality, and managing playlists where order matters and dynamic insertion is needed.

💼 Career

Understanding linked lists and how to insert nodes at the tail is a fundamental skill for software developers, especially for roles involving system design, embedded systems, and performance-critical applications.

1

Create the Node struct and head pointer

Create a struct called Node with an int field named data and a pointer to Node named next. Then create a variable head of type *Node and set it to nil.

DSA Go

type Node struct {
    data int
    next *Node
}

var head *Node = nil
// Your code here

Hint

Define the struct with the fields exactly as data int and next *Node. Then declare head as a pointer to Node and assign nil.

2

Create the insertAtEnd function

Write a function called insertAtEnd that takes two parameters: head of type *Node and value of type int. The function should return *Node. Inside, create a new node with data set to value and next set to nil. If head is nil, return the new node. Otherwise, use a for loop with a variable current to find the last node and set its next to the new node. Return the original head.

DSA Go

package main

type Node struct {
    data int
    next *Node
}

var head *Node = nil

func insertAtEnd(head *Node, value int) *Node {
    // Your code here
}

func main() {
    // Starting point
}

Hint

Create the new node with the given value. If the list is empty, return the new node as head. Otherwise, loop to the last node and link the new node there.

3

Insert nodes into the linked list

In the main function, update the global head variable by calling insertAtEnd with head and the values 10, 20, and 30 in that order.

DSA Go

package main

type Node struct {
    data int
    next *Node
}

var head *Node = nil

func insertAtEnd(head *Node, value int) *Node {
    newNode := &Node{data: value, next: nil}
    if head == nil {
        return newNode
    }
    current := head
    for current.next != nil {
        current = current.next
    }
    current.next = newNode
    return head
}

func main() {
    head = insertAtEnd(head, 10)
    head = insertAtEnd(head, 20)
    head = insertAtEnd(head, 30)
    // Your code here
}

Hint

Call insertAtEnd three times with the values 10, 20, and 30, updating the head each time.

4

Print the linked list

Write a for loop in main that uses a variable current starting at head. Loop while current is not nil. Inside the loop, print current.data followed by " -> ". After the loop, print "nil".

DSA Go

Hint

Use a loop to print each node's data followed by " -> ". After the loop, print "nil" to show the end.

Practice

1. What does the "Insert at End (Tail Insert)" operation do in a singly linked list?

easy

A. Deletes the last node of the list

B. Adds a new node at the beginning of the list

C. Adds a new node at the end of the list

D. Deletes the first node of the list

Solution

1. Step 1: Understand the operation name

   "Insert at End" means adding a new element at the tail or last position of the list.

2. Step 2: Compare with other options

   Adding at the beginning is different, and deleting nodes is not insertion.

3. Final Answer:

   Adds a new node at the end of the list -> Option C

4. Quick Check:

   Insert at End = Add node at tail [OK]

Hint: Tail insert means add new node after last node [OK]

Common Mistakes:

• Confusing insert at end with insert at beginning
• Thinking it deletes nodes
• Assuming it inserts in the middle

2. Which of the following is the correct syntax to create a new node and insert it at the end in Go for a singly linked list?

easy

A. newNode := Node{value, nil}

B. newNode := &Node{data: value, next: nil}

C. newNode := &Node{value}

D. newNode := Node{data: value}

Solution

1. Step 1: Understand Go struct initialization

   In Go, to create a pointer to a struct with named fields, use &Node{field: value, ...}.

2. Step 2: Check each option

   newNode := &Node{data: value, next: nil} correctly uses &Node with named fields and sets next to nil for tail node.

3. Final Answer:

   newNode := &Node{data: value, next: nil} -> Option B

4. Quick Check:

   Pointer to struct with named fields = newNode := &Node{data: value, next: nil} [OK]

Hint: Use &Node{field: val, next: nil} to create tail node [OK]

Common Mistakes:

• Missing & to create pointer
• Not setting next to nil for tail
• Using unnamed fields incorrectly

3. What will be the printed linked list after inserting 4 at the end of the list 1 -> 2 -> 3 -> nil using tail insert?

medium

A. 1 -> 2 -> 3 -> 4 -> nil

B. 4 -> 1 -> 2 -> 3 -> nil

C. 1 -> 2 -> 4 -> 3 -> nil

D. 1 -> 2 -> 3 -> nil

Solution

1. Step 1: Understand tail insert effect

   Inserting 4 at the end adds it after 3, so list becomes 1 -> 2 -> 3 -> 4 -> nil.

2. Step 2: Compare options

   Only 1 -> 2 -> 3 -> 4 -> nil shows 4 at the end; others show wrong order or no change.

3. Final Answer:

   1 -> 2 -> 3 -> 4 -> nil -> Option A

4. Quick Check:

   Tail insert adds node at end [OK]

Hint: Tail insert appends new node after last node [OK]

Common Mistakes:

• Inserting at beginning instead of end
• Inserting in the middle
• Not updating last node's next pointer

4. Given the following Go code snippet for tail insertion, what is the error?

func InsertAtEnd(head *Node, value int) *Node {
    newNode := &Node{data: value, next: nil}
    if head == nil {
        head = newNode
    } else {
        temp := head
        for temp.next != nil {
            temp = temp.next
        }
        temp = newNode
    }
    return head
}

medium

A. temp = newNode does not link newNode to the list

B. head is not updated when list is empty

C. newNode is not created properly

D. Loop condition should be temp != nil

Solution

1. Step 1: Analyze the loop and insertion

   The loop finds the last node (temp.next == nil). Then temp = newNode only changes temp pointer, not the last node's next.

2. Step 2: Identify correct linking

   To insert, we must set temp.next = newNode, not temp = newNode.

3. Final Answer:

   temp = newNode does not link newNode to the list -> Option A

4. Quick Check:

   Link last node's next to newNode [OK]

Hint: Set lastNode.next = newNode, not lastNode = newNode [OK]

Common Mistakes:

• Assigning newNode to temp instead of temp.next
• Not handling empty list correctly
• Wrong loop condition

5. You have a singly linked list and want to insert multiple values [5, 10, 15] at the end one by one using tail insert. Which approach is most efficient?

hard

A. Traverse from head to end for each insertion

B. Create a new list for each value and merge later

C. Insert each new node at the beginning

D. Keep a tail pointer to last node and update it on each insert

Solution

1. Step 1: Understand repeated tail insert cost

   Traversing from head to end for each insert is costly (O(n) per insert), total O(n^2).

2. Step 2: Use tail pointer optimization

   Keeping a tail pointer allows direct access to last node, so insertion is O(1) each, total O(n).

3. Final Answer:

   Keep a tail pointer to last node and update it on each insert -> Option D

4. Quick Check:

   Tail pointer reduces insertion time [OK]

Hint: Use tail pointer to avoid full traversal each insert [OK]

Common Mistakes:

• Traversing full list every time
• Inserting at beginning instead of end
• Creating multiple lists unnecessarily