Get Length of Linked List in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the length counter to zero.

DSA C#

int length = [1];

Drag options to blanks, or click blank then click option'

A-1

B1

Cnull

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting length from 1 instead of 0

Using null instead of a number

We start counting length from zero because the list is initially empty.

2fill in blank

medium

Complete the code to move to the next node in the linked list.

DSA C#

current = current.[1];

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next'

Using 'value' which holds data, not the link

To traverse the list, we move from the current node to its next node.

3fill in blank

hard

Fix the error in the while loop condition to correctly traverse the linked list.

DSA C#

while (current [1] null) {
    length++;
    current = current.next;
}

Drag options to blanks, or click blank then click option'

A==

B>

C!=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '!=' in the loop condition

The loop should continue while current is not null, meaning there are nodes left to count.

4fill in blank

hard

Fill both blanks to create a dictionary of node values and their counts for nodes with value greater than 5.

DSA C#

var counts = new Dictionary<int, int>();
while (current != null) {
    if (current.value [1] 5) {
        counts[current.value] = counts.TryGetValue(current.value, out var count) ? count + 1 : 1;
    }
    current = current.[2];
}

Drag options to blanks, or click blank then click option'

A>

B<

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>'

Using 'prev' which is not valid in singly linked list

We check if the node's value is greater than 5 and move to the next node in the list.

5fill in blank

hard

Fill all three blanks to create a dictionary with uppercase keys, values, and filter condition.

DSA C#

var result = new Dictionary<string, int>();
while (current != null) {
    var key = current.value.ToString().ToUpper();
    if (current.value [1] 10) {
        result[[2]] = current.value;
    }
    current = current.[3];
}

Drag options to blanks, or click blank then click option'

A<

Bkey

Cnext

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<'

Using 'value' instead of 'key' for dictionary key

We filter nodes with value less than 10, use the uppercase string key, and move to the next node.

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