Get Length of Linked List in DSA C# - Execution Trace

Concept Flow - Get Length of Linked List

Start at head node

↓

Is current node null?

Yes→Return count

No↓

Increment 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 nodes left.

Execution Sample

DSA C#

int GetLength(Node head) {
  int count = 0;
  Node current = head;
  while (current != null) {
    count++;
    current = current.Next;
  }
  return count;
}

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

Execution Table

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

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

Variable Tracker

Variable	Start	After Step 3	After Step 6	After Step 9	Final
count	0	1	2	3	3
current	Node 1	Node 2	Node 3	null	null

Key Moments - 3 Insights

Why do we check current != null before counting?

Because counting a node only makes sense if the node exists. See execution_table step 2 and 11 where the check stops the loop when current is null.

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

We count the current node first, then move to the next node to continue counting. This order is shown in steps 3 (increment) then 4 (move pointer).

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

The loop never runs because current starts as null. The count remains 0 and is returned immediately, as shown in step 1 and 11.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of count at step 6?

A 1

B 3

C 2

D 0

💡 Hint

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

At which step does current become null, ending the loop?

A Step 11

B Step 10

C Step 9

D Step 12

💡 Hint

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

If the linked list had 5 nodes instead of 3, what would be the final count?

A 5

B 3

C 4

D 6

💡 Hint

Count increments once per node, so final count equals number of nodes.

Concept Snapshot

Get Length of Linked List:
- Start at head node
- While current node is not null:
  - Increment count
  - Move to next node
- Return count
Counts nodes by traversing list from head to end.

Full Transcript

To get the length of a linked list, start at the head node. Check if the current node exists. If yes, increase the count by one. Then move to the next node. Repeat this until the current node is null, meaning the end of the list. Finally, return the count. This method counts each node exactly once by moving through the list step-by-step.

Practice

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

easy

A. The sum of all node values

B. The value of the first node

C. The memory size of the linked list

D. The number of nodes in the linked list

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 is how many nodes are present in the list.

3. Final Answer:

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

4. Quick Check:

   Length = count of nodes [OK]

Hint: Count nodes to get length quickly [OK]

Common Mistakes:

• Confusing length with node values
• Thinking length is memory size
• Assuming length is sum of values

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

easy

A. int length = 0;

B. int length = null;

C. string length = "0";

D. bool length = false;

Solution

1. Step 1: Identify correct data type for counting

   Length is a number, so it should be an integer type.

2. Step 2: Check initialization value

   Start counting from zero before traversing nodes.

3. Final Answer:

   int length = 0; -> Option A

4. Quick Check:

   Use int and start at 0 [OK]

Hint: Use int zero to start counting length [OK]

Common Mistakes:

• Using null for int variable
• Using string instead of int
• Using bool for counting

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

public class Node {
  public int data;
  public Node next;
  public Node(int d) { data = d; next = null; }
}

public class LinkedList {
  public Node head;
  public int GetLength() {
    int count = 0;
    Node current = head;
    while (current != null) {
      count++;
      current = current.next;
    }
    return count;
  }
}

LinkedList list = new LinkedList();
list.head = new Node(5);
list.head.next = new Node(10);
list.head.next.next = new Node(15);
Console.WriteLine(list.GetLength());

medium

A. 0

B. 2

C. 3

D. Error

Solution

1. Step 1: Count nodes in the linked list

   Nodes are 5 -> 10 -> 15, total 3 nodes.

2. Step 2: Trace GetLength method

   Loop increments count for each node until null is reached.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   3 nodes counted = 3 [OK]

Hint: Count each node until null to get length [OK]

Common Mistakes:

• Counting only head node
• Returning zero without counting
• Confusing next pointer with data

4. Identify the error in this C# method to get linked list length:

public int GetLength() {
  int count = 0;
  Node current = head;
  while (current.next != null) {
    count++;
    current = current.next;
  }
  return count;
}

medium

A. It misses counting the last node

B. It causes infinite loop

C. It returns count plus one extra

D. It throws null reference exception

Solution

1. Step 1: Analyze loop condition

   Loop runs while current.next is not null, so last node is skipped.

2. Step 2: Understand counting effect

   Count increments only for nodes before last, missing last node.

3. Final Answer:

   It misses counting the last node -> Option A

4. Quick Check:

   Loop condition excludes last node [OK]

Hint: Use current != null to include last node [OK]

Common Mistakes:

• Using current.next != null instead of current != null
• Not incrementing count for last node
• Assuming loop covers all nodes

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

public int GetEvenLength() {
  int count = 0;
  Node current = head;
  while (current != null) {
    // Your code here
    current = current.next;
  }
  return count;
}

hard

A. Add count++ unconditionally inside the loop

B. Add if (current.data % 2 == 0) count++; inside the loop

C. Add if (current.data % 2 != 0) count++; inside the loop

D. Return head.data instead of count

Solution

1. Step 1: Check node value for evenness

   Use modulo operator to test if data is even (data % 2 == 0).

2. Step 2: Increment count only if node is even

   Inside loop, increment count only when condition is true.

3. Final Answer:

   Add if (current.data % 2 == 0) count++; inside the loop -> Option B

4. Quick Check:

   Count only even nodes [OK]

Hint: Use modulo to filter even nodes before counting [OK]

Common Mistakes:

• Counting all nodes without condition
• Counting odd nodes instead of even
• Returning node data instead of count