 GeeksforGeeks App
Open App Browser
Continue

# Write a function that counts the number of times a given int occurs in a Linked List

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

Method 1- Without Recursion

Algorithm:

```Step 1: Start
Step 2: Create A Function Of A Linked List, Pass A Number
As Arguments And Provide The Count Of The Number To The Function.
Step 3: Initialize Count Equal To 0.
Step 4: Traverse In Linked List Until Equal Number Found.
Step 5: If Found A Number Equal To Update Count By 1.
Step 6: After Reaching The End Of The Linked List Return Count.
Step 7: Call The Function.
Step 8: Prints The Number Of Int Occurrences.
Step 9: Stop.```

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 of 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 of 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``import` `java.io.*;``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`

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

## Javascript

 ``

Output

`count of 1 is 3`

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

Method 2- With Recursion

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 frequency 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 of 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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to count occurrences in a linked list using``// recursion``#include ``#include ` `/* Link list node */``typedef` `struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``} Node;``// global variable for counting frequency 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(Node** head_ref, ``int` `new_data)``{``    ``/* allocate node */``    ``Node* new_node = (Node*)``malloc``(``sizeof``(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 the no. of occurrences of a node``(search_for) in a linked list (head)*/``int` `count(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 */``    ``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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## 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 frequency 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 of 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 occurrences of a node``    ``# (seach_for) in a linked 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 frequency 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 of 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 */`

## Javascript

 ``

Output

`count of 1 is 3`

Time complexity: O(n) where n is size of linked list
Auxiliary Space: O(n) for call stack since using recursion

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)*/``import` `java.io.*;``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)`

## Javascript

 ``

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;