Related Articles
Write a function that counts the number of times a given int occurs in a Linked List
• Difficulty Level : Basic
• Last Updated : 18 Dec, 2019

Given a singly linked list and a key, count number of occurrences of given key in linked list. For example, if given linked list is 1->2->1->2->1->3->1 and given key is 1, then output should be 4.

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Method 1- Without Recursion
Algorithm:

```1. Initialize count as zero.
2. Loop through each element of linked list:
a) If element data is equal to the passed number then
increment the count.
3. Return count.
```

Implementation:

## C++

 `// C++ program to count occurrences 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; ` `} ` ` `  `/* Counts the no. of occurrences of a node  ` `(search_for) in a linked list (head)*/` `int` `count(Node* head, ``int` `search_for) ` `{ ` `    ``Node* current = head; ` `    ``int` `count = 0; ` `    ``while` `(current != NULL) { ` `        ``if` `(current->data == search_for) ` `            ``count++; ` `        ``current = current->next; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `/* 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 1 is "` `<< count(head, 1); ` `    ``return` `0; ` `} ` ` `  `// This is code is contributed by rathbhupendra `

## C

 `// C program to count occurrences 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 off the new node */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Counts the no. of occurrences of a node ` `   ``(search_for) in a linked list (head)*/` `int` `count(``struct` `Node* head, ``int` `search_for) ` `{ ` `    ``struct` `Node* current = head; ` `    ``int` `count = 0; ` `    ``while` `(current != NULL) { ` `        ``if` `(current->data == search_for) ` `            ``count++; ` `        ``current = current->next; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `/* Driver program to test count function*/` `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); ` ` `  `    ``/* Check the count function */` `    ``printf``(``"count of 1 is %d"``, count(head, 1)); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count occurrences in a linked list ` `class` `LinkedList { ` `    ``Node head; ``// head of list ` ` `  `    ``/* Linked list Node*/` `    ``class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `        ``Node(``int` `d) ` `        ``{ ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``/* 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; ` `    ``} ` ` `  `    ``/* Counts the no. of occurrences of a node ` `    ``(search_for) in a linked list (head)*/` `    ``int` `count(``int` `search_for) ` `    ``{ ` `        ``Node current = head; ` `        ``int` `count = ``0``; ` `        ``while` `(current != ``null``) { ` `            ``if` `(current.data == search_for) ` `                ``count++; ` `            ``current = current.next; ` `        ``} ` `        ``return` `count; ` `    ``} ` ` `  `    ``/* Driver function to test the above methods */` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); ` ` `  `        ``/* Use push() to construct below list ` `          ``1->2->1->3->1  */` `        ``llist.push(``1``); ` `        ``llist.push(``2``); ` `        ``llist.push(``1``); ` `        ``llist.push(``3``); ` `        ``llist.push(``1``); ` ` `  `        ``/*Checking count function*/` `        ``System.out.println(``"Count of 1 is "` `+ llist.count(``1``)); ` `    ``} ` `} ` `// This code is contributed by Rajat Mishra `

## Python

 `# Python program to count the number of time a given ` `# int occurs in a linked list ` ` `  `# Node class  ` `class` `Node: ` ` `  `    ``# Constructor to initialize the node object ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  `class` `LinkedList: ` ` `  `    ``# Function to initialize head ` `    ``def` `__init__(``self``): ` `        ``self``.head ``=` `None` ` `  `    ``# Counts the no . of occurrences of a node ` `    ``# (search_for) in a linked list (head) ` `    ``def` `count(``self``, search_for): ` `        ``current ``=` `self``.head ` `        ``count ``=` `0` `        ``while``(current ``is` `not` `None``): ` `            ``if` `current.data ``=``=` `search_for: ` `                ``count ``+``=` `1` `            ``current ``=` `current.``next` `        ``return` `count ` ` `  `    ``# Function to insert a new node at the beginning ` `    ``def` `push(``self``, new_data): ` `        ``new_node ``=` `Node(new_data) ` `        ``new_node.``next` `=` `self``.head ` `        ``self``.head ``=` `new_node ` ` `  `    ``# Utility function to print the linked LinkedList ` `    ``def` `printList(``self``): ` `        ``temp ``=` `self``.head ` `        ``while``(temp): ` `            ``print` `temp.data, ` `            ``temp ``=` `temp.``next` ` `  ` `  `# Driver program ` `llist ``=` `LinkedList() ` `llist.push(``1``) ` `llist.push(``3``) ` `llist.push(``1``) ` `llist.push(``2``) ` `llist.push(``1``) ` ` `  `# Check for the count function ` `print` `"count of 1 is % d"` `%``(llist.count(``1``)) ` ` `  `# This code is contributed by Nikhil Kumar Singh(nickzuck_007) `

## C#

 `// C# program to count occurrences in a linked list ` `using` `System; ` `class` `LinkedList { ` `    ``Node head; ``// head of list ` ` `  `    ``/* Linked list Node*/` `    ``public` `class` `Node { ` `        ``public` `int` `data; ` `        ``public` `Node next; ` `        ``public` `Node(``int` `d) ` `        ``{ ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``/* 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; ` `    ``} ` ` `  `    ``/* Counts the no. of occurrences of a node  ` `    ``(search_for) in a linked list (head)*/` `    ``int` `count(``int` `search_for) ` `    ``{ ` `        ``Node current = head; ` `        ``int` `count = 0; ` `        ``while` `(current != ``null``) { ` `            ``if` `(current.data == search_for) ` `                ``count++; ` `            ``current = current.next; ` `        ``} ` `        ``return` `count; ` `    ``} ` ` `  `    ``/* Driver code */` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); ` ` `  `        ``/* Use push() to construct below list  ` `        ``1->2->1->3->1 */` `        ``llist.push(1); ` `        ``llist.push(2); ` `        ``llist.push(1); ` `        ``llist.push(3); ` `        ``llist.push(1); ` ` `  `        ``/*Checking count function*/` `        ``Console.WriteLine(``"Count of 1 is "` `+ llist.count(1)); ` `    ``} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

Output:

`count of 1 is 3`

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 2- With Recursion
This method is contributed by MY_DOOM.
Algorithm:

```Algorithm
return frequency
increase frequency by 1
```

Implementation:

## C++

 `// C++ program to count occurrences in ` `// a linked list using recursion ` `#include ` `using` `namespace` `std; ` ` `  `/* Link list node */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` `// global variable for counting frequeancy of ` `// given element k ` `int` `frequency = 0; ` ` `  `/* 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 off the new node */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Counts the no. of occurrences of a node ` `(search_for) in a linked list (head)*/` `int` `count(``struct` `Node* head, ``int` `key) ` `{ ` `    ``if` `(head == NULL) ` `        ``return` `frequency; ` `    ``if` `(head->data == key) ` `        ``frequency++; ` `    ``return` `count(head->next, key); ` `} ` ` `  `/* Driver program to test count function*/` `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); ` ` `  `    ``/* Check the count function */` `    ``cout << ``"count of 1 is "` `<< count(head, 1); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count occurrences in ` `// a linked list using recursion ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `// Represents node of a linkedlist ` `class` `Node { ` `    ``int` `data; ` `    ``Node next; ` `    ``Node(``int` `val) ` `    ``{ ` `        ``data = val; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `class` `GFG { ` ` `  `    ``// global variable for counting frequeancy of ` `    ``// given element k ` `    ``static` `int` `frequency = ``0``; ` ` `  `    ``/* 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. */` ` `  `    ``static` `Node push(Node head, ``int` `new_data) ` `    ``{ ` `        ``// allocate node ` `        ``Node new_node = ``new` `Node(new_data); ` ` `  `        ``// link the old list off the new node ` `        ``new_node.next = head; ` ` `  `        ``// move the head to point to the new node ` `        ``head = new_node; ` ` `  `        ``return` `head; ` `    ``} ` ` `  `    ``/* Counts the no. of occurrences of a node  ` `    ``(search_for) in a linked list (head)*/` `    ``static` `int` `count(Node head, ``int` `key) ` `    ``{ ` `        ``if` `(head == ``null``) ` `            ``return` `frequency; ` `        ``if` `(head.data == key) ` `            ``frequency++; ` `        ``return` `count(head.next, key); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``// Start with the empty list ` `        ``Node head = ``null``; ` ` `  `        ``/* Use push() to construct below list  ` `        ``1->2->1->3->1 */` `        ``head = push(head, ``1``); ` `        ``head = push(head, ``3``); ` `        ``head = push(head, ``1``); ` `        ``head = push(head, ``2``); ` `        ``head = push(head, ``1``); ` ` `  `        ``/* Check the count function */` `        ``System.out.print(``"count of 1 is "` `+ count(head, ``1``)); ` `    ``} ` `} ` ` `  `// This code is contributed by rachana soma `

## Python3

 `# Python program to count the number of  ` `# time a given int occurs in a linked list ` `# Node class ` `class` `Node: ` `     `  `    ``# Constructor to initialize the node object ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  `class` `LinkedList: ` `     `  `    ``# Function to initialize head ` `    ``def` `__init__(``self``): ` `        ``self``.head ``=` `None` `        ``self``.counter ``=` `0` `         `  `    ``# Counts the no . of occurances of a node ` `    ``# (seach_for) in a linkded list (head) ` `    ``def` `count(``self``, li, key):      ` `         `  `        ``# Base case  ` `        ``if``(``not` `li):  ` `            ``return` `self``.counter ` `         `  `        ``# If key is present in  ` `        ``# current node, return true  ` `        ``if``(li.data ``=``=` `key):  ` `            ``self``.counter ``=` `self``.counter ``+` `1` `         `  `        ``# Recur for remaining list  ` `        ``return` `self``.count(li.``next``, key)  ` ` `  `    ``# Function to insert a new node  ` `    ``# at the beginning ` `    ``def` `push(``self``, new_data): ` `        ``new_node ``=` `Node(new_data) ` `        ``new_node.``next` `=` `self``.head ` `        ``self``.head ``=` `new_node ` ` `  `    ``# Utility function to print the  ` `    ``# linked LinkedList ` `    ``def` `printList(``self``): ` `        ``temp ``=` `self``.head ` `        ``while``(temp): ` `            ``print` `(temp.data) ` `            ``temp ``=` `temp.``next` ` `  `# Driver Code ` `llist ``=` `LinkedList() ` `llist.push(``1``) ` `llist.push(``3``) ` `llist.push(``1``) ` `llist.push(``2``) ` `llist.push(``1``) ` ` `  `# Check for the count function ` `print` `(``"count of 1 is"``, llist.count(llist.head, ``1``)) ` ` `  `# This code is contributed by  ` `# Gaurav Kumar Raghav `

## C#

 `// C# program to count occurrences in ` `// a linked list using recursion ` `using` `System; ` ` `  `// Represents node of a linkedlist ` `public` `class` `Node { ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `    ``public` `Node(``int` `val) ` `    ``{ ` `        ``data = val; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `class` `GFG { ` ` `  `    ``// global variable for counting frequeancy of ` `    ``// given element k ` `    ``static` `int` `frequency = 0; ` ` `  `    ``/* 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. */` ` `  `    ``static` `Node push(Node head, ``int` `new_data) ` `    ``{ ` `        ``// allocate node ` `        ``Node new_node = ``new` `Node(new_data); ` ` `  `        ``// link the old list off the new node ` `        ``new_node.next = head; ` ` `  `        ``// move the head to point to the new node ` `        ``head = new_node; ` ` `  `        ``return` `head; ` `    ``} ` ` `  `    ``/* Counts the no. of occurrences of a node  ` `    ``(search_for) in a linked list (head)*/` `    ``static` `int` `count(Node head, ``int` `key) ` `    ``{ ` `        ``if` `(head == ``null``) ` `            ``return` `frequency; ` `        ``if` `(head.data == key) ` `            ``frequency++; ` `        ``return` `count(head.next, key); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``// Start with the empty list ` `        ``Node head = ``null``; ` ` `  `        ``/* Use push() to construct below list  ` `        ``1->2->1->3->1 */` `        ``head = push(head, 1); ` `        ``head = push(head, 3); ` `        ``head = push(head, 1); ` `        ``head = push(head, 2); ` `        ``head = push(head, 1); ` ` `  `        ``/* Check the count function */` `        ``Console.Write(``"count of 1 is "` `+ count(head, 1)); ` `    ``} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

Output:

`count of 1 is 3`

Below method can be used to avoid Global variable ‘frequency'(counter in case of Python 3 Code).

## C++

 `// method can be used to avoid ` `// Global variable 'frequency' ` ` `  `/* Counts the no. of occurrences of a node  ` `(search_for) in a linked list (head)*/` `int` `count(``struct` `Node* head, ``int` `key) ` `{ ` `    ``if` `(head == NULL) ` `        ``return` `0; ` `    ``if` `(head->data == key) ` `        ``return` `1 + count(head->next, key); ` `    ``return` `count(head->next, key); ` `} `

## Java

 `// method can be used to avoid ` `// Global variable 'frequency' ` ` `  `/* Counts the no. of occurrences of a node  ` `(search_for) in a linked list (head)*/` `int` `count(Node head, ``int` `key) ` `{ ` `    ``if` `(head == ``null``) ` `        ``return` `0``; ` `    ``if` `(head.data == key) ` `        ``return` `1` `+ count(head.next, key); ` `    ``return` `count(head.next, key); ` `} ` ` `  `// This code is contributed by rachana soma `

## C#

 `// method can be used to avoid ` `// Global variable 'frequency' ` `using` `System;  ` ` `  `/* Counts the no. of occurrences of a node  ` `(search_for) in a linked list (head)*/` `static` `int` `count(Node head, ``int` `key)  ` `{  ` `    ``if` `(head == ``null``)  ` `        ``return` `0;  ` `    ``if` `(head.data == key)  ` `        ``return` `1 + count(head.next, key); ` `    ``return` `count(head.next, key);  ` `}  ` ` `  `// This code is contributed by SHUBHAMSINGH10 `

## Python3

 `def` `count(``self``, temp, key): ` `     `  `    ``# during the initial call, temp ` `    ``# has the value of head ` `     `  `    ``# Base case ` `    ``if` `temp ``is` `None``: ` `        ``return` `0` `         `  `    ``# if a match is found, we  ` `    ``# increment the counter ` `    ``if` `temp.data ``=``=` `key: ` `        ``return` `1` `+` `count(temp.``next``, key) ` `    ``return` `count(temp.``next``, key) ` `     `  `# to call count, use ` `# linked_list_name.count(head, key) `

The above method implements head recursion. Below given is the tail recursive implementation for the same. Thanks to Puneet Jain for suggesting this approach :

```int count(struct Node* head, int key)
{
return 0;

return 1 + frequency;

// else
return frequency;
}
```

Time Complexity: O(n)