Find Length of a Linked List (Iterative and Recursive) (original) (raw)

Last Updated : 18 Feb, 2025

Try it on GfG Practice

Given a Singly Linked List, the task is to find the Length of the Linked List.

**Examples:

**Input: LinkedList = 1->3->1->2->1
**Output: 5
**Explanation: The linked list has 5 nodes.

**Input: LinkedList = 2->4->1->9->5->3->6
**Output: 7
**Explanation: The linked list has 7 nodes.

**Input: LinkedList = 10->20->30->40->50->60
**Output: 6
**Explanation: The linked list has 6 nodes.

Iterative Approach to Find the Length of a Linked List

The idea is similar to traversal of Linked List with an additional variableto count the number of nodes in the Linked List.

**Steps to find the length of the Linked List:

• Initialize count as 0.
• Initialize a node pointer, curr = head.
• Do following while curr is not NULL
  • curr = curr -> next
  • Increment count by 1.
• Return count. C++ `

// Iterative C++ program to find length // or count of nodes in a linked list

#include <bits/stdc++.h> using namespace std;

// Link list node class Node { public: int data; Node* next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = nullptr;
}

};

// Counts number of nodes in linked list int countNodes(Node* head) {

// Initialize count with 0
int count = 0;

// Initialize curr with head of Linked List
Node* curr = head;

// Traverse till we reach nullptr
while (curr != nullptr) {
    
      // Increment count by 1
    count++;
    
      // Move pointer to next node
    curr = curr->next;
}
  
  // Return the count of nodes
return count;

}

// Driver code int main() {

// Create a hard-coded linked list:
// 1 -> 3 -> 1 -> 2 -> 1
Node* head = new Node(1);
head->next = new Node(3);
head->next->next = new Node(1);
head->next->next->next = new Node(2);
head->next->next->next->next = new Node(1);

// Function call to count the number of nodes
cout << "Count of nodes is " << countNodes(head);
return 0;

}

C

// Iterative C program to find length or count of nodes in a // linked list

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

// Link list node struct Node { int data; struct Node* next; };

// Function to create a new node struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; }

// Counts number of nodes in linked list int countNodes(struct Node* head) { // Initialize count with 0 int count = 0;

// Initialize curr with head of Linked List
struct Node* curr = head;

// Traverse till we reach NULL
while (curr != NULL) {
  
    // Increment count by 1
    count++;
    
      // Move pointer to next node
    curr = curr->next;
}

// Return the count of nodes
return count;

}

// Driver code int main() {

// Create a hard-coded linked list:
// 1 -> 3 -> 1 -> 2 -> 1
struct Node* head = createNode(1);
head->next = createNode(3);
head->next->next = createNode(1);
head->next->next->next = createNode(2);
head->next->next->next->next = createNode(1);

// Function call
printf("Count of nodes is %d", countNodes(head));
return 0;

}

Java

// Iterative Java program to count the number of // nodes in a linked list

// Node class to define a linked list node class Node { int data; Node next;

// Constructor to initialize a new node with data
Node(int newData) {
    data = newData;
    next = null;
}

}

// Class to define methods related to the linked list public class GFG {

// Counts number of nodes in linked list
public static int countNodes(Node head) {

    // Initialize count with 0
    int count = 0;

    // Initialize curr with head of Linked List
    Node curr = head;

    // Traverse till we reach null
    while (curr != null) {

        // Increment count by 1
        count++;

        // Move pointer to next node
        curr = curr.next;
    }
    // Return the count of nodes
    return count;
}

// Driver code
public static void main(String[] args) {

    // Create a hard-coded linked list:
    // 1 -> 3 -> 1 -> 2 -> 1
    Node head = new Node(1);
    head.next = new Node(3);
    head.next.next = new Node(1);
    head.next.next.next = new Node(2);
    head.next.next.next.next = new Node(1);

    // Function call to count the number of nodes
    System.out.println("Count of nodes is "
                       + countNodes(head));
}

}

Python

Iterative Python program to count the number of nodes

in a linked list

class Node: def init(self, new_data):

    # Constructor to initialize a new node with data
    self.data = new_data
    self.next = None

def count_nodes(head):

# Counts number of nodes in linked list
# Initialize count with 0
count = 0

# Initialize curr with head of Linked List
curr = head

# Traverse till we reach None
while curr is not None:
    # Increment count by 1
    count += 1

    # Move pointer to next node
    curr = curr.next

# Return the count of nodes
return count

Driver code

if name == "main":

# Create a hard-coded linked list:
# 1 -> 3 -> 1 -> 2 -> 1
head = Node(1)
head.next = Node(3)
head.next.next = Node(1)
head.next.next.next = Node(2)
head.next.next.next.next = Node(1)

# Function call to count the number of nodes
print("Count of nodes is", count_nodes(head))

C#

// Iterative C# program to find length or count of nodes // in a linked list

using System;

// Link list node class Node { public int Data; public Node Next;

// Constructor to initialize a new node with data
public Node(int newData) {
    Data = newData;
    Next = null;
}

}

class GFG {

// Counts number of nodes in linked list
static int CountNodes(Node head) {
    
      // Initialize count with 0
    int count = 0;

    // Initialize curr with head of Linked List
    Node curr = head;

    // Traverse till we reach null
    while (curr != null) {
        // Increment count by 1
        count++;

        // Move pointer to next node
        curr = curr.Next;
    }

    // Return the count of nodes
    return count;
}

static void Main() {

    // Create a hard-coded linked list:
    // 1 -> 3 -> 1 -> 2 -> 1
    Node head = new Node(1);
    head.Next = new Node(3);
    head.Next.Next = new Node(1);
    head.Next.Next.Next = new Node(2);
    head.Next.Next.Next.Next = new Node(1);

    // Function call to count the number of nodes
    Console.WriteLine("Count of nodes is "
                      + CountNodes(head));
}

}

JavaScript

// Iterative JavaScript program to find length // or count of nodes in a linked list

// Linked List Node class Node {

// Constructor to initialize a new node
// with data
constructor(newData) {
    this.data = newData;
    this.next = null;
}

}

// Counts number of nodes in linked list function countNodes(head) { // Initialize count with 0 let count = 0;

// Initialize curr with head of Linked List
let curr = head;

// Traverse till we reach null
while (curr !== null) {

    // Increment count by 1
    count++;

    // Move pointer to next node
    curr = curr.next;
}

// Return the count of nodes
return count;

}

// Driver code

// Create a hard-coded linked list: // 1 -> 3 -> 1 -> 2 -> 1 let head = new Node(1); head.next = new Node(3); head.next.next = new Node(1); head.next.next.next = new Node(2); head.next.next.next.next = new Node(1);

// Function call to count the number of nodes console.log("Count of nodes is " + countNodes(head));

`

