Find Length of a Linked List (Iterative and Recursive)

Write a function to count the number of nodes in a given singly linked list

Examples:

Input:

Input: 2->4->1->9->5->3->6
Output: 7 

An iterative approach for finding the length of the linked list:

Follow the given steps to solve the problem:

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

Below is the implementation of the above approach:

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;
};

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = new Node();

    /* put in the data */
    new_node->data = new_data;

    /* link the old list of the new node */
    new_node->next = (*head_ref);

    /* move the head to point to the new node */
    (*head_ref) = new_node;
}

/* Counts no. of nodes in linked list */
int getCount(Node* head)
{
    int count = 0; // Initialize count
    Node* current = head; // Initialize current
    while (current != NULL) {
        count++;
        current = current->next;
    }
    return count;
}

/* Driver code*/
int main()
{
    /* Start with the empty list */
    Node* head = NULL;

    /* Use push() to construct below list
    1->2->1->3->1 */
    push(&head, 1);
    push(&head, 3);
    push(&head, 1);
    push(&head, 2);
    push(&head, 1);

    // Function call
    cout << "count of nodes is " << getCount(head);
    return 0;
}

// This is code is contributed by rathbhupendra

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;
};

/* Given a reference (pointer to pointer) to the head
  of a list and an int, push a new node on the front
  of the list. */
void push(struct Node** head_ref, int new_data)
{
    /* allocate node */
    struct Node* new_node
        = (struct Node*)malloc(sizeof(struct Node));

    /* put in the data  */
    new_node->data = new_data;

    /* link the old list of the new node */
    new_node->next = (*head_ref);

    /* move the head to point to the new node */
    (*head_ref) = new_node;
}

/* Counts no. of nodes in linked list */
int getCount(struct Node* head)
{
    int count = 0; // Initialize count
    struct Node* current = head; // Initialize current
    while (current != NULL) {
        count++;
        current = current->next;
    }
    return count;
}

/* Driver code*/
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;

    /* Use push() to construct below list
     1->2->1->3->1  */
    push(&head, 1);
    push(&head, 3);
    push(&head, 1);
    push(&head, 2);
    push(&head, 1);

    // Function call
    printf("count of nodes is %d", getCount(head));
    return 0;
}

Java

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

/* Linked list Node*/
class Node {
    int data;
    Node next;
    Node(int d)
    {
        data = d;
        next = null;
    }
}

// Linked List class
class LinkedList {
    Node head; // head of list

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
    public int getCount()
    {
        Node temp = head;
        int count = 0;
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        return count;
    }

    // Driver code
    public static void main(String[] args)
    {
        /* Start with the empty list */
        LinkedList llist = new LinkedList();
        llist.push(1);
        llist.push(3);
        llist.push(1);
        llist.push(2);
        llist.push(1);

          // Function call
        System.out.println("Count of nodes is "
                           + llist.getCount());
    }
}

Python3

# A complete working Python program to find length of a
# Linked List iteratively

# Node class


class Node:
    # Function to initialise the node object
    def __init__(self, data):
        self.data = data  # Assign data
        self.next = None  # Initialize next as null


# Linked List class contains a Node object
class LinkedList:

    # Function to initialize head
    def __init__(self):
        self.head = None

    # This function is in LinkedList class. It inserts
    # a new node at the beginning of Linked List.

    def push(self, new_data):

        # 1 & 2: Allocate the Node &
        #     Put in the data
        new_node = Node(new_data)

        # 3. Make next of new Node as head
        new_node.next = self.head

        # 4. Move the head to point to new Node
        self.head = new_node

    # This function counts number of nodes in Linked List
    # iteratively, given 'node' as starting node.

    def getCount(self):
        temp = self.head  # Initialise temp
        count = 0  # Initialise count

        # Loop while end of linked list is not reached
        while (temp):
            count += 1
            temp = temp.next
        return count


# Driver code
if __name__ == '__main__':
    llist = LinkedList()
    llist.push(1)
    llist.push(3)
    llist.push(1)
    llist.push(2)
    llist.push(1)

    # Function call
    print("Count of nodes is :", llist.getCount())

C#

