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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linked List Length Calculation

What is the output of this C code that calculates the length of a linked list?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 10;
    head->next = malloc(sizeof(struct Node));
    head->next->data = 20;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->data = 30;
    head->next->next->next = NULL;

    printf("Length: %d\n", getLength(head));
    return 0;
}

A Length: 1

B Length: 2

C Length: 0

D Length: 3

💡 Hint

Count each node until you reach NULL.

The linked list has three nodes with data 10, 20, and 30. The function counts each node until it reaches NULL, so the length is 3.

❓ Predict Output

intermediate

Length of Empty Linked List

What is the output of this C code when the linked list is empty (head is NULL)?

DSA C

#include <stdio.h>

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

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

int main() {
    struct Node* head = NULL;
    printf("Length: %d\n", getLength(head));
    return 0;
}

A Length: 1

B Length: 0

C Length: -1

D Segmentation fault

💡 Hint

An empty list has no nodes.

Since head is NULL, the while loop does not run and count remains 0.

🔧 Debug

advanced

Identify the Bug in Length Calculation

What error will this code produce when trying to get the length of the linked list?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 5;
    head->next = NULL;
    printf("Length: %d\n", getLength(head));
    return 0;
}

A Length: 0

B Length: 1

C Segmentation fault

D Infinite loop

💡 Hint

Check the loop condition carefully.

The loop counts nodes only while head->next is not NULL, so it stops before counting the last node. For a single node, count remains 0.

❓ Predict Output

advanced

Output After Adding a Node at the End

What is the output of this code after adding a new node at the end and calculating the length?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

void addNodeEnd(struct Node** head_ref, int new_data) {
    struct Node* new_node = malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    if (*head_ref == NULL) {
        *head_ref = new_node;
        return;
    }
    struct Node* last = *head_ref;
    while (last->next != NULL) {
        last = last->next;
    }
    last->next = new_node;
}

int main() {
    struct Node* head = NULL;
    addNodeEnd(&head, 1);
    addNodeEnd(&head, 2);
    addNodeEnd(&head, 3);
    addNodeEnd(&head, 4);
    printf("Length: %d\n", getLength(head));
    return 0;
}

A Length: 4

B Length: 3

C Length: 5

D Length: 0

💡 Hint

Count all nodes after adding four nodes.

Four nodes are added, so the length is 4.

🧠 Conceptual

expert

Time Complexity of Linked List Length Calculation

What is the time complexity of calculating the length of a singly linked list with n nodes using the standard iterative method?

A O(1) - Constant time

B O(n^2) - Quadratic time

C O(n) - Linear time

D O(log n) - Logarithmic time

💡 Hint

You must visit each node once to count.

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