Output

Count of nodes is 5

**Time complexity: O(n), Where nis the size of the linked list
**Auxiliary Space: O(1), As constant extra space is used.

Recursive Approach to Find the Length of a Linked List:

The idea is to use recursion by maintaining a function, say **countNodes(node) which takes a node as an argument and calls itself with the next node until we reach the end of the Linked List. Each of the recursive call returns **1 + count of remaining nodes.

C++ `

// Recursive C++ program to find length // or count of nodes in a linked list

#include <bits/stdc++.h> using namespace std;

// Link list node class Node { public: int data; Node* next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = nullptr;
}

};

// Recursively count number of nodes in linked list int countNodes(Node* head) {

// Base Case
if (head == NULL) {
    return 0;
}

// Count this node plus the rest of the list
return 1 + countNodes(head->next);

}

// Driver code int main() {

// Create a hard-coded linked list:
// 1 -> 3 -> 1 -> 2 -> 1
Node* head = new Node(1);
head->next = new Node(3);
head->next->next = new Node(1);
head->next->next->next = new Node(2);
head->next->next->next->next = new Node(1);

// Function call to count the number of nodes
cout << "Count of nodes is " << countNodes(head);
return 0;

}

C

// Recursive C program to find length // or count of nodes in a linked list

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

// Link list node struct Node { int data; struct Node* next; };

// Constructor to initialize a new node with data struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; }

// Recursively count number of nodes in linked list int countNodes(struct Node* head) {

// Base Case
if (head == NULL) {
    return 0;
}

// Count this node plus the rest of the list
return 1 + countNodes(head->next);

}

// Driver code int main() {

// Create a hard-coded linked list:
// 1 -> 3 -> 1 -> 2 -> 1
struct Node* head = createNode(1);
head->next = createNode(3);
head->next->next = createNode(1);
head->next->next->next = createNode(2);
head->next->next->next->next = createNode(1);

// Function call to count the number of nodes
printf("Count of nodes is %d\n", countNodes(head));
return 0;

}

Java

// Recursive Java program to find length // or count of nodes in a linked list

// Link list node class Node { int data; Node next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = null;
}

}

// Recursively count number of nodes in linked list public class GFG { public static int countNodes(Node head) {

    // Base Case
    if (head == null) {
        return 0;
    }

    // Count this node plus the rest of the list
    return 1 + countNodes(head.next);
}

public static void main(String[] args) {
      
    // Create a hard-coded linked list:
    // 1 -> 3 -> 1 -> 2 -> 1
    Node head = new Node(1);
    head.next = new Node(3);
    head.next.next = new Node(1);
    head.next.next.next = new Node(2);
    head.next.next.next.next = new Node(1);

    // Function call to count the number of nodes
    System.out.println("Count of nodes is "
                       + countNodes(head));
}

}

Python

Recursive Python program to find length

or count of nodes in a linked list

Linked List Node

class Node: def init(self, new_data): self.data = new_data self.next = None

Recursively count number of nodes in linked list

def count_nodes(head): # Base Case if head is None: return 0

# Count this node plus the rest of the list
return 1 + count_nodes(head.next)

Driver code

if name == "main":

# Create a hard-coded linked list:
# 1 -> 3 -> 1 -> 2 -> 1
head = Node(1)
head.next = Node(3)
head.next.next = Node(1)
head.next.next.next = Node(2)
head.next.next.next.next = Node(1)

# Function call to count the number of nodes
print("Count of nodes is", count_nodes(head))

C#

// Recursive C# program to find length // or count of nodes in a linked list

using System;

// Link list node public class Node { public int Data; public Node Next;

// Constructor to initialize a new node with data
public Node(int new_data) {
    Data = new_data;
    Next = null;
}

}

// Recursively count number of nodes in linked list public class GFG { public static int CountNodes(Node head) {

    // Base Case
    if (head == null) {
        return 0;
    }

    // Count this node plus the rest of the list
    return 1 + CountNodes(head.Next);
}

// Driver code
public static void Main() {
  
    // Create a hard-coded linked list:
    // 1 -> 3 -> 1 -> 2 -> 1
    Node head = new Node(1);
    head.Next = new Node(3);
    head.Next.Next = new Node(1);
    head.Next.Next.Next = new Node(2);
    head.Next.Next.Next.Next = new Node(1);

    // Function call to count the number of nodes
    Console.WriteLine("Count of nodes is " + CountNodes(head));
}

}

JavaScript

// Recursive Javascript program to find length // or count of nodes in a linked list

// Link list node class Node { constructor(data) { this.data = data; this.next = null; } }

// Recursively count number of nodes in linked list function countNodes(head) {

// Base Case
if (head === null) {
    return 0;
}

// Count this node plus the rest of the list
return 1 + countNodes(head.next);

}

// Driver code // Create a hard-coded linked list: // 1 -> 3 -> 1 -> 2 -> 1 let head = new Node(1); head.next = new Node(3); head.next.next = new Node(1); head.next.next.next = new Node(2); head.next.next.next.next = new Node(1);

// Function call to count the number of nodes console.log("Count of nodes is " + countNodes(head));

`

Output

Count of nodes is 5

**Time Complexity: O(n), where **n is the length of Linked List.
**Auxiliary Space: O(n), Extra space is used in the recursion call stack.