// C# program to count number
// of nodes in a linked list
using System;

/* Linked list Node*/
public class Node {
    public int data;
    public Node next;
    public Node(int d)
    {
        data = d;
        next = null;
    }
}

// Linked List class
public class LinkedList {
    Node head; // head of list

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
    public int getCount()
    {
        Node temp = head;
        int count = 0;
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        return count;
    }

    // Driver code
    public static void Main()
    {
        /* Start with the empty list */
        LinkedList llist = new LinkedList();
        llist.push(1);
        llist.push(3);
        llist.push(1);
        llist.push(2);
        llist.push(1);

          // Function call
        Console.WriteLine("Count of nodes is "
                          + llist.getCount());
    }
}

/* This code contributed by PrinciRaj1992 */

Javascript

<script>
// javascript program to count number of nodes in a linked list

/* Linked list Node*/
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}

// Linked List class
var head; // head of list

    /* Inserts a new Node at front of the list. */
     function push(new_data) {
        /*
         * 1 & 2: Allocate the Node & Put in the data
         */
        var new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
     function getCount() {
        var temp = head;
        var count = 0;
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        return count;
    }

    /*
     * Driver program to test above functions. Ideally this function should be in a
     * separate user class. It is kept here to keep code compact
     */

        /* Start with the empty list */
        push(1);
        push(3);
        push(1);
        push(2);
        push(1);

        document.write("Count of nodes is " + getCount());

// This code contributed by Rajput-Ji
</script>

Output

count of nodes is 5

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

A recursive approach for finding the length of the linked list:

Follow the given steps to solve the problem:

• If the head is NULL, return 0.
• Otherwise, return 1 + getCount(head->next) 

Below is the implementation of the above approach:

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;
};

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = new Node();

    /* put in the data */
    new_node->data = new_data;

    /* link the old list of the new node */
    new_node->next = (*head_ref);

    /* move the head to point to the new node */
    (*head_ref) = new_node;
}

/* Recursively count number of nodes in linked list */
int getCount(Node* head)
{
    // Base Case
    if (head == NULL) {
        return 0;
    }
    // Count this node plus the rest of the list
    else {
        return 1 + getCount(head->next);
    }
}

/* Driver program to test count function*/
int main()
{
    /* Start with the empty list */
    Node* head = NULL;

    /* Use push() to construct below list
    1->2->1->3->1 */
    push(&head, 1);
    push(&head, 3);
    push(&head, 1);
    push(&head, 2);
    push(&head, 1);

    /* Check the count function */
    cout << "Count of nodes is " << getCount(head);
    return 0;
}

// This is code is contributed by rajsanghavi9

Java

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

/* Linked list Node*/
class Node {
    int data;
    Node next;
    Node(int d)
    {
        data = d;
        next = null;
    }
}

// Linked List class
class LinkedList {
    Node head; // head of list

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
    public int getCountRec(Node node)
    {
        // Base case
        if (node == null)
            return 0;

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

    /* Wrapper over getCountRec() */
    public int getCount() { return getCountRec(head); }

    /* Driver program to test above functions. Ideally
       this function should be in a separate user class.
       It is kept here to keep code compact */
    public static void main(String[] args)
    {
        /* Start with the empty list */
        LinkedList llist = new LinkedList();
        llist.push(1);
        llist.push(3);
        llist.push(1);
        llist.push(2);
        llist.push(1);

        System.out.println("Count of nodes is "
                           + llist.getCount());
    }
}

Python3

# A complete working Python program to find length of a
# Linked List recursively

# Node class


class Node:
    # Function to initialise the node object
    def __init__(self, data):
        self.data = data  # Assign data
        self.next = None  # Initialize next as null


# Linked List class contains a Node object
class LinkedList:

    # Function to initialize head
    def __init__(self):
        self.head = None

    # This function is in LinkedList class. It inserts
    # a new node at the beginning of Linked List.

    def push(self, new_data):

        # 1 & 2: Allocate the Node &
        #        Put in the data
        new_node = Node(new_data)

        # 3. Make next of new Node as head
        new_node.next = self.head

        # 4. Move the head to point to new Node
        self.head = new_node

