Open In App

Count Occurrences in a Linked List

Last Updated : 28 Oct, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a singly linked list and a key, the task is to count the number of occurrences of the given key in the linked list.

Example :

Input : head: 1->2->1->2->1->3->1 , key = 1
Output : 4

Count-Occurrences-in-a-Linked-List_1

Explanation: key equals 1 has 4 occurrences.

Input : head: 1->2->1->2->1, key = 3
Output : 0
Explanation: key equals to 3 has 0 occurrences.

Table of Content

[Naive Approach] By Recursion – O(n) time and O(n) space

The idea is similar to the iterative approach. Here we are using the recursion to check if the node value equals to key or not. Please note that the iterative approach would be better in terms of time and space. The recursive approach can be good fun exercise or a question in an interview / exam.

Below is the implementation of the above approach :

C++ 
// C++ program to count occurrences in
// a linked list by recursion
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;
  	Node(int data) {
        this->data = data;
        this->next = nullptr;
    }
};

// Counts the no. of occurrences of a key 
// in a linked list
int count(struct Node* head, int key) {
    if (head == NULL)
        return 0;
  	
  	int ans = count(head->next, key);
  
    if (head->data == key)
        ans++;
  
    return ans;
}

int main() {
  
    //Hard Coded Linked List 
  	// 1->2->1->2->1

    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(1);
    head->next->next->next = new Node(2);
    head->next->next->next->next = new Node(1);
	
  	int key = 1;

    cout << count(head, key);
    return 0;
}
C 
// C program to count occurrences in
// a linked list by recursion
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

// Counts the number of occurrences of a key
// in a linked list using recursion
int count(struct Node* head, int key) {
    if (head == NULL) {
        return 0;
    }
  
  	int ans = count(head->next, key);
  
    if (head->data == key) {
        ans++;
    }
  
  	return ans;
}

struct Node* createNode(int new_data) {
    struct Node* new_node = 
      (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    return new_node;
}

int main() {
  
    // Hard Coded Linked List 
    // 1->2->1->2->1
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(1);
    head->next->next->next = createNode(2);
    head->next->next->next->next = createNode(1);

    int key = 1;
  
    printf("%d", count(head, key));

    return 0;
}
Java 
// Java program to count occurrences in
// a linked list by recursion
class Node {
    int data;
    Node next;

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

public class GfG {

    // Recursive method to count occurrences of a
  	// value in the linked list
    static int count(Node head, int key) {
        if (head == null) {
            return 0;
        }
      	
      	int ans = count(head.next, key);
      
        if (head.data == key) {
            ans++;
        }
        
      	return ans;
    }

    public static void main(String[] args) {
      
        // Hard coded linked list: 
      	// 1 -> 2 -> 1 -> 2 -> 1
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(1);
        head.next.next.next = new Node(2);
        head.next.next.next.next = new Node(1);

        int key = 1;

        System.out.println(count(head, key));
    }
}
Python 
# Python program to count occurrences in
# a linked list by recursion
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def count(head, key):
    if head is None:
        return 0
      
    ans = count(head.next, key)
    
    if head.data == key:
        ans += 1
    
    return ans

# Hard coded linked list: 
# 1 -> 2 -> 1 -> 2 -> 1
head = Node(1)
head.next = Node(2)
head.next.next = Node(1)
head.next.next.next = Node(2)
head.next.next.next.next = Node(1)

key = 1

print(count(head, key))
C# 
// C# program to count occurrences in
// a linked list by recursion
using System;

class Node {
    public int data;
    public Node next;

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

class GfG {
  
    // Recursive method to count occurrences of
  	// a value in the linked list
    static int Count(Node head, int key) {
        if (head == null) {
            return 0;
        }
      	
      	int ans = Count(head.next, key);
      
        if (head.data == key) {
            ans++;
        }
        
      	return ans;
    }

