# Find Length of a Linked List (Iterative and Recursive)

• Difficulty Level : Basic
• Last Updated : 15 Nov, 2022

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:

Recommended Practice

## 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 ` `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 ` `#include `   `/* 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

 ``

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 ` `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

 ``

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 ` `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 off 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

 ``

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.