    # This function counts number of nodes in Linked List
    # recursively, given 'node' as starting node.
    def getCountRec(self, node):
        if (not node):  # Base case
            return 0
        else:
            return 1 + self.getCountRec(node.next)

    # A wrapper over getCountRec()
    def getCount(self):
        return self.getCountRec(self.head)


# Code execution starts here
if __name__ == '__main__':
    llist = LinkedList()
    llist.push(1)
    llist.push(3)
    llist.push(1)
    llist.push(2)
    llist.push(1)
    print('Count of nodes is :', llist.getCount())

C#

// Recursive C# program to count number of nodes in
// a linked list
using System;

/* Linked list Node*/
public class Node {
    public int data;
    public Node next;
    public Node(int d)
    {
        data = d;
        next = null;
    }
}

// Linked List class
public class LinkedList {
    Node head; // head of list

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
    public int getCountRec(Node node)
    {
        // Base case
        if (node == null)
            return 0;

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

    /* Wrapper over getCountRec() */
    public int getCount() { return getCountRec(head); }

    /* Driver program to test above functions. Ideally
    this function should be in a separate user class.
    It is kept here to keep code compact */
    public static void Main(String[] args)
    {
        /* Start with the empty list */
        LinkedList llist = new LinkedList();
        llist.push(1);
        llist.push(3);
        llist.push(1);
        llist.push(2);
        llist.push(1);

        Console.WriteLine("Count of nodes is "
                          + llist.getCount());
    }
}

// This code is contributed 29AjayKumar

Javascript

<script>
// Recursive javascript program to count number of nodes in
// a linked list

/* Linked list Node*/
class Node {
    constructor(val) {
            this.data = val;
            this.next = null;
        }
    }

    // Linked List class
    var head; // head of list

