Select a Random Node from a tree with equal probability
Last Updated :
18 Nov, 2022
Given a Binary Tree with children Nodes, Return a random Node with an equal Probability of selecting any Node in tree.
Consider the given tree with root as 1.
10
/ \
20 30
/ \ / \
40 50 60 70
Examples:
Input : getRandom(root);
Output : A Random Node From Tree : 3
Input : getRandom(root);
Output : A Random Node From Tree : 2
A simple solution is to store Inorder traversal of tree in an array. Let the count of nodes be n. To get a random node, we generate a random number from 0 to n-1, use this number as index in array and return the value at index.
An alternate solution is to modify tree structure. We store count of children in every node. Consider the above tree. We use inorder traversal here also. We generate a number smaller than or equal count of nodes. We traverse tree and go to the node at that index. We use counts to quickly reach the desired node. With counts, we reach in O(h) time where h is height of tree.
10,6
/ \
20,2 30,2
/ \ / \
40,0 50,0 60,0 70,0
The first value is node and second
value is count of children.
We start traversing the tree, on each node we either go to left subtree or right subtree considering whether the count of children is less than random count or not.
If the random count is less than the count of children then we go left else we go right.
Below is the implementation of above Algorithm. getElements will return count of children for root, InsertChildrenCount inserts children data to each node, RandomNode returns the random node with the help of Utility Function RandomNodeUtil.
Implementation:
C++
// CPP program to Select a Random Node from a tree
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
int children;
Node *left, *right;
};
Node* newNode(int data)
{
Node *temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
temp->children = 0;
return temp;
}
// This is used to fill children counts.
int getElements(Node* root)
{
if (!root)
return 0;
return getElements(root->left) +
getElements(root->right) + 1;
}
// Inserts Children count for each node
void insertChildrenCount(Node*& root)
{
if (!root)
return;
root->children = getElements(root) - 1;
insertChildrenCount(root->left);
insertChildrenCount(root->right);
}
// returns number of children for root
int children(Node* root)
{
if (!root)
return 0;
return root->children + 1;
}
// Helper Function to return a random node
int randomNodeUtil(Node* root, int count)
{
if (!root)
return 0;
if (count == children(root->left))
return root->data;
if (count < children(root->left))
return randomNodeUtil(root->left, count);
return randomNodeUtil(root->right,
count - children(root->left) - 1);
}
// Returns Random node
int randomNode(Node* root)
{
srand(time(0));
int count = rand() % (root->children + 1);
return randomNodeUtil(root, count);
}
int main()
{
// Creating Above Tree
Node* root = newNode(10);
root->left = newNode(20);
root->right = newNode(30);
root->left->right = newNode(40);
root->left->right = newNode(50);
root->right->left = newNode(60);
root->right->right = newNode(70);
insertChildrenCount(root);
cout << "A Random Node From Tree : "
<< randomNode(root) << endl;
return 0;
}
// Java program to Select a Random Node from a tree
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG
{
static class Node
{
int data;
int children;
Node left, right;
}
static Node newNode(int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null;
temp.children = 0;
return temp;
}
// This is used to fill children counts.
static int getElements(Node root)
{
if (root == null)
return 0;
return getElements(root.left) +
getElements(root.right) + 1;
}
// Inserts Children count for each node
static Node insertChildrenCount(Node root)
{
if (root == null)
return null;
root.children = getElements(root) - 1;
root.left = insertChildrenCount(root.left);
root.right = insertChildrenCount(root.right);
return root;
}
// returns number of children for root
static int children(Node root)
{
if (root == null)
return 0;
return root.children + 1;
}
// Helper Function to return a random node
static int randomNodeUtil(Node root, int count)
{
if (root == null)
return 0;
if (count == children(root.left))
return root.data;
if (count < children(root.left))
return randomNodeUtil(root.left, count);
return randomNodeUtil(root.right,
count - children(root.left) - 1);
}
// Returns Random node
static int randomNode(Node root)
{
int count = (int) Math.random() *
(root.children + 1);
return randomNodeUtil(root, count);
}
// Driver Code
public static void main(String args[])
{
// Creating Above Tree
Node root = newNode(10);
root.left = newNode(20);
root.right = newNode(30);
root.left.right = newNode(40);
root.left.right = newNode(50);
root.right.left = newNode(60);
root.right.right = newNode(70);
insertChildrenCount(root);
System.out.println( "A Random Node From Tree : " +
randomNode(root));
}
}
// This code is contributed by Arnab Kundu
# Python3 program to Select a
# Random Node from a tree
from random import randint
class Node:
def __init__(self, data):
self.data = data
self.children = 0
self.left = None
self.right = None
# This is used to fill children counts.
def getElements(root):
if root == None:
return 0
return (getElements(root.left) +
getElements(root.right) + 1)
# Inserts Children count for each node
def insertChildrenCount(root):
if root == None:
return
root.children = getElements(root) - 1
insertChildrenCount(root.left)
insertChildrenCount(root.right)
# Returns number of children for root
def children(root):
if root == None:
return 0
return root.children + 1
# Helper Function to return a random node
def randomNodeUtil(root, count):
if root == None:
return 0
if count == children(root.left):
return root.data
if count < children(root.left):
return randomNodeUtil(root.left, count)
return randomNodeUtil(root.right,
count - children(root.left) - 1)
# Returns Random node
def randomNode(root):
count = randint(0, root.children)
return randomNodeUtil(root, count)
# Driver Code
if __name__ == "__main__":
# Creating Above Tree
root = Node(10)
root.left = Node(20)
root.right = Node(30)
root.left.right = Node(40)
root.left.right = Node(50)
root.right.left = Node(60)
root.right.right = Node(70)
insertChildrenCount(root)
print("A Random Node From Tree :",
randomNode(root))
# This code is contributed by Rituraj Jain
// C# program to Select a Random Node from a tree
using System;
class GFG
{
class Node
{
public int data;
public int children;
public Node left, right;
}
static Node newNode(int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null;
temp.children = 0;
return temp;
}
// This is used to fill children counts.
static int getElements(Node root)
{
if (root == null)
return 0;
return getElements(root.left) +
getElements(root.right) + 1;
}
// Inserts Children count for each node
static Node insertChildrenCount(Node root)
{
if (root == null)
return null;
root.children = getElements(root) - 1;
root.left = insertChildrenCount(root.left);
root.right = insertChildrenCount(root.right);
return root;
}
// returns number of children for root
static int children(Node root)
{
if (root == null)
return 0;
return root.children + 1;
}
// Helper Function to return a random node
static int randomNodeUtil(Node root, int count)
{
if (root == null)
return 0;
if (count == children(root.left))
return root.data;
if (count < children(root.left))
return randomNodeUtil(root.left, count);
return randomNodeUtil(root.right,
count - children(root.left) - 1);
}
// Returns Random node
static int randomNode(Node root)
{
int count = (int) new Random().Next(0, root.children + 1);
return randomNodeUtil(root, count);
}
// Driver Code
public static void Main(String []args)
{
// Creating Above Tree
Node root = newNode(10);
root.left = newNode(20);
root.right = newNode(30);
root.left.right = newNode(40);
root.left.right = newNode(50);
root.right.left = newNode(60);
root.right.right = newNode(70);
insertChildrenCount(root);
Console.Write( "A Random Node From Tree : " +
randomNode(root));
}
}
// This code is contributed by Arnab Kundu
<script>
// JavaScript program to Select a Random Node from a tree
class Node
{
constructor(data)
{
this.data=data;
this.left=this.right=null;
this.children = 0;
}
}
// This is used to fill children counts.
function getElements(root)
{
if (root == null)
return 0;
return getElements(root.left) +
getElements(root.right) + 1;
}
// Inserts Children count for each node
function insertChildrenCount(root)
{
if (root == null)
return null;
root.children = getElements(root) - 1;
root.left = insertChildrenCount(root.left);
root.right = insertChildrenCount(root.right);
return root;
}
// returns number of children for root
function children(root)
{
if (root == null)
return 0;
return root.children + 1;
}
// Helper Function to return a random node
function randomNodeUtil(root,count)
{
if (root == null)
return 0;
if (count == children(root.left))
return root.data;
if (count < children(root.left))
return randomNodeUtil(root.left, count);
return randomNodeUtil(root.right,
count - children(root.left) - 1);
}
// Returns Random node
function randomNode(root)
{
let count = Math.floor(Math.random() *
(root.children + 1));
return randomNodeUtil(root, count);
}
// Driver Code
// Creating Above Tree
let root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.right = new Node(40);
root.left.right = new Node(50);
root.right.left = new Node(60);
root.right.right = new Node(70);
insertChildrenCount(root);
document.write( "A Random Node From Tree : " +
randomNode(root)+"<br>");
// This code is contributed by avanitrachhadiya2155
</script>
OutputA Random Node From Tree : 30
Time Complexity of randomNode is O(h) where h is height of tree. Note that we are either moving to right or to left at a time.
Auxiliary Space: O(h)
Similar Reads
Randomized Algorithms Randomized algorithms in data structures and algorithms (DSA) are algorithms that use randomness in their computations to achieve a desired outcome. These algorithms introduce randomness to improve efficiency or simplify the algorithm design. By incorporating random choices into their processes, ran
2 min read
Random Variable Random variable is a fundamental concept in statistics that bridges the gap between theoretical probability and real-world data. A Random variable in statistics is a function that assigns a real value to an outcome in the sample space of a random experiment. For example: if you roll a die, you can a
10 min read
Binomial Random Variables In this post, we'll discuss Binomial Random Variables.Prerequisite : Random Variables A specific type of discrete random variable that counts how often a particular event occurs in a fixed number of tries or trials. For a variable to be a binomial random variable, ALL of the following conditions mus
8 min read
Randomized Algorithms | Set 0 (Mathematical Background) Conditional Probability Conditional probability P(A | B) indicates the probability of even 'A' happening given that the even B happened.P(A|B) = \frac{P(A\cap B)}{P(B)} We can easily understand above formula using below diagram. Since B has already happened, the sample space reduces to B. So the pro
3 min read
Randomized Algorithms | Set 1 (Introduction and Analysis) What is a Randomized Algorithm? An algorithm that uses random numbers to decide what to do next anywhere in its logic is called a Randomized Algorithm. For example, in Randomized Quick Sort, we use a random number to pick the next pivot (or we randomly shuffle the array). And in Karger's algorithm,
5 min read
Randomized Algorithms | Set 2 (Classification and Applications) We strongly recommend to refer below post as a prerequisite of this. Randomized Algorithms | Set 1 (Introduction and Analysis) Classification Randomized algorithms are classified in two categories. Las Vegas: A Las Vegas algorithm were introduced by Laszlo Babai in 1979. A Las Vegas algorithm is an
13 min read
Randomized Algorithms | Set 3 (1/2 Approximate Median) Time Complexity: We use a set provided by the STL in C++. In STL Set, insertion for each element takes O(log k). So for k insertions, time taken is O (k log k). Now replacing k with c log n =>O(c log n (log (clog n))) =>O (log n (log log n)) How is probability of error less than 2/n2? Algorithm make
2 min read
Easy problems on randomized algorithms
Write a function that generates one of 3 numbers according to given probabilitiesYou are given a function rand(a, b) which generates equiprobable random numbers between [a, b] inclusive. Generate 3 numbers x, y, z with probability P(x), P(y), P(z) such that P(x) + P(y) + P(z) = 1 using the given rand(a,b) function.The idea is to utilize the equiprobable feature of the rand(a,b)
5 min read
Generate 0 and 1 with 25% and 75% probabilityGiven a function rand50() that returns 0 or 1 with equal probability, write a function that returns 1 with 75% probability and 0 with 25% probability using rand50() only. Minimize the number of calls to the rand50() method. Also, the use of any other library function and floating-point arithmetic ar
13 min read
Implement rand3() using rand2()Given a function rand2() that returns 0 or 1 with equal probability, implement rand3() using rand2() that returns 0, 1 or 2 with equal probability. Minimize the number of calls to rand2() method. Also, use of any other library function and floating point arithmetic are not allowed. The idea is to us
6 min read
Birthday ParadoxHow many people must be there in a room to make the probability 100% that at-least two people in the room have same birthday? Answer: 367 (since there are 366 possible birthdays, including February 29). The above question was simple. Try the below question yourself. How many people must be there in
7 min read
Expectation or expected value of an arrayExpectation or expected value of any group of numbers in probability is the long-run average value of repetitions of the experiment it represents. For example, the expected value in rolling a six-sided die is 3.5, because the average of all the numbers that come up in an extremely large number of ro
5 min read
Shuffle a deck of cardsGiven a deck of cards, the task is to shuffle them. Asked in Amazon Interview Prerequisite : Shuffle a given array Algorithm: 1. First, fill the array with the values in order. 2. Go through the array and exchange each element with the randomly chosen element in the range from itself to the end. //
5 min read
Program to generate CAPTCHA and verify userA CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart) is a test to determine whether the user is human or not.So, the task is to generate unique CAPTCHA every time and to tell whether the user is human or not by asking user to enter the same CAPTCHA as generated auto
6 min read
Find an index of maximum occurring element with equal probabilityGiven an array of integers, find the most occurring element of the array and return any one of its indexes randomly with equal probability.Examples: Input: arr[] = [-1, 4, 9, 7, 7, 2, 7, 3, 0, 9, 6, 5, 7, 8, 9] Output: Element with maximum frequency present at index 6 OR Element with maximum frequen
8 min read
Randomized Binary Search AlgorithmWe are given a sorted array A[] of n elements. We need to find if x is present in A or not.In binary search we always used middle element, here we will randomly pick one element in given range.In Binary Search we had middle = (start + end)/2 In Randomized binary search we do following Generate a ran
13 min read
Medium problems on randomized algorithms
Make a fair coin from a biased coinYou are given a function foo() that represents a biased coin. When foo() is called, it returns 0 with 60% probability, and 1 with 40% probability. Write a new function that returns 0 and 1 with a 50% probability each. Your function should use only foo(), no other library method. Solution:Â We know fo
6 min read
Shuffle a given array using Fisher–Yates shuffle AlgorithmGiven an array, write a program to generate a random permutation of array elements. This question is also asked as "shuffle a deck of cards" or "randomize a given array". Here shuffle means that every permutation of array element should be equally likely. Let the given array be arr[]. A simple solut
10 min read
Expected Number of Trials until SuccessConsider the following famous puzzle. In a country, all families want a boy. They keep having babies till a boy is born. What is the expected ratio of boys and girls in the country? This puzzle can be easily solved if we know following interesting result in probability and expectation. If probabilit
6 min read
Strong Password Suggester ProgramGiven a password entered by the user, check its strength and suggest some password if it is not strong. Criteria for strong password is as follows : A password is strong if it has : At least 8 characters At least one special char At least one number At least one upper and one lower case char. Exampl
15 min read
QuickSort using Random PivotingIn this article, we will discuss how to implement QuickSort using random pivoting. In QuickSort we first partition the array in place such that all elements to the left of the pivot element are smaller, while all elements to the right of the pivot are greater than the pivot. Then we recursively call
15+ min read
Operations on Sparse MatricesGiven two sparse matrices (Sparse Matrix and its representations | Set 1 (Using Arrays and Linked Lists)), perform operations such as add, multiply or transpose of the matrices in their sparse form itself. The result should consist of three sparse matrices, one obtained by adding the two input matri
15+ min read
Estimating the value of Pi using Monte CarloMonte Carlo estimation Monte Carlo methods are a broad class of computational algorithms that rely on repeated random sampling to obtain numerical results. One of the basic examples of getting started with the Monte Carlo algorithm is the estimation of Pi. Estimation of Pi The idea is to simulate ra
8 min read
Implement rand12() using rand6() in one lineGiven a function, rand6() that returns random numbers from 1 to 6 with equal probability, implement the one-liner function rand12() using rand6() which returns random numbers from 1 to 12 with equal probability. The solution should minimize the number of calls to the rand6() method. Use of any other
7 min read
Hard problems on randomized algorithms
Generate integer from 1 to 7 with equal probabilityGiven a function foo() that returns integers from 1 to 5 with equal probability, write a function that returns integers from 1 to 7 with equal probability using foo() only. Minimize the number of calls to foo() method. Also, use of any other library function is not allowed and no floating point arit
6 min read
Implement random-0-6-Generator using the given random-0-1-GeneratorGiven a function random01Generator() that gives you randomly either 0 or 1, implement a function that utilizes this function and generate numbers between 0 and 6(both inclusive). All numbers should have same probabilities of occurrence. Examples: on multiple runs, it gives 3 2 3 6 0 Approach : The i
5 min read
Select a random number from stream, with O(1) spaceGiven a stream of numbers, generate a random number from the stream. You are allowed to use only O(1) space and the input is in the form of a stream, so can't store the previously seen numbers. So how do we generate a random number from the whole stream such that the probability of picking any numbe
10 min read
Random number generator in arbitrary probability distribution fashionGiven n numbers, each with some frequency of occurrence. Return a random number with probability proportional to its frequency of occurrence. Example: Let following be the given numbers. arr[] = {10, 30, 20, 40} Let following be the frequencies of given numbers. freq[] = {1, 6, 2, 1} The output shou
11 min read
Reservoir SamplingReservoir sampling is a family of randomized algorithms for randomly choosing k samples from a list of n items, where n is either a very large or unknown number. Typically n is large enough that the list doesn't fit into main memory. For example, a list of search queries in Google and Facebook.So we
11 min read
Linearity of ExpectationPrerequisite: Random Variable This post is about mathematical concepts like expectation, linearity of expectation. It covers one of the required topics to understand Randomized Algorithms. Let us consider the following simple problem. Problem: Given a fair dice with 6 faces, the dice is thrown n tim
4 min read
Introduction and implementation of Karger's algorithm for Minimum CutGiven an undirected and unweighted graph, find the smallest cut (smallest number of edges that disconnects the graph into two components). The input graph may have parallel edges. For example consider the following example, the smallest cut has 2 edges. A Simple Solution use Max-Flow based s-t cut a
15+ min read
Select a Random Node from a Singly Linked ListGiven a singly linked list, select a random node from the linked list (the probability of picking a node should be 1/N if there are N nodes in the list). You are given a random number generator.Below is a Simple Solution Count the number of nodes by traversing the list. Traverse the list again and s
14 min read
Select a Random Node from a tree with equal probabilityGiven a Binary Tree with children Nodes, Return a random Node with an equal Probability of selecting any Node in tree.Consider the given tree with root as 1. 10 / \ 20 30 / \ / \ 40 50 60 70 Examples: Input : getRandom(root); Output : A Random Node From Tree : 3 Input : getRandom(root); Output : A R
8 min read
Freivald’s Algorithm to check if a matrix is product of twoGiven three matrices A, B and C, find if C is a product of A and B. Examples: Input : A = 1 1 1 1 B = 1 1 1 1 C = 2 2 2 2 Output : Yes C = A x B Input : A = 1 1 1 1 1 1 1 1 1 B = 1 1 1 1 1 1 1 1 1 C = 3 3 3 3 1 2 3 3 3 Output : No A simple solution is to find product of A and B and then check if pro
12 min read
Random Acyclic Maze Generator with given Entry and Exit pointGiven two integers N and M, the task is to generate any N * M sized maze containing only 0 (representing a wall) and 1 (representing an empty space where one can move) with the entry point as P0 and exit point P1 and there is only one path between any two movable positions. Note: P0 and P1 will be m
15+ min read