Select a Random Node from a Singly Linked List
Last Updated :
13 Apr, 2023
Given 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 select every node with a probability of 1/N. The selection can be done by generating a random number from 0 to N-i for the node, and selecting the i'th node only if the generated number is equal to 0 (or any other fixed number from 0 to N-i).
We get uniform probabilities with the above schemes.
i = 1, probability of selecting first node = 1/N
i = 2, probability of selecting second node =
[probability that first node is not selected] *
[probability that second node is selected]
= ((N-1)/N)* 1/(N-1)
= 1/N
Similarly, the probability of other selecting other nodes is 1/N
The above solution requires two traversals of the linked list.
How to select a random node with only one traversal allowed?
The idea is to use Reservoir Sampling. Following are the steps. This is a simpler version of Reservoir Sampling as we need to select only one key instead of the k keys.
(1) Initialize result as first node
result = head->key
(2) Initialize n = 2
(3) Now one by one consider all nodes from 2nd node onward.
(3.a) Generate a random number from 0 to n-1.
Let the generated random number is j.
(3.b) If j is equal to 0 (we could choose other fixed number
between 0 to n-1), then replace result with current node.
(3.c) n = n+1
(3.d) current = current->next
Below is the implementation of the above algorithm.
C++
/* C++ program to randomly select a node from a singly
linked list */
#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#include<iostream>
using namespace std;
/* Link list node */
class Node
{
public:
int key;
Node* next;
void printRandom(Node*);
void push(Node**, int);
};
// A reservoir sampling based function to print a
// random node from a linked list
void Node::printRandom(Node *head)
{
// IF list is empty
if (head == NULL)
return;
// Use a different seed value so that we don't get
// same result each time we run this program
srand(time(NULL));
// Initialize result as first node
int result = head->key;
// Iterate from the (k+1)th element to nth element
Node *current = head;
int n;
for (n = 2; current != NULL; n++)
{
// change result with probability 1/n
if (rand() % n == 0)
result = current->key;
// Move to next node
current = current->next;
}
cout<<"Randomly selected key is \n"<< result;
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST */
/* A utility function to create a new node */
Node* newNode(int new_key)
{
// allocate node
Node* new_node = (Node*) malloc(sizeof( Node));
/// put in the key
new_node->key = new_key;
new_node->next = NULL;
return new_node;
}
/* A utility function to insert a node at the beginning
of linked list */
void Node:: push(Node** head_ref, int new_key)
{
/* allocate node */
Node* new_node = new Node;
/* put in the key */
new_node->key = new_key;
/* link the old list of the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
Node n1;
Node *head = NULL;
n1.push(&head, 5);
n1.push(&head, 20);
n1.push(&head, 4);
n1.push(&head, 3);
n1.push(&head, 30);
n1.printRandom(head);
return 0;
}
// This code is contributed by SoumikMondal
C
/* C program to randomly select a node from a singly
linked list */
#include<stdio.h>
#include<stdlib.h>
#include <time.h>
/* Link list node */
struct Node
{
int key;
struct Node* next;
};
// A reservoir sampling based function to print a
// random node from a linked list
void printRandom(struct Node *head)
{
// IF list is empty
if (head == NULL)
return;
// Use a different seed value so that we don't get
// same result each time we run this program
srand(time(NULL));
// Initialize result as first node
int result = head->key;
// Iterate from the (k+1)th element to nth element
struct Node *current = head;
int n;
for (n=2; current!=NULL; n++)
{
// change result with probability 1/n
if (rand() % n == 0)
result = current->key;
// Move to next node
current = current->next;
}
printf("Randomly selected key is %d\n", result);
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST */
/* A utility function to create a new node */
struct Node *newNode(int new_key)
{
/* allocate node */
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));
/* put in the key */
new_node->key = new_key;
new_node->next = NULL;
return new_node;
}
/* A utility function to insert a node at the beginning
of linked list */
void push(struct Node** head_ref, int new_key)
{
/* allocate node */
struct Node* new_node = new Node;
/* put in the key */
new_node->key = new_key;
/* link the old list of the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct Node *head = NULL;
push(&head, 5);
push(&head, 20);
push(&head, 4);
push(&head, 3);
push(&head, 30);
printRandom(head);
return 0;
}
Java
// Java program to select a random node from singly linked list
import java.util.*;
// Linked List Class
class LinkedList {
static Node head; // head of list
/* Node Class */
static class Node {
int data;
Node next;
// Constructor to create a new node
Node(int d) {
data = d;
next = null;
}
}
// A reservoir sampling based function to print a
// random node from a linked list
void printrandom(Node node) {
// If list is empty
if (node == null) {
return;
}
// Use a different seed value so that we don't get
// same result each time we run this program
Math.abs(UUID.randomUUID().getMostSignificantBits());
// Initialize result as first node
int result = node.data;
// Iterate from the (k+1)th element to nth element
Node current = node;
int n;
for (n = 2; current != null; n++) {
// change result with probability 1/n
if (Math.random() % n == 0) {
result = current.data;
}
// Move to next node
current = current.next;
}
System.out.println("Randomly selected key is " + result);
}
// Driver program to test above functions
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.head = new Node(5);
list.head.next = new Node(20);
list.head.next.next = new Node(4);
list.head.next.next.next = new Node(3);
list.head.next.next.next.next = new Node(30);
list.printrandom(head);
}
}
// This code has been contributed by Mayank Jaiswal
Python3
# Python program to randomly select a node from singly
# linked list
import random
# 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
# A reservoir sampling based function to print a
# random node from a linked list
def printRandom(self):
# If list is empty
if self.head is None:
return
if self.head and not self.head.next:
print("Randomly selected key is %d" %(self.head.data))
# Use a different seed value so that we don't get
# same result each time we run this program
random.seed()
# Initialize result as first node
result = self.head.data
# Iterate from the (k+1)th element nth element
# because we iterate from (k+1)th element, or
# the first node will be picked more easily
current = self.head.next
n = 2
while(current is not None):
# change result with probability 1/n
if (random.randrange(n) == 0 ):
result = current.data
# Move to next node
current = current.next
n += 1
print("Randomly selected key is %d" %(result))
# 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 LinkedList
def printList(self):
temp = self.head
while(temp):
print(temp.data,end=" ")
temp = temp.next
# Driver program to test above function
llist = LinkedList()
llist.push(5)
llist.push(20)
llist.push(4)
llist.push(3)
llist.push(30)
llist.printRandom()
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)
C#
// C# program to select a random node
// from singly linked list
using System;
// Linked List Class
public class LinkedList
{
Node head; // head of list
/* Node Class */
public class Node
{
public int data;
public Node next;
// Constructor to create a new node
public Node(int d)
{
data = d;
next = null;
}
}
// A reservoir sampling based function to print a
// random node from a linked list
void printrandom(Node node)
{
// If list is empty
if (node == null)
{
return;
}
// Use a different seed value so that we don't get
// same result each time we run this program
//Math.abs(UUID.randomUUID().getMostSignificantBits());
// Initialize result as first node
int result = node.data;
// Iterate from the (k+1)th element to nth element
Node current = node;
int n;
for (n = 2; current != null; n++)
{
// change result with probability 1/n
if (new Random().Next() % n == 0)
{
result = current.data;
}
// Move to next node
current = current.next;
}
Console.WriteLine("Randomly selected key is " +
result);
}
// Driver Code
public static void Main(String[] args)
{
LinkedList list = new LinkedList();
list.head = new Node(5);
list.head.next = new Node(20);
list.head.next.next = new Node(4);
list.head.next.next.next = new Node(3);
list.head.next.next.next.next = new Node(30);
list.printrandom(list.head);
}
}
// This code is contributed by 29AjayKumar
JavaScript
<script>
// Javascript program to select a random node
// from singly linked list
/* Node Class */
class Node
{
constructor(d)
{
this.data=d;
this.next = null;
}
}
// A reservoir sampling based function to print a
// random node from a linked list
function printrandom(node)
{
// If list is empty
if (node == null) {
return;
}
// Use a different seed value so that we don't get
// same result each time we run this program
//Math.abs(UUID.randomUUID().getMostSignificantBits());
// Initialize result as first node
let result = node.data;
// Iterate from the (k+1)th element to nth element
let current = node;
let n;
for (n = 2; current != null; n++) {
// change result with probability 1/n
if (Math.floor(Math.random()*n) == 0) {
result = current.data;
}
// Move to next node
current = current.next;
}
document.write("Randomly selected key is <br>" +
result+"<br>");
}
// Driver program to test above functions
head = new Node(5);
head.next = new Node(20);
head.next.next = new Node(4);
head.next.next.next = new Node(3);
head.next.next.next.next = new Node(30);
printrandom(head);
// This code is contributed by rag2127
</script>
OutputRandomly selected key is
4
Time Complexity: O(n), as we are using a loop to traverse n times. Where n is the number of nodes in the linked list.
Auxiliary Space: O(1), as we are not using any extra space.
Note that the above program is based on the outcome of a random function and may produce different outputs.
How does this work?
Let there be total N nodes in the list. It is easier to understand from the last node.
The probability that the last node is result simply 1/N [For the last or N'th node, we generate a random number between 0 to N-1 and make the last node as the result if the generated number is 0 (or any other fixed number]
The probability that the second last node is the result should also be 1/N.
The probability that the second last node is result
= [Probability that the second last node replaces result] X
[Probability that the last node doesn't replace the result]
= [1 / (N-1)] * [(N-1)/N]
= 1/N
Similarly, we can show the probability for 3rd last node and other nodes.
Another approach Using rand() Function:
Here in this Approach, we convert linked list to vector by storing every node value and than we apply rand() function on them and return the random node value.
Approach/Intuition:
here given linked list :
- 5 -> 20 -> 4 -> 3 -> 30.
- we traverse over linked list and convert it into vector.
- vector<int>v{5,20,4,3,30};
- than we use rand() function.
- int n=v.size() //size of the vector.
- int RandomIndex=rand() % n;
- and at the end we will return random node value from singly linked list.
Below is the code to implement the above approach:
C++
/* C++ program to randomly select a node from a singly
linked list */
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
/* Link list node */
class Node {
public:
int key;
Node* next;
void printRandom(Node*);
void push(Node**, int);
};
Node* newNode(int new_key)
{
// allocate node
Node* new_node = (Node*)malloc(sizeof(Node));
/// put in the key
new_node->key = new_key;
new_node->next = NULL;
return new_node;
}
/* A utility function to insert a node at the beginning
of linked list */
void Node::push(Node** head_ref, int new_key)
{
/* allocate node */
Node* new_node = new Node;
/* put in the key */
new_node->key = new_key;
/* link the old list of the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
void printRandom(Node* head)
{
Node* temp = head;
vector<int> v;
while (temp != NULL) {
v.push_back(temp->key);
temp = temp->next;
}
int n = v.size();
int randIndex = rand() % n;
cout << v[randIndex] << endl;
}
// Driver's code
int main()
{
Node n1;
Node* head = NULL;
n1.push(&head, 5);
n1.push(&head, 20);
n1.push(&head, 4);
n1.push(&head, 3);
n1.push(&head, 30);
// function call
printRandom(head);
// code & approach contributed by Sanket Gode.
return 0;
}
Java
/*package whatever //do not write package name here */
import java.io.*;
import java.util.*;
// Node of Linkedlist
class Node {
int key;
Node next;
Node(int key)
{
this.key = key;
this.next = null;
}
}
class GFG {
// Function to Print Random Values
public static void printRandom(Node head)
{
Node temp = head;
ArrayList<Integer> list = new ArrayList<Integer>();
while (temp != null) {
list.add(temp.key);
temp = temp.next;
}
int n = list.size();
Random rand = new Random();
int randIndex = rand.nextInt(n);
System.out.println(list.get(randIndex));
}
// Drivers Code
public static void main(String[] args)
{
// Making List
Node head = new Node(30);
head.next = new Node(3);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
head.next.next.next.next = new Node(5);
// Calling Function
printRandom(head);
// This Code is Contributed By Vikas Bishnoi
}
}
Python3
import random
# Link list node
class Node:
def __init__(self):
self.key = 0
self.next = None
def push(self, head_ref, new_key):
# allocate node
new_node = Node()
# put in the key
new_node.key = new_key
# link the old list of the new node
new_node.next = head_ref
# move the head to point to the new node
head_ref = new_node
return head_ref
@staticmethod
def printRandom(head):
temp = head
v = []
while temp != None:
v.append(temp.key)
temp = temp.next
n = len(v)
randIndex = random.randint(0, n-1)
print(v[randIndex])
# Driver's code
if __name__ == '__main__':
n1 = Node()
head = None
head = n1.push(head, 5)
head = n1.push(head, 20)
head = n1.push(head, 4)
head = n1.push(head, 3)
head = n1.push(head, 30)
# function call
Node.printRandom(head)
C#
using System;
using System.Collections.Generic;
// Node of Linkedlist
public class Node {
public int key;
public Node next;
public Node(int key)
{
this.key = key;
this.next = null;
}
}
public class GFG {
// Function to Print Random Values
public static void printRandom(Node head)
{
Node temp = head;
List<int> list = new List<int>();
while (temp != null) {
list.Add(temp.key);
temp = temp.next;
}
int n = list.Count;
Random rand = new Random();
int randIndex = rand.Next(n);
Console.WriteLine(list[randIndex]);
}
// Drivers Code
public static void Main()
{
// Making List
Node head = new Node(30);
head.next = new Node(3);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
head.next.next.next.next = new Node(5);
// Calling Function
printRandom(head);
}
}
JavaScript
// import random
const val = 7;
// Link list node
class Node{
constructor(){
this.key = 0;
this.next = null;
}
push(head_ref, new_key){
// allocate node
let new_node = new Node();
// put in the key
new_node.key = new_key;
// link the old list of the new node
new_node.next = head_ref;
// move the head to point to the new node
head_ref = new_node;
return head_ref;
}
printRandom(head){
let temp = head;
let v = [];
while(temp != null){
v.push(temp.key);
temp = temp.key;
}
let n = v.length;
let randIndex = Math.floor((Math.random() * (n-1)));
console.log(Math.floor(v[randIndex]/val));
}
}
// Driver's code
n1 = new Node()
head = null
head = n1.push(head, 5)
head = n1.push(head, 20)
head = n1.push(head, 4)
head = n1.push(head, 3)
head = n1.push(head, 30)
// function call
n1.printRandom(head)
// The code is contributed by Nidhi goel.
Complexity Analysis:
Time Complexity: O(n).
Space Complexity:O(n).
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 probabilities
You 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% probability
Given 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 Paradox
How 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 array
Expectation 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 cards
Given 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 user
A 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 probability
Given 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 Algorithm
We 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 coin
You 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 Algorithm
Given 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 Success
Consider 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 Program
Given 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 Pivoting
In 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 Matrices
Given 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 Carlo
Monte 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 line
Given 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 probability
Given 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-Generator
Given 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) space
Given 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 fashion
Given 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 Sampling
Reservoir 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 Expectation
Prerequisite: 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 Cut
Given 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 List
Given 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 probability
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 R
8 min read
Freivaldâs Algorithm to check if a matrix is product of two
Given 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 point
Given 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