    /* Inserts a new Node at front of the list. */
    function push( new_data) {
        /*
         * 1 & 2: Allocate the Node & Put in the data
         */
        var new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
     function getCountRec(node) {
        // Base case
        if (node == null)
            return 0;

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

    /* Wrapper over getCountRec() */
     function getCount() {
        return getCountRec(head);
    }

    /*
     * Driver program to test above functions. Ideally this function should be in a
     * separate user class. It is kept here to keep code compact
     */

        /* Start with the empty list */

        push(1);
        push(3);
        push(1);
        push(2);
        push(1);

        document.write("Count of nodes is " + getCount());

// This code contributed by gauravrajput1
</script>

Output

Count of nodes is 5

Time Complexity: O(N), As we are traversing the linked list only once.
Auxiliary Space: O(N), Extra space is used in the recursion call stack.

Recursive approach for finding the length of the linked list using constant space:

To solve the problem follow the below idea:

The above recursive approach can be modified to make it a tail recursive function and thus our auxiliary space will become O(1)

Below is the implementation of the above approach:

C++

// Tail 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;
};

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = new Node();

    /* put in the data */
    new_node->data = new_data;

    /* link the old list of the new node */
    new_node->next = (*head_ref);

    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
// A tail recursive function to count the nodes of a linked
// list
// default value of the count is used as zero
int getCount(Node* head, int count = 0)
{
    // base case
    if (head == NULL)
        return count;
    // move the pointer to next node and increase the count
    return getCount(head->next, count + 1);
}

/* Driver code*/
int main()
{
    /* Start with the empty list */
    Node* head = NULL;

    /* Use push() to construct below list
    1->2->1->3->1 */
    push(&head, 1);
    push(&head, 3);
    push(&head, 1);
    push(&head, 2);
    push(&head, 1);

    // Function call
    cout << "Count of nodes is " << getCount(head);
    return 0;
}

// This is code is contributed by Abhijeet Kumar

Java

// Tail Recursive Java program to count number of nodes in
// a linked list

/* Linked list Node*/
class Node {
    int data;
    Node next;
    Node(int d)
    {
        data = d;
        next = null;
    }
}

// Linked List class
class LinkedList {
    Node head; // head of list

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
    public int getCountRec(Node node, int count)
    {
        // Base case
        if (node == null)
            return count;

        // Move to the next node and increase count
        return getCountRec(node.next, 1 + count);
    }

    /* Wrapper over getCountRec() */
    public int getCount() { return getCountRec(head, 0); }

    // Driver code
    public static void main(String[] args)
    {
        LinkedList llist = new LinkedList();
        llist.push(1);
        llist.push(3);
        llist.push(1);
        llist.push(2);
        llist.push(1);

          // Function call
        System.out.println("Count of nodes is "
                           + llist.getCount());
    }
}

// This code was contributed by Abhijeet
// Kumar(abhijeet19403)

Python3

# A complete working Python3 program to find length of a
# Linked List using Tail recursion.

# Node class


class Node:
    # Function to initialise the node object
    def __init__(self, data):
        self.data = data  # Assign data
        self.next = None  # Initialize next as null


# Linked List class contains a Node object
class LinkedList:

    # Function to initialize head
    def __init__(self):
        self.head = None

    # This function is in LinkedList class. It inserts
    # a new node at the beginning of Linked List.

    def push(self, new_data):

        # 1 & 2: Allocate the Node &
        #     Put in the data
        new_node = Node(new_data)

        # 3. Make next of new Node as head
        new_node.next = self.head

        # 4. Move the head to point to new Node
        self.head = new_node

    # This function counts number of nodes in Linked List
    # recursively, given 'node' as starting node using Tail Recursion.
    def getCountRec(self, node, count=0):
        if (not node):  # Base case
            return count
        else:
            return self.getCountRec(node.next, count+1)

    # A wrapper over getCountRec()
    def getCount(self):
        return self.getCountRec(self.head)


# Driver code
if __name__ == '__main__':
    llist = LinkedList()
    llist.push(1)
    llist.push(3)
    llist.push(1)
    llist.push(2)
    llist.push(1)

    # Function call
    print('Count of nodes is :', llist.getCount())

    # This code is contributed by garinesrija.

C#

// Tail Recursive C# program to count number of nodes in
// a linked list
using System;

/* Linked list Node*/
public class Node {
    public int data;
    public Node next;
    public Node(int d)
    {
        data = d;
        next = null;
    }
}

// Linked List class
public class LinkedList {
    Node head; // head of list

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
    public int getCountRec(Node node, int count)
    {
        // Base case
        if (node == null)
            return count;

        // Move the pointer to next node and increase the
        // count
        return getCountRec(node.next, 1 + count);
    }

    /* Wrapper over getCountRec() */
    public int getCount() { return getCountRec(head, 0); }

    // Driver code
    public static void Main(String[] args)
    {
        LinkedList llist = new LinkedList();
        llist.push(1);
        llist.push(3);
        llist.push(1);
        llist.push(2);
        llist.push(1);

          // Function call
        Console.WriteLine("Count of nodes is "
                          + llist.getCount());
    }
}

// This code is contributed Abhijeet Kumar(abhijeet19403)

Javascript

<script>
// Tail Recursive javascript program to count number of nodes in
// a linked list

/* Linked list Node*/
class Node {
    constructor(val) {
            this.data = val;
            this.next = null;
        }
    }

    // Linked List class
    var head; // head of list

    /* Inserts a new Node at front of the list. */
    function push( new_data) {
        /*
         * 1 & 2: Allocate the Node & Put in the data
         */
        var new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Returns count of nodes in linked list */
     function getCountRec(node,var count) {
        // Base case
        if (node == null)
            return count;

        // Move the pointer to next node and increase the count
        return getCountRec(node.next,count+1);
    }

    /* Wrapper over getCountRec() */
     function getCount() {
        return getCountRec(head,0);
    }

    /*
     * Driver program to test above functions. Ideally this function should be in a
     * separate user class. It is kept here to keep code compact
     */

        /* Start with the empty list */

        push(1);
        push(3);
        push(1);
        push(2);
        push(1);

        document.write("Count of nodes is " + getCount());

// This code contributed by Abhijeet Kumar(abhijeet19403)
</script>

Output

Count of nodes is 5

Time Complexity: O(N), As we are traversing the list only once.
Auxiliary Space: O(1), As we are using the tail recursive function, no extra space is used in the function call stack.

This article is contributed by Ravi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.