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→Stop, length counted

No↓

Increment length 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 more nodes.

Execution Sample

DSA C

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

Counts nodes in a linked list by traversing from head to end.

Execution Table

Step	Operation	Current Node	Length Count	Pointer Changes	Visual State
1	Start at head	Node1	0	current = head	Node1 -> Node2 -> Node3 -> NULL
2	Check current != NULL	Node1	0	None	Node1 -> Node2 -> Node3 -> NULL
3	Increment length	Node1	1	None	Node1 -> Node2 -> Node3 -> NULL
4	Move to next node	Node2	1	current = current->next	Node1 -> Node2 -> Node3 -> NULL
5	Check current != NULL	Node2	1	None	Node1 -> Node2 -> Node3 -> NULL
6	Increment length	Node2	2	None	Node1 -> Node2 -> Node3 -> NULL
7	Move to next node	Node3	2	current = current->next	Node1 -> Node2 -> Node3 -> NULL
8	Check current != NULL	Node3	2	None	Node1 -> Node2 -> Node3 -> NULL
9	Increment length	Node3	3	None	Node1 -> Node2 -> Node3 -> NULL
10	Move to next node	NULL	3	current = current->next	Node1 -> Node2 -> Node3 -> NULL
11	Check current != NULL	NULL	3	None	Node1 -> Node2 -> Node3 -> NULL
12	Stop traversal	NULL	3	None	Final length = 3

💡 current becomes NULL at step 11, loop ends, length counted as 3

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
length	0	1	2	3	3
current	Node1	Node2	Node3	NULL	NULL

Key Moments - 3 Insights

Why do we check current != NULL before counting length?

Because if current is NULL, it means we reached the end of the list and there are no more nodes to count. See execution_table step 11 where current is NULL and loop stops.

Why do we move current to current->next after incrementing length?

We count the current node first, then move to the next node to continue counting. This order ensures no node is skipped. See execution_table steps 3 and 4.

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

The loop never runs because current starts as NULL. Length remains 0. This is shown by the loop condition failing immediately at step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the length count at step 6?

A 1

B 2

C 3

D 0

💡 Hint

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

At which step does the current pointer become NULL?

A Step 9

B Step 11

C Step 10

D Step 12

💡 Hint

Look at the 'Current Node' column to see when it changes to NULL.

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

A 5

B 4

C 3

D 6

💡 Hint

Length equals the number of nodes counted, so final length matches node count.

Concept Snapshot

Get Length of Linked List:
- Start at head node
- While current node is not NULL:
  - Increment length
  - Move to next node
- Stop when current is NULL
- Return length counted

Full Transcript

To get the length of a linked list, start from the head node. Check if the current node exists. If yes, increase the length count by one. Then move to the next node. Repeat this until you reach a node that is NULL, which means the end of the list. The length count at this point is the total number of nodes in the list.

Practice

1. What does the function to get the length of a linked list typically do?

easy

A. Reverses the linked list

B. Deletes all nodes in the linked list

C. Finds the maximum value stored in the linked list

D. Counts the number of nodes by traversing from head to end

Solution

1. Step 1: Understand the linked list traversal

   The function starts at the head node and moves through each node until it reaches the end (null).

2. Step 2: Count each node visited

   Each time the function moves to the next node, it increases a counter by one.

3. Final Answer:

   Counts the number of nodes by traversing from head to end -> Option D

4. Quick Check:

   Length = number of nodes visited [OK]

Hint: Count nodes while moving from head to null [OK]

Common Mistakes:

• Confusing length with maximum value
• Trying to reverse the list instead
• Not traversing all nodes

2. Which of the following is the correct C syntax to declare a pointer to the head of a linked list node named head?

easy

A. struct Node* head;

B. struct Node &head;

C. Node head*;

D. struct Node head;

Solution

1. Step 1: Recall pointer declaration in C

   To declare a pointer to a struct Node, use struct Node* variableName;.

2. Step 2: Match with options

   struct Node* head; correctly declares head as a pointer to struct Node.

3. Final Answer:

   struct Node* head; -> Option A

4. Quick Check:

   Pointer syntax uses * after type [OK]

Hint: Pointer declaration uses * after type name [OK]

Common Mistakes:

• Forgetting the * for pointer
• Using & which is reference in C++ not C
• Incorrect order of * and variable name

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

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

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

int main() {
    struct Node n3 = {30, NULL};
    struct Node n2 = {20, &n3};
    struct Node n1 = {10, &n2};
    printf("%d", getLength(&n1));
    return 0;
}

medium

A. 3

B. 2

C. 1

D. 0

Solution

1. Step 1: Analyze linked list nodes

   There are three nodes: n1 -> n2 -> n3 -> NULL.

2. Step 2: Count nodes in getLength function

   The function counts each node until it reaches NULL, so count = 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   3 nodes counted from head to end [OK]

Hint: Count nodes until next is NULL [OK]

Common Mistakes:

• Counting only head node
• Off-by-one error in counting
• Confusing pointer addresses with count

4. Find the error in this C function to get the length of a linked list:

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

medium

A. It causes a segmentation fault immediately

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: Understand the loop condition

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

2. Step 2: Check counting logic

   Because it stops early, the last node is not counted, so 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 handling empty list (NULL head)
• Incrementing count after loop ends

5. You have a linked list where some nodes may have next pointers forming a cycle (loop). How would you modify the length function to avoid infinite counting?

hard

A. Stop counting after 10 nodes to avoid infinite loop

B. Count nodes normally without any change

C. Use two pointers moving at different speeds to detect a cycle before counting

D. Set all next pointers to NULL before counting

Solution

1. Step 1: Detect cycle using two pointers

   Use Floyd's cycle detection: one pointer moves one step, another moves two steps to find a loop.

2. Step 2: If cycle detected, handle counting carefully

   Once a cycle is found, count nodes up to the cycle start to avoid infinite counting.

3. Final Answer:

   Use two pointers moving at different speeds to detect a cycle before counting -> Option C

4. Quick Check:

   Cycle detection prevents infinite loops [OK]

Hint: Detect cycle first with slow and fast pointers [OK]

Common Mistakes:

• Ignoring cycle causes infinite loop
• Stopping count arbitrarily without detection
• Modifying list structure destructively