Find length of a Singly Linked List

Q: What is the length of a linked list?

It is the number of nodes in the list. An empty list ( head == null ) has length 0.

Q: How can you get the length of a linked list in O(1) time?

Store a size field in the list class and update it on every insert and delete. java.util.LinkedList.size() works this way. Java example: class SinglyLinkedList { Node head; int size; void addFirst(int data) { Node node = new Node(data); node.next = head; head = node; size++; } int size() { return size; } }

Q: How do you check whether a linked list has even or odd length without counting all nodes?

Move a pointer two nodes at a time. If it ends on null, the length is even; if it ends on the last node, the length is odd. Java example: static boolean isEvenLength(Node head) { Node current = head; while (current != null && current.next != null) { current = current.next.next; } return current == null; }

Q: How do you find the middle node of a linked list in one pass?

fast moves twice as fast as slow, so slow is in the middle when fast reaches the end. Java example: static Node middle(Node head) { Node slow = head, fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; } return slow; // second middle for even length }

Q: What happens if you count the nodes of a list that has a cycle?

The loop never reaches null, so it never ends. If a cycle is possible, detect it first with Floyd's algorithm (slow and fast pointers).

Find length of a Singly Linked List

Last updated: October 21, 2026Oct 21, 2026

In this Linked List tutorial, we will learn how to find the length of a Linked List. The length of a linked list is the total number of nodes present in it.

Examples:

Output

Linked List: 80 -> 20 -> 70 -> 50 -> 30
Length of Linked List: 5

Output

Linked List: 80 -> 20 -> 70 -> 50 -> 30 -> 10 -> 90 -> 40
Length of Linked List: 8

There are two approaches to find the length of a linked list:

Iterative Approach
Recursive Approach

1. Find length of a linked list using an Iterative Approach

Follow these steps to find the length of the Linked List using the iterative approach:

Create a count variable and initialize it with 0.
Initialize the temp variable with head, tempNode = head.
Do the following while tempNode is not NULL:
- tempNode = tempNode → next
- Increment count by 1
Once tempNode is NULL, return count.

In the example below, we will see the implementation of the iterative approach in Java.

FindLengthUsingIterativeApproachInSLL.java

class Node {
  public int data;
  public Node next;

  // Constructor
  public Node(int data) {
    this.data = data;
    this.next = null;
  }
}

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

    // Initialize count with 0
    int count = 0;

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

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

      // Increment count by 1
      count++;

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

  public static void main(String[] args) {
    // Create a linked list
    Node head = new Node(10);
    head.next = new Node(20);
    head.next.next = new Node(30);
    head.next.next.next = new Node(40);
    head.next.next.next.next = new Node(50);

    // Linked list will be created like this
    // 10 -> 20 -> 30 -> 40 -> 50

    // Printing total number of nodes in the list
    System.out.println("Length of the linked list is: " + countTotalNodes(head));

    // Now adding two more nodes
    head.next.next.next.next.next = new Node(60);
    head.next.next.next.next.next.next = new Node(70);

    // Now, the linked list will be like this
    // 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> 70

    System.out.println("After adding two new nodes, length of the linked list is: " + countTotalNodes(head));
  }
}

Output

Length of the linked list is: 5
After adding two new nodes, length of the linked list is: 7

Time complexity: O(N), where N is the length of the linked list.

Auxiliary Space: O(1), as constant extra space is used.

2. Find length of linked list using Recursive Approach

To implement the recursive approach, we define a function called countTotalNodes(node). This function takes a node as an argument and calls itself with the next node until we reach the end of the linked list. Each recursive call returns 1 + the count of the remaining nodes.

In the example below, we will see how to find the length of a linked list using the recursive approach in Java.

FindLengthUsingRecursiveApproachInSLL.java

class Node {
  public int data;
  public Node next;

  // Constructor
  public Node(int data) {
    this.data = data;
    this.next = null;
  }
}

public class FindLengthUsingRecursiveApproachInSLL {
  static int countTotalNodes(Node head) {
    // Returns 0, if list is empty
    if (head == null) {
      return 0;
    }

    // Adding 1 in the total number of nodes of the list
    return 1 + countTotalNodes(head.next);
  }

  public static void main(String[] args) {

    // Create a linked list
    Node head = new Node(10);
    head.next = new Node(20);
    head.next.next = new Node(30);
    head.next.next.next = new Node(40);
    head.next.next.next.next = new Node(50);

    // Linked list will be created like this
    // 10 -> 20 -> 30 -> 40 -> 50

    // Printing total number of nodes in the list
    System.out.println("Length of the linked list is: " + countTotalNodes(head));

    // Now adding two more nodes
    head.next.next.next.next.next = new Node(60);
    head.next.next.next.next.next.next = new Node(70);

    // Now, the linked list will be like this
    // 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> 70

    System.out.println("After adding two new nodes, length of the linked list is: " + countTotalNodes(head));
  }
}

Output

Length of the linked list is: 5
After adding two new nodes, length of the linked list is: 7

Time complexity: O(N), where N is the length of the linked list.

Auxiliary Space: O(N), as extra space is used by the recursion call stack.

Frequently Asked Questions (FAQ)

Q1. What is the length of a linked list?

It is the number of nodes in the list. An empty list (head == null) has length 0.

Q2. What is the complexity of the iterative and recursive approaches?

Both take O(n) time. The iterative version uses O(1) extra space, while the recursive version uses O(n) stack space, one frame per node.

Q3. How can you get the length of a linked list in O(1) time?

Store a size field in the list class and update it on every insert and delete. java.util.LinkedList.size() works this way.

SizedList.java

class SinglyLinkedList {
    Node head;
    int size;

    void addFirst(int data) {
        Node node = new Node(data);
        node.next = head;
        head = node;
        size++;
    }

    int size() {
        return size;
    }
}

Q4. Does Java optimize the tail recursion in a recursive length method?

No. The JVM does not perform tail-call optimization, so every recursive call adds a stack frame. A list with a few hundred thousand nodes can cause a StackOverflowError; use the iterative version for long lists.

Q5. How do you check whether a linked list has even or odd length without counting all nodes?

Move a pointer two nodes at a time. If it ends on null, the length is even; if it ends on the last node, the length is odd.

IsEvenLength.java

static boolean isEvenLength(Node head) {
    Node current = head;
    while (current != null && current.next != null) {
        current = current.next.next;
    }
    return current == null;
}

Q6. How do you find the middle node of a linked list in one pass?

MiddleNode.java

static Node middle(Node head) {
    Node slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow; // second middle for even length
}

fast moves twice as fast as slow, so slow is in the middle when fast reaches the end.

Q7. What happens if you count the nodes of a list that has a cycle?

The loop never reaches null, so it never ends. If a cycle is possible, detect it first with Floyd's algorithm (slow and fast pointers).

Q8. Does moving the head parameter inside countTotalNodes change the caller's list?

No. Java passes the reference by value, so the method only moves its own copy. Using a separate tempNode still makes the code clearer and avoids bugs when head is a field of the list object.

Was this tutorial helpful?

Help Us Improve

Find length of a Singly Linked List

1. Find length of a linked list using an Iterative Approach

2. Find length of linked list using Recursive Approach

Frequently Asked Questions (FAQ)