Get Length of Linked List in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the 'Get Length of Linked List' operation?

It counts how many nodes are in the linked list, telling us the total number of elements stored.

beginner

In a singly linked list, how do you find the length?

Start at the head node, move through each node one by one, and count until you reach the end (nil).

intermediate

Why can't we get the length of a linked list instantly like an array?

Because linked lists don't store their size; we must count nodes by visiting each one.

intermediate

What is the time complexity of getting the length of a linked list?

O(n), where n is the number of nodes, because we visit each node once.

beginner

Show the Go code snippet to get the length of a singly linked list.

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

What does the 'Get Length of Linked List' function return?

A Value of the last node

B Number of nodes in the list

C Pointer to the head node

D Sum of all node values

The function counts and returns how many nodes are in the linked list.

Which of these is the correct way to traverse a linked list to get its length?

A Start at head, move to next node until nil, counting nodes

B Jump directly to the last node

C Use an index to access nodes like an array

D Count nodes backwards from tail

Linked lists must be traversed from head to end, counting each node.

What is the time complexity of finding the length of a linked list with n nodes?

A O(n)

B O(1)

C O(log n)

D O(n^2)

We visit each node once, so time grows linearly with n.

Why can't we get the length of a linked list in O(1) time without extra storage?

A Because linked lists are immutable

B Because nodes are unordered

C Because linked lists do not store their size by default

D Because nodes have no values

Linked lists do not keep track of their length automatically.

In Go, what type should the 'head' parameter have in the GetLength function for a singly linked list?

A []Node

B int

C Node

D *Node

The head is a pointer to the first Node in the list.

Explain step-by-step how to find the length of a singly linked list.

Think about walking through the list like counting people in a line.

Write a simple Go function to get the length of a linked list and explain how it works.

Imagine counting steps until you reach the end.

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