Get Length of Linked List in DSA Javascript - Execution Trace

Concept Flow - Get Length of Linked List

Start at head node

↓

Is current node null?

Yes→Stop, length found

No↓

Increment length count

↓

Move to next node

↩Back to check current node

Start from the head node, check if current node exists, count it, move to next, repeat until no node left.

Execution Sample

DSA Javascript

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

Counts nodes in a linked list by moving from head to end, incrementing length each step.

Execution Table

Step	Operation	Current Node	Length Count	Pointer Changes	Visual State
1	Start at head	Node(1)	0	current = head	1 -> 2 -> 3 -> null
2	Check current != null	Node(1)	0	No change	1 -> 2 -> 3 -> null
3	Increment length	Node(1)	1	No change	1 -> 2 -> 3 -> null
4	Move to next node	Node(2)	1	current = current.next	1 -> 2 -> 3 -> null
5	Check current != null	Node(2)	1	No change	1 -> 2 -> 3 -> null
6	Increment length	Node(2)	2	No change	1 -> 2 -> 3 -> null
7	Move to next node	Node(3)	2	current = current.next	1 -> 2 -> 3 -> null
8	Check current != null	Node(3)	2	No change	1 -> 2 -> 3 -> null
9	Increment length	Node(3)	3	No change	1 -> 2 -> 3 -> null
10	Move to next node	null	3	current = current.next	1 -> 2 -> 3 -> null
11	Check current != null	null	3	No change	1 -> 2 -> 3 -> null
12	Stop, return length	null	3	No change	1 -> 2 -> 3 -> null

💡 current becomes null at step 10, loop ends, length 3 returned

Variable Tracker

Variable	Start	After Step 4	After Step 7	After Step 10	Final
current	Node(1)	Node(2)	Node(3)	null	null
length	0	1	2	3	3

Key Moments - 3 Insights

Why do we check if current is null before counting?

Because at step 2 and similar checks, if current is null, it means we reached the end and should stop counting to avoid errors.

Why do we move current to current.next after incrementing length?

At steps 4, 7, and 10, moving current to next node lets us visit all nodes one by one until none remain.

What happens if the linked list is empty (head is null)?

At step 2, current is null immediately, so the loop never runs and length stays 0, correctly showing empty list length.

Visual Quiz - 3 Questions

Look at the execution table, what is the length count at step 6?

A 2

B 1

C 3

D 0

💡 Hint

Check the 'Length Count' column at step 6 in the execution_table.

At which step does current become null?

A Step 12

B Step 11

C Step 10

D Step 9

💡 Hint

Look at the 'Current Node' column to see when it changes to null.

If the linked list had only one node, what would length be after step 3?

A 0

B 1

C 2

D null

💡 Hint

Refer to the variable_tracker for length increments after first node count.

Concept Snapshot

Get Length of Linked List:
- Start at head node
- While current node is not null:
  - Increment length
  - Move to next node
- Return length
Counts nodes by visiting each once until end.

Full Transcript

To get the length of a linked list, start at the head node. Check if the current node exists. If yes, add one to the length count. Then move to the next node. Repeat this until the current node is null, which means the end of the list. The length count at this point is the total number of nodes in the list. If the list is empty, the length is zero because the head is null and the loop never runs.

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