Get Length of Linked List in DSA Go - Time & Space Complexity

Time Complexity: Get Length of Linked List

O(n)

Understanding Time Complexity

We want to understand how the time to find the length of a linked list changes as the list grows.

How does the number of steps grow when the list gets longer?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func getLength(head *Node) int {
    length := 0
    current := head
    for current != nil {
        length++
        current = current.Next
    }
    return length
}
    

This code counts how many nodes are in a linked list by moving from the first node to the end.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The loop that moves through each node one by one.
• How many times: Once for every node in the list until the end.

How Execution Grows With Input

As the list gets longer, the number of steps grows directly with the number of nodes.

Input Size (n)	Approx. Operations
10	10 steps
100	100 steps
1000	1000 steps

Pattern observation: The steps increase evenly as the list size increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the length grows in direct proportion to the number of nodes in the list.

Common Mistake

[X] Wrong: "Getting the length is a constant time operation because we just count once."

[OK] Correct: We must visit each node to count it, so the time grows with the list size, not fixed.

Interview Connect

Understanding this helps you explain how simple list operations scale and shows you can analyze basic loops well.

Self-Check

"What if the linked list stored its length as a variable updated on insert/delete? How would the time complexity change?"

Practice

1. What does the length of a linked list represent?

easy

A. The memory size of the linked list

B. The value of the first node

C. The number of nodes in the linked list

D. The sum of all node values

Solution

1. Step 1: Understand linked list structure

   A linked list is made of nodes connected one after another.

2. Step 2: Define length meaning

   The length counts how many nodes are present in the list.

3. Final Answer:

   The number of nodes in the linked list -> Option C

4. Quick Check:

   Length = count of nodes [OK]

Hint: Length means count nodes, not values or memory [OK]

Common Mistakes:

• Confusing length with sum of values
• Thinking length is memory size
• Using first node value as length

2. Which Go code snippet correctly initializes a variable to count the length of a linked list?

easy

A. length := 0

B. length := nil

C. length := "0"

D. length := false

Solution

1. Step 1: Identify correct variable type for counting

   Length is a number, so it should be an integer starting at zero.

2. Step 2: Check Go syntax for initialization

   Using length := 0 correctly declares an int variable with zero value.

3. Final Answer:

   length := 0 -> Option A

4. Quick Check:

   Count variable starts at 0 [OK]

Hint: Count starts at zero as int, not nil or string [OK]

Common Mistakes:

• Using nil instead of zero
• Using string "0" instead of int 0
• Using boolean false instead of number

3. What is the output of this Go code that counts the length of a linked list?

type Node struct {
    value int
    next  *Node
}

func getLength(head *Node) int {
    length := 0
    current := head
    for current != nil {
        length++
        current = current.next
    }
    return length
}

// Linked list: 10 -> 20 -> 30 -> nil
head := &Node{10, &Node{20, &Node{30, nil}}}
fmt.Println(getLength(head))

medium

A. 2

B. 3

C. 0

D. Runtime error

Solution

1. Step 1: Trace the loop through nodes

   Start at head (10), count 1, move to next (20), count 2, move to next (30), count 3, next is nil, stop.

2. Step 2: Return the count

   The loop counted 3 nodes, so length is 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Nodes counted = 3 [OK]

Hint: Count increments once per node until nil [OK]

Common Mistakes:

• Stopping loop too early
• Not incrementing length inside loop
• Confusing nil check

4. Find the error in this Go function that tries to get the length of a linked list:

func getLength(head *Node) int {
    length := 0
    for head.next != nil {
        length++
        head = head.next
    }
    return length
}

medium

A. It misses counting the last node

B. It causes a nil pointer dereference

C. It counts nodes twice

D. It returns length as a string

Solution

1. Step 1: Analyze loop condition

   The loop runs while head.next != nil, so it stops before the last node.

2. Step 2: Check counting logic

   Since last node's next is nil, it is not counted, so length is one less than actual.

3. Final Answer:

   It misses counting the last node -> Option A

4. Quick Check:

   Loop condition excludes last node [OK]

Hint: Loop until current != nil to count all nodes [OK]

Common Mistakes:

• Using head.next != nil instead of head != nil
• Not counting last node
• Assuming loop covers all nodes

5. Given a linked list where each node contains an integer, how would you modify the length function to count only nodes with even values?

func getLength(head *Node) int {
    length := 0
    current := head
    for current != nil {
        // Your condition here
        current = current.next
    }
    return length
}

hard

A. Return length without any loop

B. Increment length unconditionally inside the loop

C. Check if current.value > 0 before incrementing length

D. Add if current.value%2 == 0 { length++ } inside the loop

Solution

1. Step 1: Add condition to count only even values

   Inside the loop, check if current.value is divisible by 2 (even).

2. Step 2: Increment length only if condition is true

   Use if current.value%2 == 0 { length++ } to count even nodes.

3. Final Answer:

   Add if current.value%2 == 0 { length++ } inside the loop -> Option D

4. Quick Check:

   Count only even nodes [OK]

Hint: Use modulo 2 check inside loop to count even nodes [OK]

Common Mistakes:

• Counting all nodes without condition
• Checking wrong condition like > 0
• Skipping loop entirely