Count Occurrences in a Linked List

Last Updated : 13 Aug, 2026

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.

Try It Yourself
redirect icon

Table of Content

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

The idea is to recursively traverse the linked list from the head. At each node, check if its value matches the given key; if it does, increment the count by 1. Then recursively call the function on the next node. When the pointer reaches NULL, return 0.

C++ 
#include <iostream>
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 == nullptr)
        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 
#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 
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 
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# 
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 
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] Iterative Traversal – O(n) time and O(1) space

The idea is to traverse the linked list iteratively from the head, maintaining a counter. For each node, check if its value matches the key; if it does, increment the counter. Continue until the end of the list and return the final count.

C++ 
#include <iostream>
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 != nullptr) {
        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 
#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 
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 
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# 
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 
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
Comment

Explore