Pop Using Linked List Node in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping the head node?

Consider a singly linked list with nodes containing values 10 -> 20 -> 30 -> null. The pop operation removes the head node and returns the new head. What is the printed state of the list after popping once?

DSA Go

package main

import "fmt"

type Node struct {
    Val  int
    Next *Node
}

func pop(head *Node) *Node {
    if head == nil {
        return nil
    }
    return head.Next
}

func printList(head *Node) string {
    result := ""
    for head != nil {
        result += fmt.Sprintf("%d -> ", head.Val)
        head = head.Next
    }
    result += "null"
    return result
}

func main() {
    head := &Node{Val: 10, Next: &Node{Val: 20, Next: &Node{Val: 30}}}
    head = pop(head)
    fmt.Println(printList(head))
}

A 20 -> 30 -> null

B 30 -> null

C 10 -> 20 -> 30 -> null

D null

💡 Hint

Popping removes the first node and returns the next node as the new head.

The pop function removes the head node (value 10) and returns the next node (value 20) as the new head. The list after popping is 20 -> 30 -> null.

❓ Predict Output

intermediate

What happens when popping an empty list?

Given an empty linked list (head is nil), what is the output of the pop operation and the printed list?

DSA Go

package main

import "fmt"

type Node struct {
    Val  int
    Next *Node
}

func pop(head *Node) *Node {
    if head == nil {
        return nil
    }
    return head.Next
}

func printList(head *Node) string {
    result := ""
    for head != nil {
        result += fmt.Sprintf("%d -> ", head.Val)
        head = head.Next
    }
    result += "null"
    return result
}

func main() {
    var head *Node = nil
    head = pop(head)
    fmt.Println(printList(head))
}

A 0 -> null

B null

C panic: runtime error

D empty list

💡 Hint

Popping an empty list returns nil, so printing shows null.

Since the list is empty (head is nil), popping returns nil. Printing the list shows null.

❓ Predict Output

advanced

What is the output after popping twice from a 3-node list?

Given a linked list 5 -> 15 -> 25 -> null, after popping twice, what is the printed list?

DSA Go

package main

import "fmt"

type Node struct {
    Val  int
    Next *Node
}

func pop(head *Node) *Node {
    if head == nil {
        return nil
    }
    return head.Next
}

func printList(head *Node) string {
    result := ""
    for head != nil {
        result += fmt.Sprintf("%d -> ", head.Val)
        head = head.Next
    }
    result += "null"
    return result
}

func main() {
    head := &Node{Val: 5, Next: &Node{Val: 15, Next: &Node{Val: 25}}}
    head = pop(head)
    head = pop(head)
    fmt.Println(printList(head))
}

A 15 -> 25 -> null

B null

C 25 -> null

D 5 -> 15 -> 25 -> null

💡 Hint

Each pop removes the head node, so after two pops, the head points to the third node.

First pop removes 5, second pop removes 15, so the list starts at 25 -> null.

❓ Predict Output

advanced

What error occurs if pop tries to access Next of nil?

What happens if the pop function is called with a nil head and tries to access head.Next without checking if head is nil?

DSA Go

package main

type Node struct {
    Val  int
    Next *Node
}

func pop(head *Node) *Node {
    return head.Next
}

func main() {
    var head *Node = nil
    head = pop(head)
}

A panic: runtime error: invalid memory address or nil pointer dereference

B returns nil without error

C compilation error: invalid operation

D returns head unchanged

💡 Hint

Accessing a field of nil pointer causes a runtime panic in Go.

Since head is nil, accessing head.Next causes a runtime panic due to nil pointer dereference.

🧠 Conceptual

expert

What is the time complexity of popping the head node in a singly linked list?

Consider a singly linked list with n nodes. What is the time complexity of the pop operation that removes the head node?

A O(n^2) - quadratic time

B O(n) - linear time

C O(log n) - logarithmic time

D O(1) - constant time

💡 Hint

Popping the head only changes the head pointer to the next node.

Removing the head node requires only updating the head pointer, which is a constant time operation O(1).

Practice

1. What does the pop operation do in a linked list when implemented using nodes?

easy

A. Counts the total number of nodes

B. Adds a new node at the end

