Get Length of Linked List in DSA Javascript

Mental Model

Count how many nodes are in the linked list by moving from the start to the end one by one.

Analogy: Like counting people in a line by asking each person to point to the next until no one is left.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null

Goal: Find how many nodes are in the list

Step 1: start at head node with value 1

head -> [curr->1] -> 2 -> 3 -> null

Why: We begin counting from the first node

Step 2: count 1, move curr to next node with value 2

head -> 1 -> [curr->2] -> 3 -> null

Why: Count current node and move forward to continue counting

Step 3: count 2, move curr to next node with value 3

head -> 1 -> 2 -> [curr->3] -> null

Why: Keep counting nodes until we reach the end

Step 4: count 3, move curr to null (end)

head -> 1 -> 2 -> 3 -> [curr->null]

Why: Stop counting when we reach the end of the list

Result:

head -> 1 -> 2 -> 3 -> null
Length = 3

Annotated Code

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  getLength() {
    let count = 0;
    let curr = this.head;
    while (curr !== null) {
      count++;
      curr = curr.next;
    }
    return count;
  }
}

// Driver code
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
console.log("List length:", list.getLength());

while (curr !== null) {

loop through each node until reaching the end

count++;

increment count for each node visited

curr = curr.next;

move to next node to continue counting

Output

List length: 3

Complexity Analysis

Time: O(n) because we visit each node once to count

Space: O(1) because we use only a few variables regardless of list size

vs Alternative: Better than recursive counting which uses extra call stack space O(n)

Edge Cases

empty list

returns length 0 without error

DSA Javascript

while (curr !== null) {

single node list

returns length 1 correctly

DSA Javascript

while (curr !== null) {

When to Use This Pattern

When you need to know how many items are in a linked list, use a simple traversal counting pattern.

Common Mistakes

Mistake: Forgetting to move to the next node inside the loop causing infinite loop
Fix: Add 'curr = curr.next;' inside the counting loop

Mistake: Starting count at 1 instead of 0 causing off-by-one error
Fix: Initialize count to 0 before counting nodes

Summary

Counts the number of nodes in a linked list by traversing it.

Use when you need to know the size of a linked list.

The key is to move through each node one by one and count them.

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 value of the last node

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 in the list, regardless of their values.

3. Final Answer:

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

4. Quick Check:

   Length = number of nodes [OK]

Hint: Length counts nodes, not values or memory size [OK]

Common Mistakes:

• Confusing length with node values
• Thinking length is memory size
• Counting only first or last node

2. Which of the following JavaScript code snippets correctly initializes a variable to count the length of a linked list?

easy

A. let length = 0;

B. let length = null;

C. let length = undefined;

D. let length = '0';

Solution

1. Step 1: Identify correct initialization for counting

   Counting starts from zero, so length should be a number 0.

2. Step 2: Check variable types

   Using null, undefined, or string '0' is incorrect for numeric counting.

3. Final Answer:

   let length = 0; -> Option A

4. Quick Check:

   Initialize count with 0 [OK]

Hint: Start counting from zero using a number variable [OK]

Common Mistakes:

• Using null or undefined instead of 0
• Using string '0' instead of number 0
• Not initializing length variable

3. What will be the output of the following code?

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

let length = 0;
let current = head;
while (current !== null) {
  length++;
  current = current.next;
}
console.log(length);

medium

A. 3

B. 2

C. 1

D. 0

Solution

1. Step 1: Trace linked list nodes

   Nodes are 1 -> 2 -> 3 -> null, so 3 nodes total.

2. Step 2: Count nodes in while loop

   Loop increments length for each node until current is null, so length becomes 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Count nodes = 3 [OK]

Hint: Count nodes by traversing until null [OK]

Common Mistakes:

• Stopping loop early
• Not incrementing length
• Incorrectly checking current node

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

function getLength(head) {
  let length = 0;
  let current = head;
  while (current.next !== null) {
    length++;
    current = current.next;
  }
  return length;
}

medium

A. The length variable should start at 1, not 0

B. The loop condition should check current !== null, not current.next !== null

C. The function should return current instead of length

D. The current variable should be initialized to null

Solution

1. Step 1: Analyze loop condition

   Checking current.next !== null misses counting the last node.

2. Step 2: Correct loop condition

   Loop should run while current !== null to count all nodes including last.

3. Final Answer:

   The loop condition should check current !== null, not current.next !== null -> Option B

4. Quick Check:

   Loop until current is null to count all nodes [OK]

Hint: Loop until current is null, not current.next [OK]

Common Mistakes:

• Stopping before last node
• Starting length at 1 incorrectly
• Returning wrong variable

5. Given a linked list where each node has a value and a next pointer, how would you modify the length calculation to skip nodes with value 0 and count only nodes with non-zero values?

hard

A. Count all nodes and then subtract the number of zeros found

B. Skip the first node if its value is 0 before starting the loop

C. Set length to the total nodes minus the number of zeros after counting all nodes

D. Increment length only if current.value !== 0 inside the traversal loop

Solution

1. Step 1: Traverse all nodes

   Loop through each node from head to null as usual.

2. Step 2: Count only non-zero value nodes

   Inside loop, increment length only if current.value !== 0 to skip zeros.

3. Final Answer:

   Increment length only if current.value !== 0 inside the traversal loop -> Option D

4. Quick Check:

   Count nodes with value != 0 during traversal [OK]

Hint: Count nodes only if value is not zero during traversal [OK]

Common Mistakes:

• Skipping nodes incorrectly
• Counting all then subtracting zeros
• Modifying list structure