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

05 Apr, 2022
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:  
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
Java
Python3
C#
Javascript
// C++ program to count occurrences 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 headof a list and an int, push a new node on the frontof 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 program to count occurrences 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 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 program to count occurrences in a linked listclass 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 program to count the number of time a given# int occurs in a linked list # Node classclass 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 programllist = LinkedList()llist.push(1)llist.push(3)llist.push(1)llist.push(2)llist.push(1) # Check for the count functionprint ("count of 1 is % d" %(llist.count(1))) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// C# program to count occurrences in a linked listusing 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
<script>// javascript program to count occurrences in a linked listvar head; // head of list     /* Linked list Node */           class Node {            constructor(val) {                this.data = val;                this.next = null;            }        }     /* Inserts a new Node at front of the list. */    function push(new_data) {        /*         * 1 & 2: Allocate the Node & Put in the data         */         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)     */    function count(search_for) {         current = head;        var count = 0;        while (current != null) {            if (current.data == search_for)                count++;            current = current.next;        }        return count;    }     /* Driver function to test the above methods */                       /*         * Use push() to construct below list 1->2->1->3->1         */        push(1);        push(2);        push(1);        push(3);        push(1);         /* Checking count function */        document.write("Count of 1 is " + count(1)); // This code contributed by gauravrajput1</script>
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
count(head, key);
if head is NULL
return frequency
if(head->data==key)
increase frequency by 1
count(head->next, key)
Implementation:  
C++
Java
Python3
C#
Javascript
// C++ program to count occurrences in// a linked list using recursion#include <bits/stdc++.h>using namespace std; /* Link list node */struct Node {    int data;    struct Node* next;};// global variable for counting frequency of// given element kint frequency = 0; /* Given a reference (pointer to pointer) to the headof a list and an int, push a new node on the frontof 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 program to count occurrences in// a linked list using recursionimport java.io.*;import java.util.*; // Represents node of a linkedlistclass 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 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
# Python program to count the number of# time a given int occurs in a linked list# Node classclass 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 Codellist = LinkedList()llist.push(1)llist.push(3)llist.push(1)llist.push(2)llist.push(1) # Check for the count functionprint ("count of 1 is", llist.count(llist.head, 1)) # This code is contributed by# Gaurav Kumar Raghav
// C# program to count occurrences in// a linked list using recursionusing System; // Represents node of a linkedlistpublic 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 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 */
<script> // Javascript program to count occurrences in// a linked list using recursion // Represents node of a linkedlistclass Node{    constructor(val)    {        this.data = val;        this.next = null;    }} // Global variable for counting// frequency of given element klet frequency = 0; /* Given a reference (pointer to pointer)to the head of a list and an int, push anew node on the front of the list. */function push(head, new_data){         // Allocate node    let 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)*/function count(head, key){    if (head == null)        return frequency;    if (head.data == key)        frequency++;             return count(head.next, key);} // Driver code // Start with the empty listlet 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 */document.write("count of 1 is " +               count(head, 1));                // This code is contributed by divyeshrabadiya07 </script>
Output: 
count of 1 is 3
Below method can be used to avoid Global variable ‘frequency'(counter in case of Python 3 Code). 
C++
Java
C#
Python3
Javascript
// 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);}
// 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
// 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
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)
<script> // method can be used to afunction// Global variable 'frequency' /* Counts the no. of occurrences of a node(search_for) in a linked list (head)*/function count(head , 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 todaysgaurav </script>
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)
{
    if(head == NULL)
        return 0;
        
   int frequency = count(head->next, key);
   if(head->data == key)
     return 1 + frequency;
    
    // else 
    return frequency;
}
Time Complexity: O(n)
https://www.youtube.com/watch?v=-g3KauAWofwPlease write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Puneet Jain 1
Shreyash Sharma 3
SivaPrakashReddyKomma
andrew1234
gaurav_kumar_raghav
dkp1903
rathbhupendra
rachana soma
princiraj1992
SHUBHAMSINGH10
nidhi_biet
GauravRajput1
todaysgaurav
anikaseth98
divyeshrabadiya07
khushboogoyal499
amartyaghoshgfg
simranarora5sos
Linked Lists
Linked List
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Delete a Linked List node at a given position
Queue - Linked List Implementation
Implement a stack using singly linked list
Implementing a Linked List in Java using Class
Circular Linked List | Set 1 (Introduction and Applications)
Remove duplicates from a sorted linked list
Find Length of a Linked List (Iterative and Recursive)
Function to check if a singly linked list is palindrome
Search an element in a Linked List (Iterative and Recursive)
Write a function to delete a Linked List