C. Removes the first node and returns its value

D. Searches for a node with a specific value

Solution

1. Step 1: Understand pop operation in linked list

   Pop means removing the top or first element from the list.

2. Step 2: Identify what happens to the first node

   The first node is removed and its value is returned, updating the head pointer.

3. Final Answer:

   Removes the first node and returns its value -> Option C

4. Quick Check:

   Pop = Remove first node [OK]

Hint: Pop always removes the first node in a linked list [OK]

Common Mistakes:

• Thinking pop adds nodes instead of removing
• Confusing pop with search or count operations
• Removing the last node instead of the first

2. Which of the following is the correct Go syntax to define a node struct for a singly linked list?

easy

A. class Node { int value; Node next; }

B. struct Node { int value; Node* next; }

C. Node := struct { value int; next Node }

D. type Node struct { value int; next *Node }

Solution

1. Step 1: Recall Go struct syntax

   In Go, structs are defined with 'type Name struct { fields }'.

2. Step 2: Check pointer usage for next node

   The next field must be a pointer to Node: '*Node'.

3. Final Answer:

   type Node struct { value int; next *Node } -> Option D

4. Quick Check:

   Go struct with pointer = type Node struct { value int; next *Node } [OK]

Hint: Use 'type' and pointers for linked list nodes in Go [OK]

Common Mistakes:

• Using C/C++ or Java syntax in Go
• Missing pointer '*' for next node
• Trying to declare struct inline incorrectly

3. What will be the output after popping once from the linked list represented by nodes with values 10 -> 20 -> 30 -> null?

medium

A. 20 -> 30 -> null

B. 10 -> 20 -> 30 -> null

C. 30 -> null

D. null

Solution

1. Step 1: Identify the first node value

   The first node has value 10.

2. Step 2: Remove first node and update head

   After popping, head points to node with value 20, so list is 20 -> 30 -> null.

3. Final Answer:

   20 -> 30 -> null -> Option A

4. Quick Check:

   Pop removes 10, new head 20 [OK]

Hint: Pop removes first node, so list starts from second node [OK]

Common Mistakes:

• Not updating head pointer after pop
• Returning the whole list instead of updated list
• Confusing pop with removing last node

4. Given this Go code snippet for pop operation, what is the error?

func pop(head *Node) (*Node, int) {
    if head == nil {
        return nil, 0
    }
    value := head.value
    head = head.next
    return head, value
}

medium

A. It returns wrong value from the node

B. The function does not update the original head pointer outside

C. It causes a runtime panic due to nil dereference

D. The function should return only the value, not the new head

Solution

1. Step 1: Understand pointer behavior in Go

   Assigning 'head = head.next' changes local copy, not original head outside.

2. Step 2: Identify missing pointer update

   The original head pointer outside the function remains unchanged, so pop has no effect.

3. Final Answer:

   The function does not update the original head pointer outside -> Option B

4. Quick Check:

   Local pointer change doesn't affect caller [OK]

Hint: Update original pointer by returning new head or using double pointer [OK]

Common Mistakes:

• Assuming local pointer change updates original
• Ignoring need to return new head
• Not checking for nil before accessing value

5. You have a linked list with nodes 5 -> 15 -> 25 -> 35 -> null. You pop twice and then add a new node with value 45 at the front. What is the final list?

hard

A. 45 -> 25 -> 35 -> null

B. 25 -> 35 -> 45 -> null

C. 45 -> 35 -> null

D. 15 -> 25 -> 35 -> 45 -> null

Solution

1. Step 1: Pop twice from the list

   First pop removes 5, list becomes 15 -> 25 -> 35 -> null. Second pop removes 15, list becomes 25 -> 35 -> null.

2. Step 2: Add new node with value 45 at front

   New node 45 points to current head 25, so list is 45 -> 25 -> 35 -> null.

3. Final Answer:

   45 -> 25 -> 35 -> null -> Option A

4. Quick Check:

   Pop twice then add front = 45 -> 25 -> 35 [OK]

Hint: Pop removes from front; adding front inserts new head [OK]

Common Mistakes:

• Not updating head after each pop
• Adding new node at end instead of front
• Confusing order of operations