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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the length of the linked list after insertion?

Consider the following C++ code that inserts nodes into a singly linked list. What will be the length of the list after all insertions?

DSA C++

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

int getLength(Node* head) {
    int count = 0;
    Node* current = head;
    while (current != nullptr) {
        count++;
        current = current->next;
    }
    return count;
}

int main() {
    Node* head = nullptr;
    head = new Node(10);
    head->next = new Node(20);
    head->next->next = new Node(30);
    int length = getLength(head);
    std::cout << length << std::endl;
    return 0;
}

A 3

B 2

C 4

D 0

💡 Hint

Count how many nodes are linked starting from head.

The list has three nodes: 10 -> 20 -> 30 -> null. The getLength function counts each node until it reaches null, so the length is 3.

❓ Predict Output

intermediate

What is the output length after deleting a node?

Given the linked list and the code below, what is the length printed after deleting the second node?

DSA C++

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

int getLength(Node* head) {
    int count = 0;
    Node* current = head;
    while (current != nullptr) {
        count++;
        current = current->next;
    }
    return count;
}

int main() {
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    // Delete second node
    Node* temp = head->next;
    head->next = head->next->next;
    delete temp;
    int length = getLength(head);
    std::cout << length << std::endl;
    return 0;
}

A 2

B 3

C 1

D 0

💡 Hint

After deletion, count remaining nodes.

Initially, the list has 3 nodes: 1 -> 2 -> 3. After deleting the second node (2), the list becomes 1 -> 3 -> null, so length is 2.

❓ Predict Output

advanced

What is the length output of this recursive length function?

What will be the output of the following C++ code that calculates the length of a linked list recursively?

DSA C++

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

int getLengthRecursive(Node* head) {
    if (head == nullptr) return 0;
    return 1 + getLengthRecursive(head->next);
}

int main() {
    Node* head = new Node(5);
    head->next = new Node(10);
    head->next->next = new Node(15);
    head->next->next->next = new Node(20);
    std::cout << getLengthRecursive(head) << std::endl;
    return 0;
}

A 3

B 4

C 5

D 0

💡 Hint

Count nodes recursively until nullptr.

The list has four nodes: 5 -> 10 -> 15 -> 20 -> null. The recursive function adds 1 for each node until it reaches null, so output is 4.

🧠 Conceptual

advanced

What is the time complexity of getting the length of a singly linked list?

If you have a singly linked list with n nodes, what is the time complexity of a function that counts the number of nodes by traversing the list once?

A O(1)

B O(n^2)

C O(log n)

D O(n)

💡 Hint

Think about how many nodes you visit to count length.

To count nodes, you must visit each node once, so time complexity is linear, O(n).

🔧 Debug

expert

Why does this getLength function return an incorrect length?

Examine the following code. It is intended to return the length of a linked list but returns an incorrect length. What is the cause?

DSA C++

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

int getLength(Node* head) {
    int count = 0;
    while (head->next != nullptr) {
        count++;
        head = head->next;
    }
    return count;
}

int main() {
    Node* head = new Node(1);
    head->next = new Node(2);
    std::cout << getLength(head) << std::endl;
    return 0;
}

A The function causes a null pointer dereference because head is nullptr initially.

B The function has an infinite loop because head is never updated.

C The function does not count the last node because it stops when head->next is nullptr.

D The function counts nodes twice causing an incorrect length.

💡 Hint

Check the loop condition and what nodes are counted.

The loop stops when head->next is nullptr, so it does not count the last node. This causes the length to be one less than actual. In the example, the list 1 -> 2 -> null returns 1 instead of 2.

Practice

1. What does the function getLength do when given the head of a linked list?

easy

A. Deletes the linked list

B. Returns the value of the first node

C. Returns the number of nodes in the linked list

D. Returns the last node of the linked list

Solution

1. Step 1: Understand the function purpose

   The function getLength counts nodes starting from the head until the end.

2. Step 2: Identify the output

   It returns the total count of nodes, which is the length of the linked list.

3. Final Answer:

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

4. Quick Check:

   Counting nodes = length [OK]

Hint: Count nodes one by one until null [OK]

Common Mistakes:

• Confusing length with node value
• Trying to delete nodes instead of counting
• Returning the last node instead of count

2. Which of the following is the correct syntax to initialize a pointer to the head of a linked list in C++?

easy

A. Node* head = NULL;

B. Node head = NULL;

C. Node* head = 0;

D. Node head = 0;

Solution

1. Step 1: Understand pointer initialization

   In C++, a pointer to a node is declared as Node* and can be initialized to NULL or nullptr.

2. Step 2: Check each option

   Node* head = NULL; uses Node* head = NULL; which is correct pointer initialization syntax.

3. Final Answer:

   Node* head = NULL; -> Option A

4. Quick Check:

   Pointer declaration uses * and NULL [OK]

Hint: Use * for pointers and NULL for empty [OK]

Common Mistakes:

• Declaring pointer without *
• Assigning NULL to non-pointer variable
• Using 0 instead of NULL (less clear)

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

struct Node {
  int data;
  Node* next;
};

int getLength(Node* head) {
  int count = 0;
  while (head != NULL) {
    count++;
    head = head->next;
  }
  return count;
}

int main() {
  Node n3 = {30, NULL};
  Node n2 = {20, &n3};
  Node n1 = {10, &n2};
  int length = getLength(&n1);
  std::cout << length;
  return 0;
}

medium

A. 3

B. 2

C. 1

D. 0

Solution

1. Step 1: Trace the linked list nodes

   The list has nodes n1 -> n2 -> n3 -> NULL, so total 3 nodes.

2. Step 2: Count nodes in getLength

   The function counts each node until NULL, so count becomes 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   3 nodes counted = 3 [OK]

Hint: Count nodes by following next pointers until NULL [OK]

Common Mistakes:

• Counting only first node
• Off-by-one error in loop
• Confusing data values with count

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

int getLength(Node* head) {
  int count = 0;
  while (head->next != NULL) {
    count++;
    head = head->next;
  }
  return count;
}

medium

A. It causes a segmentation fault

B. It misses counting the last node

C. It counts nodes twice

D. It returns the data of the last node

Solution

1. Step 1: Analyze the loop condition

   The loop runs while head->next != NULL, so it stops before the last node.

2. Step 2: Check counting logic

   Since last node is not counted, the returned count is one less than actual length.

3. Final Answer:

   It misses counting the last node -> Option B

4. Quick Check:

   Loop condition excludes last node [OK]

Hint: Use while(head != NULL) to count all nodes [OK]

Common Mistakes:

• Using head->next in loop condition
• Not counting last node
• Confusing node data with count

5. Given a linked list where each node contains an integer, how would you modify the getLength function to return the length only if all node values are positive? If any node has zero or negative value, return -1.

hard

A. Count nodes normally and ignore values

B. Return -1 if list is empty, else return length

C. Return length only if first node is positive

D. Traverse nodes, if value <= 0 return -1, else count nodes and return count

Solution

1. Step 1: Traverse each node checking value

   While moving through the list, check if node's data is <= 0; if yes, return -1 immediately.

2. Step 2: Count nodes if all values positive

   If all nodes have positive values, count them and return the count as length.

3. Final Answer:

   Traverse nodes, if value <= 0 return -1, else count nodes and return count -> Option D

4. Quick Check:

   Check values during count, return -1 if any non-positive [OK]

Hint: Check values while counting, stop early if non-positive [OK]

Common Mistakes:

• Ignoring node values during count
• Checking only first node value
• Returning length even if negative values exist