    static void Main(string[] args) {
      
        // Hard coded linked list: 
      	// 1 -> 2 -> 1 -> 2 -> 1
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(1);
        head.next.next.next = new Node(2);
        head.next.next.next.next = new Node(1);

        int key = 1;
        
        Console.WriteLine(Count(head, key));
    }
}
JavaScript 
// Javascript program to count occurrences in
// a linked list by recursion
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Recursive function to count occurrences of a 
// value in the linked list
function count(head, key) {
    if (head === null) {
        return 0;
    }
    
    let ans = count(head.next, key);
    
    if (head.data === key) {
        ans++;
    }
    
    return ans;
}

// Hard coded linked list:
// 1 -> 2 -> 1 -> 2 -> 1
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(1);
head.next.next.next = new Node(2);
head.next.next.next.next = new Node(1);

let key = 1;

console.log( count(head, key));

Output
3


[Expected Approach] By Traversing each node – O(n) time and O(1) space

The idea is to traverse through the each node of linked list and check if the node data is equal to the key or not. If it is equal to key we will increment the count.

Below is the implementation of the above approach:

C++ 
// C++ program to count occurrences in a
// linked list
#include <bits/stdc++.h>
using namespace std;
class Node {
  public:
    int data;
    Node *next;
    Node(int data) {
        this->data = data;
        this->next = nullptr;
    }
};

//Counts the no. of occurrences of a 
// key in a linked list 
int count(Node *head, int key) {
    Node *curr = head;
    int count = 0;
    while (curr != NULL) {
        if (curr->data == key) {
            count++;
        }
        curr = curr->next;
    }
    return count;
}

int main() {
  
    // Hard Coded Linked List
    // 1->2->1->2->1
    Node *head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(1);
    head->next->next->next = new Node(2);
    head->next->next->next->next = new Node(1);

    int key = 1;
    cout << count(head, key);
    return 0;
}
C 
// C program to count occurrences in 
// a linked list
#include <stdio.h>

struct Node {
    int data;
    struct Node *next;
};

//Counts the no. of occurrences of a 
// key in a linked list 
int count(struct Node *head, int key) {
    struct Node *curr = head;
    int count = 0;
    while (curr != NULL) {
        if (curr->data == key)
            count++;
        curr = curr->next;
    }
    return count;
}

struct Node *createNode(int new_data) {
    struct Node *new_node = 
      (struct Node *)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    return new_node;
}
int main() {
  
    // Hard Coded Linked List
    // 1->2->1->2->1
    struct Node *head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(1);
    head->next->next->next = createNode(2);
    head->next->next->next->next = createNode(1);

    int key = 1;
    printf("%d", count(head, key));
    return 0;
}
Java 
// C program to count occurrences in
// a linked list
class Node {
    int data;
    Node next;

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

public class GfG {

    // Method to count occurrences of a value in the linked
    // list
    static int count(Node head, int key) {
        Node curr = head;
        int count = 0;
        while (curr != null) {
            if (curr.data == key) {
                count++;
            }
            curr = curr.next;
        }
        return count;
    }

    public static void main(String[] args) {
      
        // Hard coded linked list: 1 -> 2 -> 1 -> 2 -> 1
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(1);
        head.next.next.next = new Node(2);
        head.next.next.next.next = new Node(1);

        int key = 1;
        System.out.println(count(head, key));
    }
}
Python 
# Python program to count occurrences in
# a linked list
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def count(head, key):
    curr = head
    count = 0
    while curr is not None:
        if curr.data == key:
            count += 1
        curr = curr.next
    return count

# Hard coded linked list:
# 1 -> 2 -> 1 -> 2 -> 1 
head = Node(1)
head.next = Node(2)
head.next.next = Node(1)
head.next.next.next = Node(2)
head.next.next.next.next = Node(1)

key = 1

print(count(head, key))
C# 
// C# program to count occurrences in
// a linked list
using System;

class Node {
    public int data;
    public Node next;

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

class GfG {

    // Method to count occurrences of a value
  	// in the linked list
    static int Count(Node head, int key) {
        Node curr = head;
        int count = 0;
        while (curr != null) {
            if (curr.data == key) {
                count++;
            }
            curr = curr.next;
        }
        return count;
    }

    static void Main(string[] args) {
      
        // Hard coded linked list: 
      	// 1 -> 2 -> 1 -> 2 -> 1
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(1);
        head.next.next.next = new Node(2);
        head.next.next.next.next = new Node(1);

        int key = 1;
        Console.WriteLine(Count(head, key));
    }
}
JavaScript 
// Javascript program to count occurrences in
// a linked list
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Function to count occurrences of 
// a value in the linked list
function count(head, key) {
    let curr = head;
    let count = 0;
    while (curr !== null) {
        if (curr.data === key) {
            count++;
        }
        curr = curr.next;
    }
    return count;
}

// Hard coded linked list:
// 1 -> 2 -> 1 -> 2 -> 1
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(1);
head.next.next.next = new Node(2);
head.next.next.next.next = new Node(1);

let key = 1;
console.log(count(head, key));

Output
3

Next Article
Count Occurrences in a Linked List

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox