Related Articles

# Probability of finding an element K in a Singly Linked List

• Last Updated : 18 Jun, 2021

Given a Singly Linked List of size N and another key K, we have to find the probability that the key K is present in the Singly Linked List.
Examples:

Input: Linked list = 2 -> 3 -> 3 -> 3 -> 4 -> 2, Key = 5
Output:
Explanation:
Since the value of Key is 5 which is not present in List, the probability of finding the Key in the Linked List is 0.
Input: Linked list = 2 -> 3 -> 5 -> 1 -> 9 -> 8 -> 0 -> 7 -> 6 -> 5, Key = 5
Output: 0.2

Attention reader! All those who say programming isn't for kids, just haven't met the right mentors yet. Join the  Demo Class for First Step to Coding Coursespecifically designed for students of class 8 to 12.

The students will get to learn more about the world of programming in these free classes which will definitely help them in making a wise career choice in the future.

Approach:
The probability of finding a Key element K in a Singly Linked List is given below:

Probability = Number of Occurrences of Element K / Size of the Linked List

In our approach, we will first count the number of Element K present in the Singly Linked List and then the probability will be calculated by dividing the number of occurrences of K by the size of the Singly Linked List.
Below is the implementation of the above approach:

## C

 `// C code to find the probability``// of finding an Element``// in a Singly 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 off the new node``    ``new_node->next = (*head_ref);` `    ``// move the head to point to the new node``    ``(*head_ref) = new_node;``}` `// Counts nnumber of nodes in linked list``int` `getCount(``struct` `Node* head)``{` `    ``// Initialize count``    ``int` `count = 0;` `    ``// Initialize current``    ``struct` `Node* current = head;` `    ``while` `(current != NULL) {``        ``count++;``        ``current = current->next;``    ``}``    ``return` `count;``}` `float` `kPresentProbability(``    ``struct` `Node* head,``    ``int` `n, ``int` `k)``{` `    ``// Initialize count``    ``float` `count = 0;` `    ``// Initialize current``    ``struct` `Node* current = head;` `    ``while` `(current != NULL) {``        ``if` `(current->data == k)``            ``count++;``        ``current = current->next;``    ``}``    ``return` `count / n;``}` `// Driver Code``int` `main()``{``    ``// Start with the empty list``    ``struct` `Node* head = NULL;` `    ``// Use push() to construct below list``    ``// 1->2->1->3->1``    ``push(&head, 2);``    ``push(&head, 3);``    ``push(&head, 5);``    ``push(&head, 1);``    ``push(&head, 9);``    ``push(&head, 8);``    ``push(&head, 0);``    ``push(&head, 7);``    ``push(&head, 6);``    ``push(&head, 5);` `    ``printf``(``"%.1f"``,``           ``kPresentProbability(``               ``head, getCount(head), 5));` `    ``return` `0;``}`

## Java

 `// Java code to find the probability``// of finding an Element``// in a Singly Linked List``class` `GFG{` `// Link list node``static` `class` `Node``{``  ``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.``static` `Node 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;``  ` `  ``return` `head_ref;``}` `// Counts nnumber of nodes``// in linked list``static` `int` `getCount(Node head)``{``  ``// Initialize count``  ``int` `count = ``0``;` `  ``// Initialize current``  ``Node current = head;` `  ``while` `(current != ``null``)``  ``{``    ``count++;``    ``current = current.next;``  ``}``  ``return` `count;``}` `static` `float` `kPresentProbability(Node head,``                                 ``int` `n, ``int` `k)``{``  ``// Initialize count``  ``float` `count = ``0``;` `  ``// Initialize current``  ``Node current = head;` `  ``while` `(current != ``null``)``  ``{``    ``if` `(current.data == k)``      ``count++;``    ``current = current.next;``  ``}``  ``return` `count / n;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Start with the empty list``  ``Node head = ``null``;` `  ``// Use push() to conbelow list``  ``// 1.2.1.3.1``  ``head = push(head, ``2``);``  ``head = push(head, ``3``);``  ``head = push(head, ``5``);``  ``head = push(head, ``1``);``  ``head = push(head, ``9``);``  ``head = push(head, ``8``);``  ``head = push(head, ``0``);``  ``head = push(head, ``7``);``  ``head = push(head, ``6``);``  ``head = push(head, ``5``);` `  ``System.out.printf(``"%.1f"``, kPresentProbability(``                     ``head, getCount(head), ``5``));` `}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 code to find the probability``# of finding an Element``# in a Singly Linked List` `# Node class``class` `Node:``    ` `    ``def` `__init__(``self``, data, ``next` `=` `None``):``        ` `        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `class` `LinkedList:``    ` `    ``def` `__init__(``self``):``        ` `        ``self``.head ``=` `None``    ` `    ``def` `push(``self``, data):``        ` `        ``# Allocate the Node &``        ``# put the data``        ``new_node ``=` `Node(data)``        ` `        ``# Make the next of new Node as head``        ``new_node.``next` `=` `self``.head``        ` `        ``# Move the head to point to new Node``        ``self``.head ``=` `new_node` `    ``# Counts the number of nodes in linkedlist``    ``def` `getCount(``self``):``        ` `        ``# Initialize current``        ``current ``=` `self``.head``        ` `        ``# Initialize count``        ``count ``=` `0``        ` `        ``while` `current ``is` `not` `None``:``            ``count ``+``=` `1``            ``current ``=` `current.``next``        ` `        ``return` `count``    ` `    ``def` `kPresentProbability(``self``, n, k):``        ` `        ``# Initialize current``        ``current ``=` `self``.head``        ` `        ``# Initialize count``        ``count ``=` `0.0``        ` `        ``while` `current ``is` `not` `None``:``            ``if` `current.data ``=``=` `k:``                ``count ``+``=` `1``                ` `            ``current ``=` `current.``next``        ` `        ``return` `count ``/` `n``    ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``# Start with empty list``    ``llist ``=` `LinkedList()``    ` `    ``# Use push to construct the linked list``    ``llist.push(``2``)``    ``llist.push(``3``)``    ``llist.push(``5``)``    ``llist.push(``1``)``    ``llist.push(``9``)``    ``llist.push(``8``)``    ``llist.push(``0``)``    ``llist.push(``7``)``    ``llist.push(``6``)``    ``llist.push(``5``)``    ` `    ``print``(llist.kPresentProbability(``          ``llist.getCount(), ``5``))``    ` `# This code is contributed by kevalshah5   `

## C#

 `// C# code to find the probability``// of finding an Element``// in a Singly Linked List``using` `System;``class` `GFG{` `// Link list node``class` `Node``{``  ``public` `int` `data;``  ``public` `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.``static` `Node 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;``  ` `  ``return` `head_ref;``}` `// Counts nnumber of nodes``// in linked list``static` `int` `getCount(Node head)``{``  ``// Initialize count``  ``int` `count = 0;` `  ``// Initialize current``  ``Node current = head;` `  ``while` `(current != ``null``)``  ``{``    ``count++;``    ``current = current.next;``  ``}``  ``return` `count;``}` `static` `float` `kPresentProbability(Node head,``                                 ``int` `n, ``int` `k)``{``  ``// Initialize count``  ``float` `count = 0;` `  ``// Initialize current``  ``Node current = head;` `  ``while` `(current != ``null``)``  ``{``    ``if` `(current.data == k)``      ``count++;``    ``current = current.next;``  ``}``  ``return` `count / n;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``// Start with the empty list``  ``Node head = ``null``;` `  ``// Use push() to conbelow list``  ``// 1.2.1.3.1``  ``head = push(head, 2);``  ``head = push(head, 3);``  ``head = push(head, 5);``  ``head = push(head, 1);``  ``head = push(head, 9);``  ``head = push(head, 8);``  ``head = push(head, 0);``  ``head = push(head, 7);``  ``head = push(head, 6);``  ``head = push(head, 5);` `  ``Console.Write(``"{0:F1}"``, kPresentProbability(``                 ``head, getCount(head), 5));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output
`0.2`

My Personal Notes arrow_drop_up