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 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.

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++

// C/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 occurences 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;
}

/* Drier 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 occurences 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;
    }

    /* Drier 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 occurances of a node
    # (seach_for) in a linkded 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)


Output:
count of 1 is 3

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

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.









Writing code in comment? Please use code.geeksforgeeks.org, generate link and share the link here.

  • deepuanand

    Via Tail Recursion…

    int count_n_in_ll(node_t *head,int n)
    {
    static int count = 0;
    if(head == NULL) {
    if(count == 0) {
    printf(“either element not present in list or linklist is emptyn”);
    return -1;
    }
    return count;
    }
    if(head->data == n)
    count++;
    return count_n_in_ll(head->next,n);
    }

  • Sandeep

    public void countRepeated(int n){

    Node main = start;

    int count = 0;

    if(main.getData() == n){ //To check for start node
    count++;
    }

    while(main.getLink() != null){ //To check for remaining nodes excluding //last node

    if(main.getData() == n){
    count++;
    }

    main = main.getLink();
    }

    if(main.getData() == n){ //To check for last node
    count++;
    }

    System.out.println(“The count of repeated number is : ” + count);

    }

  • ravikant

    Common people post questions like these 😛
    They spoil such a good site !!

    • http://www.hate.com student

      what do you mean y common people? Are u a super hero or master of disasters something ? It is because of people like you that good is getting better and bad is getting worst

    • neha2210

      Common people learn and become good programmers. I believe you think you were never a common person!

    • abhishek08aug

      Wow! This is the most uncommon/retarded comment I came across ever on this site. 😀

    • Sudarshan Singh

      Cool..man ..I have also astonished on this post but its ok…even a single person needs it its ok

    • a.rookie.programmer

      this site is for common people.. if u think u are an exceptional programmer either go find a better site or make ur own.. btw thanks gfg for posting this..

  • geeksforgeeks

    @Snehal: Time complexity is definitely O(n) but space complexity is O(1) as we are using constant extra space.

    • Prateek Sharma

      I think Auxiliary space is o(1) but space complexity is o(n)…

       
      /* Paste your code here (You may delete these lines if not writing code) */
       
      • GeeksforGeeks

        Thanks for pointing this out. We have updated the post.

    • Shailedra

      i think Space complexity singly linked list is O(n)

  • Snehal

    I didnt get how it is O(1)?
    anyway we need to traverse the complete linked list to count the occurrence of the element ?if you are assuming
    n==(constant) and so it is o(1) , then it is wrong assumption,becoz at worst/base/avg case u need to move till end of the ll in the approach used by u

  • geeksforgeeks

    @Shikha: Thanks very much for pointing this out. We have corrected the space complexity.

  • http://geeksforgeeks.org/?p=852 Shikha

    Hi,
    Space complexity is O(1) not O(n) here. ( http://geeksforgeeks.org/?p=852 )