Get Length of Linked List in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the length of the linked list after these insertions?

Consider a singly linked list where we insert nodes with values 10, 20, and 30 in that order. What will be the length of the list after these insertions?

DSA Typescript

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

class LinkedList {
  head: Node | null = null;

  insert(value: number) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  getLength(): number {
    let count = 0;
    let current = this.head;
    while (current) {
      count++;
      current = current.next;
    }
    return count;
  }
}

const list = new LinkedList();
list.insert(10);
list.insert(20);
list.insert(30);
console.log(list.getLength());

A 0

B 3

C 2

D 1

💡 Hint

Count each node starting from the head until you reach the end.

Each insertion adds one node at the end. After inserting 10, 20, and 30, the list has 3 nodes. The getLength method counts all nodes by traversing from head to the end.

❓ Predict Output

intermediate

What is the length of an empty linked list?

If you create a new linked list but do not insert any nodes, what will be the length returned by getLength()?

DSA Typescript

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

class LinkedList {
  head: Node | null = null;

  getLength(): number {
    let count = 0;
    let current = this.head;
    while (current) {
      count++;
      current = current.next;
    }
    return count;
  }
}

const list = new LinkedList();
console.log(list.getLength());

A undefined

B 1

C null

D 0

💡 Hint

No nodes means length is zero.

Since no nodes are inserted, the head is null and the traversal loop does not run. The count remains zero.

🔧 Debug

advanced

Why does this getLength method return 0 even after insertions?

The following code inserts nodes but getLength always returns 0. What is the bug?

DSA Typescript

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

class LinkedList {
  head: Node | null = null;

  insert(value: number) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  getLength(): number {
    let count = 0;
    let current = null;
    while (current) {
      count++;
      current = current.next;
    }
    return count;
  }
}

const list = new LinkedList();
list.insert(5);
list.insert(15);
console.log(list.getLength());

A The getLength method initializes current to null instead of head.

B The while loop condition should be current.next instead of current.

C The Node constructor does not set next to null.

D The insert method does not update the head correctly.

💡 Hint

Check where the traversal starts in getLength.

The getLength method sets current = null instead of current = this.head. So the while loop never runs and count stays zero.

🧠 Conceptual

advanced

What is the time complexity of getLength in a singly linked list?

Given a singly linked list with n nodes, what is the time complexity of the getLength method that counts nodes by traversing the list?

A O(log n)

B O(1)

C O(n)

D O(n^2)

💡 Hint

The method visits each node once.

The getLength method visits each node exactly once, so the time grows linearly with the number of nodes.

🚀 Application

expert

What is the length of the linked list after these operations?

Starting with an empty linked list, perform these operations in order: 1. Insert 1 2. Insert 2 3. Insert 3 4. Remove the head node 5. Insert 4 What is the length of the linked list now?

DSA Typescript

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

class LinkedList {
  head: Node | null = null;

  insert(value: number) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  removeHead() {
    if (this.head) {
      this.head = this.head.next;
    }
  }

  getLength(): number {
    let count = 0;
    let current = this.head;
    while (current) {
      count++;
      current = current.next;
    }
    return count;
  }
}

const list = new LinkedList();
list.insert(1);
list.insert(2);
list.insert(3);
list.removeHead();
list.insert(4);
console.log(list.getLength());

A 3

B 4

C 2

D 1

💡 Hint

Track the list nodes after each operation carefully.

After inserting 1,2,3 the list length is 3. Removing head removes node with value 1, length becomes 2. Inserting 4 adds one node, length becomes 3.

Practice

1. What does the function getLength(head: ListNode | null): number typically return when given the head of a linked list?

easy

A. The last node in the linked list

B. The number of nodes in the linked list

C. The value of the first node

D. The sum of all node values

Solution

1. Step 1: Understand the function purpose

   The function named getLength is designed to count nodes, so it returns the number of nodes in the list.

2. Step 2: Confirm what is returned

   Since it counts nodes, it returns the total count, not values or nodes themselves.

3. Final Answer:

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

4. Quick Check:

   Function name and return type indicate count [OK]

Hint: Function named getLength returns count of nodes [OK]

Common Mistakes:

• Confusing length with node value
• Thinking it returns the last node
• Assuming it sums node values

2. Which of the following TypeScript code snippets correctly initializes a variable count to start counting nodes in a linked list?

easy

A. let count = 0;

B. let count = null;

C. let count = head;

D. let count = undefined;

Solution

1. Step 1: Identify the correct initial value for counting

   Counting nodes requires a number starting at zero, so count should be initialized to 0.

2. Step 2: Check other options

   Initializing to null, head, or undefined is incorrect for counting.

3. Final Answer:

   let count = 0; -> Option A

4. Quick Check:

   Counting starts at zero [OK]

Hint: Start counting nodes from zero [OK]

Common Mistakes:

• Initializing count to null or undefined
• Using head node as count
• Not initializing count at all

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

class ListNode {
  val: number;
  next: ListNode | null;
  constructor(val: number) {
    this.val = val;
    this.next = null;
  }
}

function getLength(head: ListNode | null): number {
  let count = 0;
  let current = head;
  while (current !== null) {
    count++;
    current = current.next;
  }
  return count;
}

const node1 = new ListNode(10);
const node2 = new ListNode(20);
const node3 = new ListNode(30);
node1.next = node2;
node2.next = node3;

console.log(getLength(node1));

medium

A. 3

B. 2

C. 0

D. Error

Solution

1. Step 1: Trace the linked list nodes

   There are three nodes linked: node1 -> node2 -> node3 -> null.

2. Step 2: Count nodes in the while loop

   The loop increments count for each node until current is null, so count becomes 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   3 nodes counted [OK]

Hint: Count increments once per node until null [OK]

Common Mistakes:

• Counting only 2 nodes by missing last
• Returning zero if loop not entered
• Syntax errors causing runtime error

4. Identify the error in this TypeScript function to get linked list length:

function getLength(head: ListNode | null): number {
  let count = 0;
  let current = head;
  while (current.next !== null) {
    count++;
    current = current.next;
  }
  return count;
}

medium

A. It counts nodes twice

B. It will cause an infinite loop

C. It throws a syntax error

D. It misses counting the last node

Solution

1. Step 1: Analyze the while loop condition

   The loop runs while current.next !== null, so it stops before the last node.

2. Step 2: Understand counting effect

   Because the last node's next is null, it is not counted, so length is one less than actual.

3. Final Answer:

   It misses counting the last node -> Option D

4. Quick Check:

   Loop condition excludes last node [OK]

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

Common Mistakes:

• Using current.next in loop condition
• Not counting last node
• Assuming loop counts all nodes

5. Given a linked list where each node has a val and next, how would you modify the getLength function to return 0 if the list is empty and the correct length otherwise?

hard

A. Return length as 1 if head is null

B. Start count at 1 and loop while current is not null

C. Check if head is null before loop; return 0 if true, else count nodes

D. Use a for loop from 0 to head.val

Solution

1. Step 1: Handle empty list case

   Check if head is null before counting; if yes, return 0 immediately.

2. Step 2: Count nodes if list is not empty

   If head is not null, loop through nodes incrementing count until current is null.

3. Final Answer:

   Check if head is null before loop; return 0 if true, else count nodes -> Option C

4. Quick Check:

   Empty list returns 0, else counts nodes [OK]

Hint: Return 0 if head is null before counting [OK]

Common Mistakes:

• Starting count at 1 incorrectly
• Returning 1 for empty list
• Using node value instead of node presence