Sort elements by frequency using Binary Search Tree
Last Updated :
05 Mar, 2025
Given an array of integers arr[], sort the array according to the frequency of elements, i.e. elements that have higher frequency comes first. If the frequencies of two elements are the same, then the smaller number comes first.
Examples:
Input: arr[] = [5, 5, 4, 6, 4]
Output: [4, 4, 5, 5, 6]
Explanation: The highest frequency here is 2. Both 5 and 4 have that frequency. Now since the frequencies are the same the smaller element comes first. So 4 comes first then comes 5. Finally comes 6. The output is 4 4 5 5 6.
Input: arr[] = [9, 9, 9, 2, 5]
Output: [9, 9, 9, 2, 5]
Explanation: The highest frequency here is 3. Element 9 has the highest frequency So 9 comes first. Now both 2 and 5 have the same frequency. So we print smaller elements first. The output is 9 9 9 2 5.
Note: We have discussed the multiple approaches to solve this problem in article Sort Elements by Frequency. In this article we've discussed an approach using binary search tree.
Using Binary Search Tree - O(n ^ 2) Time and O(n) Space
The idea is to use Binary Search Tree to efficiently store the elements and their frequency in the form of tree nodes. And thereafter store the value - frequency pair in a 2d array and sort it according to the frequency.
Follow the below given steps:
- Create a Binary Search Tree (BST) and, as you insert each element, maintain a count (frequency) of that element in the same BST.
- Perform an inorder traversal of the BST. During the traversal, store each unique element along with its frequency as a pair in an auxiliary array called freq[].
- Sort the freq[] array according to the frequency of the elements.
- Traverse through the sorted count[] array and, for each element x with frequency freq, print x exactly freq times.
Below is given the implementation:
C++
#include <bits/stdc++.h>
using namespace std;
// BST Node Structure
class Node {
public:
int data;
int freq;
Node *left;
Node *right;
Node(int data) {
this->data = data;
this->freq = 1;
this->left = nullptr;
this->right = nullptr;
}
};
// to store the element in BST
Node* insert(Node* root, int data) {
// base case: if the data
// is not present in the BST
if (root == nullptr)
return new Node(data);
// if the data is already present
// in the BST, increment the frequency
if (data == root->data)
root->freq += 1;
// if the data is less than the root
// data, recur for the left subtree
else if (data < root->data)
root->left = insert(root->left, data);
// if the data is more than the root
// data, recur for the right subtree
else
root->right = insert(root->right, data);
return root;
}
// Function to store the frequency of each element
void store(Node *root, vector<vector<int>> &freq) {
// Base Case
if (root == nullptr) return;
// Recur for left subtree
store(root->left, freq);
// Store item from root in freq
freq.push_back({root->freq, root->data});
// Recur for right subtree
store(root->right, freq);
}
// Function to sort the array
// according to frequency of elements
vector<int> sortByFreq(vector<int> &arr) {
int n = arr.size();
// create bst and insert all elements
Node *root = nullptr;
for(int i = 0; i < n; i++) {
root = insert(root, arr[i]);
}
// create a 2d vector to store
// the frequency of each element
vector<vector<int>> freq;
// to sort the frequency in descending order
auto comp = [&](vector<int> &a, vector<int> &b)
{
if (a[0] == b[0])
return a[1] < b[1];
return a[0] > b[0];
};
// store the frequency and the element
store(root, freq);
// sort the frequency array
sort(freq.begin(), freq.end(), comp);
// to store the answer
vector<int> ans;
// push the elements in the answer array
for(int i = 0; i < freq.size(); i++) {
for(int j = 0; j < freq[i][0]; j++) {
ans.push_back(freq[i][1]);
}
}
return ans;
}
int main() {
vector<int> arr = {5, 5, 4, 6, 4};
vector<int> ans = sortByFreq(arr);
for(int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
import java.util.*;
// Node structure
class Node {
int data;
int freq;
Node left;
Node right;
Node(int data) {
this.data = data;
this.freq = 1;
this.left = null;
this.right = null;
}
}
// Function to store the element in BST
class GfG {
static Node insert(Node root, int data) {
// base case: if the data
// is not present in the BST
if (root == null)
return new Node(data);
// if the data is already present
// in the BST, increment the frequency
if (data == root.data)
root.freq += 1;
// if the data is less than the root
// data, recur for the left subtree
else if (data < root.data)
root.left = insert(root.left, data);
// if the data is more than the root
// data, recur for the right subtree
else
root.right = insert(root.right, data);
return root;
}
// Function to store the frequency of each element
static void store(Node root, ArrayList<ArrayList<Integer>> freq) {
// Base Case
if (root == null)
return;
// Recur for left subtree
store(root.left, freq);
// Store item from root in freq
ArrayList<Integer> temp = new ArrayList<>();
temp.add(root.freq);
temp.add(root.data);
freq.add(temp);
// Recur for right subtree
store(root.right, freq);
}
// Function to sort the array
// according to frequency of elements
static ArrayList<Integer> sortByFreq(int[] arr) {
int n = arr.length;
// create bst and insert all elements
Node root = null;
for (int i = 0; i < n; i++) {
root = insert(root, arr[i]);
}
// create a 2d vector to store
// the frequency of each element
ArrayList<ArrayList<Integer>> freq = new ArrayList<>();
// store the frequency and the element
store(root, freq);
// to sort the frequency in descending order
Comparator<ArrayList<Integer>> comp =
new Comparator<ArrayList<Integer>>() {
public int compare(ArrayList<Integer> a, ArrayList<Integer> b) {
if (a.get(0).equals(b.get(0)))
return a.get(1) - b.get(1);
return b.get(0) - a.get(0);
}
};
Collections.sort(freq, comp);
// to store the answer
ArrayList<Integer> ans = new ArrayList<>();
// push the elements in the answer array
for (int i = 0; i < freq.size(); i++) {
for (int j = 0; j < freq.get(i).get(0); j++) {
ans.add(freq.get(i).get(1));
}
}
return ans;
}
public static void main(String[] args) {
int[] arr = {5, 5, 4, 6, 4};
ArrayList<Integer> ans = sortByFreq(arr);
for (int i = 0; i < ans.size(); i++) {
System.out.print(ans.get(i) + " ");
}
}
}
# Node structure
class Node:
def __init__(self, data):
self.data = data
self.freq = 1
self.left = None
self.right = None
# to store the element in BST
def insert(root, data):
# base case: if the data
# is not present in the BST
if root is None:
return Node(data)
# if the data is already present
# in the BST, increment the frequency
if data == root.data:
root.freq += 1
# if the data is less than the root
# data, recur for the left subtree
elif data < root.data:
root.left = insert(root.left, data)
# if the data is more than the root
# data, recur for the right subtree
else:
root.right = insert(root.right, data)
return root
# Function to store the frequency of each element
def store(root, freq):
# Base Case
if root is None:
return
# Recur for left subtree
store(root.left, freq)
# Store item from root in freq
freq.append([root.freq, root.data])
# Recur for right subtree
store(root.right, freq)
# Function to sort the array
# according to frequency of elements
def sortByFreq(arr):
n = len(arr)
# create bst and insert all elements
root = None
for i in range(n):
root = insert(root, arr[i])
# create a 2d vector to store
# the frequency of each element
freq = []
# store the frequency and the element
store(root, freq)
# to sort the frequency in descending order
freq.sort(key=lambda a: (-a[0], a[1]))
# to store the answer
ans = []
# push the elements in the answer array
for i in range(len(freq)):
for j in range(freq[i][0]):
ans.append(freq[i][1])
return ans
if __name__ == "__main__":
arr = [5, 5, 4, 6, 4]
ans = sortByFreq(arr)
for i in range(len(ans)):
print(ans[i], end=" ")
// Node structure
using System;
using System.Collections.Generic;
class Node {
public int data;
public int freq;
public Node left;
public Node right;
public Node(int data) {
this.data = data;
this.freq = 1;
this.left = null;
this.right = null;
}
}
class GfG {
// to store the element in BST
static Node insert(Node root, int data) {
// base case: if the data
// is not present in the BST
if (root == null)
return new Node(data);
// if the data is already present
// in the BST, increment the frequency
if (data == root.data)
root.freq += 1;
// if the data is less than the root
// data, recur for the left subtree
else if (data < root.data)
root.left = insert(root.left, data);
// if the data is more than the root
// data, recur for the right subtree
else
root.right = insert(root.right, data);
return root;
}
// Function to store the frequency of each element
static void store(Node root, List<List<int>> freq) {
// Base Case
if (root == null)
return;
// Recur for left subtree
store(root.left, freq);
// Store item from root in freq
List<int> temp = new List<int>();
temp.Add(root.freq);
temp.Add(root.data);
freq.Add(temp);
// Recur for right subtree
store(root.right, freq);
}
// Function to sort the array
// according to frequency of elements
static List<int> sortByFreq(int[] arr) {
int n = arr.Length;
// create bst and insert all elements
Node root = null;
for (int i = 0; i < n; i++) {
root = insert(root, arr[i]);
}
// create a 2d vector to store
// the frequency of each element
List<List<int>> freq = new List<List<int>>();
// store the frequency and the element
store(root, freq);
// to sort the frequency in descending order
freq.Sort((a, b) => {
if (a[0] == b[0])
return a[1].CompareTo(b[1]);
return b[0].CompareTo(a[0]);
});
// to store the answer
List<int> ans = new List<int>();
// push the elements in the answer array
for (int i = 0; i < freq.Count; i++) {
for (int j = 0; j < freq[i][0]; j++) {
ans.Add(freq[i][1]);
}
}
return ans;
}
static void Main() {
int[] arr = {5, 5, 4, 6, 4};
List<int> ans = sortByFreq(arr);
foreach (int i in ans) {
Console.Write(i + " ");
}
}
}
// Node structure
class Node {
constructor(data) {
this.data = data;
this.freq = 1;
this.left = null;
this.right = null;
}
}
// to store the element in BST
function insert(root, data) {
// base case: if the data
// is not present in the BST
if (root === null)
return new Node(data);
// if the data is already present
// in the BST, increment the frequency
if (data === root.data)
root.freq += 1;
// if the data is less than the root
// data, recur for the left subtree
else if (data < root.data)
root.left = insert(root.left, data);
// if the data is more than the root
// data, recur for the right subtree
else
root.right = insert(root.right, data);
return root;
}
// Function to store the frequency of each element
function store(root, freq) {
// Base Case
if (root === null)
return;
// Recur for left subtree
store(root.left, freq);
// Store item from root in freq
freq.push([root.freq, root.data]);
// Recur for right subtree
store(root.right, freq);
}
// Function to sort the array
// according to frequency of elements
function sortByFreq(arr) {
let n = arr.length;
// create bst and insert all elements
let root = null;
for (let i = 0; i < n; i++) {
root = insert(root, arr[i]);
}
// create a 2d vector to store
// the frequency of each element
let freq = [];
// store the frequency and the element
store(root, freq);
// to sort the frequency in descending order
freq.sort((a, b) => {
if (a[0] === b[0])
return a[1] - b[1];
return b[0] - a[0];
});
// to store the answer
let ans = [];
// push the elements in the answer array
for (let i = 0; i < freq.length; i++) {
for (let j = 0; j < freq[i][0]; j++) {
ans.push(freq[i][1]);
}
}
return ans;
}
let arr = [5, 5, 4, 6, 4];
let ans = sortByFreq(arr);
console.log(ans.join(" "));
Time Complexity: O(n ^ 2), in the worst case when given array is sorted, the skewed tree will be formed that takes O(n) time to store the elements, and we are storing n elements, thus the overall time complexity will be O(n ^ 2).
Auxiliary Space: O(n), to store the elements in BST and freq[] array.
Using Self Balancing Binary Search Tree - O(n * log n) Time and O(n) Space
The idea is to use self balancing binary search tree (AVL Tree or Red Black Tree), that offers O(log n) insertion time complexity even in the worst case.
C++, Java and C# seem to have built-in implementations of a self balancing in BST. We have implemented our own AVL tree in Python and JavaScript.
C++
#include <bits/stdc++.h>
using namespace std;
// Function to sort the array
// according to frequency of elements
vector<int> sortByFreq(vector<int> &arr) {
int n = arr.size();
// hash map to store the
// frequency of each element
map<int, int> mp;
// store the frequency of each element
for(int i = 0; i < n; i++) {
mp[arr[i]]++;
}
// create a 2d vector to store
// the frequency of each element
vector<vector<int>> freq;
// to sort the frequency in descending order
auto comp = [&](vector<int> &a, vector<int> &b)
{
if (a[0] == b[0])
return a[1] < b[1];
return a[0] > b[0];
};
// store the frequency and the element
for(auto i : mp) {
freq.push_back({i.second, i.first});
}
// sort the frequency array
sort(freq.begin(), freq.end(), comp);
// to store the answer
vector<int> ans;
// push the elements in the answer array
for(int i = 0; i < freq.size(); i++) {
for(int j = 0; j < freq[i][0]; j++) {
ans.push_back(freq[i][1]);
}
}
return ans;
}
int main() {
vector<int> arr = {5, 5, 4, 6, 4};
vector<int> ans = sortByFreq(arr);
for(int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
// Function to sort the array
// according to frequency of elements
import java.util.*;
class GfG {
// Function to sort the array
// according to frequency of elements
static ArrayList<Integer> sortByFreq(int[] arr) {
int n = arr.length;
// hash map to store the
// frequency of each element
TreeMap<Integer, Integer> mp = new TreeMap<>();
for (int i = 0; i < n; i++) {
mp.put(arr[i], mp.getOrDefault(arr[i], 0) + 1);
}
// create a 2d vector to store
// the frequency of each element
ArrayList<ArrayList<Integer>> freq = new ArrayList<>();
for (Map.Entry<Integer, Integer> entry : mp.entrySet()) {
ArrayList<Integer> pair = new ArrayList<>();
pair.add(entry.getValue());
pair.add(entry.getKey());
freq.add(pair);
}
// to sort the frequency in descending order
Collections.sort(freq, new Comparator<ArrayList<Integer>>() {
public int compare(ArrayList<Integer> a, ArrayList<Integer> b) {
if(a.get(0).equals(b.get(0)))
return a.get(1) - b.get(1);
return b.get(0) - a.get(0);
}
});
// to store the answer
ArrayList<Integer> ans = new ArrayList<>();
// push the elements in the answer array
for (int i = 0; i < freq.size(); i++) {
for (int j = 0; j < freq.get(i).get(0); j++) {
ans.add(freq.get(i).get(1));
}
}
return ans;
}
public static void main(String[] args) {
int[] arr = {5, 5, 4, 6, 4};
ArrayList<Integer> ans = sortByFreq(arr);
for (int i = 0; i < ans.size(); i++) {
System.out.print(ans.get(i) + " ");
}
}
}
class Node:
def __init__(self, key):
self.key = key
self.freq = 1
self.left = None
self.right = None
self.height = 1
# A utility function to get the
# height of the tree
def height(node):
if not node:
return 0
return node.height
# A utility function to right rotate
# subtree rooted with y
def right_rotate(y):
x = y.left
T2 = x.right
# Perform rotation
x.right = y
y.left = T2
# Update heights
y.height = 1 + max(height(y.left), height(y.right))
x.height = 1 + max(height(x.left), height(x.right))
# Return new root
return x
# A utility function to left rotate
# subtree rooted with x
def left_rotate(x):
y = x.right
T2 = y.left
# Perform rotation
y.left = x
x.right = T2
# Update heights
x.height = 1 + max(height(x.left), height(x.right))
y.height = 1 + max(height(y.left), height(y.right))
# Return new root
return y
# Get balance factor of node N
def get_balance(node):
if not node:
return 0
return height(node.left) - height(node.right)
# Recursive function to insert a key in
# the subtree rooted with node
def insert(node, key):
# Perform the normal BST insertion
if not node:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
else:
node.freq += 1
return node
# Update height of this ancestor node
node.height = 1 + max(height(node.left), height(node.right))
# Get the balance factor of this ancestor node
balance = get_balance(node)
# If this node becomes unbalanced,
# then there are 4 cases
# Left Left Case
if balance > 1 and key < node.left.key:
return right_rotate(node)
# Right Right Case
if balance < -1 and key > node.right.key:
return left_rotate(node)
# Left Right Case
if balance > 1 and key > node.left.key:
node.left = left_rotate(node.left)
return right_rotate(node)
# Right Left Case
if balance < -1 and key < node.right.key:
node.right = right_rotate(node.right)
return left_rotate(node)
# Return the (unchanged) node pointer
return node
# Function to store the frequency of each element
def store(root, freq):
# Base Case
if root is None:
return
# Recur for left subtree
store(root.left, freq)
# Store item from root in freq
freq.append([root.freq, root.key])
# Recur for right subtree
store(root.right, freq)
# Function to sort the array
# according to frequency of elements
def sortByFreq(arr):
n = len(arr)
# create bst and insert all elements
root = None
for i in range(n):
root = insert(root, arr[i])
# create a 2d vector to store
# the frequency of each element
freq = []
# store the frequency and the element
store(root, freq)
# to sort the frequency in descending order
freq.sort(key=lambda a: (-a[0], a[1]))
# to store the answer
ans = []
# push the elements in the answer array
for i in range(len(freq)):
for j in range(freq[i][0]):
ans.append(freq[i][1])
return ans
if __name__ == "__main__":
arr = [5, 5, 4, 6, 4]
ans = sortByFreq(arr)
for i in range(len(ans)):
print(ans[i], end=" ")
// Function to sort the array
// according to frequency of elements
using System;
using System.Collections.Generic;
class GfG {
// Function to sort the array
// according to frequency of elements
static List<int> sortByFreq(int[] arr) {
int n = arr.Length;
// hash map to store the
// frequency of each element
SortedDictionary<int, int> mp =
new SortedDictionary<int, int>();
for (int i = 0; i < n; i++) {
if (mp.ContainsKey(arr[i]))
mp[arr[i]]++;
else
mp[arr[i]] = 1;
}
// create a 2d vector to store
// the frequency of each element
List<List<int>> freq = new List<List<int>>();
foreach (KeyValuePair<int, int> kvp in mp) {
List<int> pair = new List<int>();
pair.Add(kvp.Value);
pair.Add(kvp.Key);
freq.Add(pair);
}
// to sort the frequency in descending order
freq.Sort((a, b) => {
if(a[0] == b[0])
return a[1].CompareTo(b[1]);
return b[0].CompareTo(a[0]);
});
// to store the answer
List<int> ans = new List<int>();
// push the elements in the answer array
for (int i = 0; i < freq.Count; i++) {
for (int j = 0; j < freq[i][0]; j++) {
ans.Add(freq[i][1]);
}
}
return ans;
}
static void Main() {
int[] arr = {5, 5, 4, 6, 4};
List<int> ans = sortByFreq(arr);
foreach (int i in ans) {
Console.Write(i + " ");
}
}
}
// Node Structure
class Node {
constructor(key) {
this.key = key;
this.freq = 1;
this.left = null;
this.right = null;
this.height = 1;
}
}
// A utility function to get
// the height of the tree
function height(node) {
if (node === null) {
return 0;
}
return node.height;
}
// A utility function to right rotate
// subtree rooted with y
function rightRotate(y) {
const x = y.left;
const T2 = x.right;
// Perform rotation
x.right = y;
y.left = T2;
// Update heights
y.height = 1 + Math.max(height(y.left), height(y.right));
x.height = 1 + Math.max(height(x.left), height(x.right));
// Return new root
return x;
}
// A utility function to left rotate subtree rooted with x
function leftRotate(x) {
const y = x.right;
const T2 = y.left;
// Perform rotation
y.left = x;
x.right = T2;
// Update heights
x.height = 1 + Math.max(height(x.left), height(x.right));
y.height = 1 + Math.max(height(y.left), height(y.right));
// Return new root
return y;
}
// Get balance factor of node
function getBalance(node) {
if (node === null) {
return 0;
}
return height(node.left) - height(node.right);
}
// Recursive function to insert a key in
// the subtree rooted with node
function insert(node, key) {
// Perform the normal BST insertion
if (node === null) {
return new Node(key);
}
if (key < node.key) {
node.left = insert(node.left, key);
} else if (key > node.key) {
node.right = insert(node.right, key);
} else {
node.freq++;
return node;
}
// Update height of this ancestor node
node.height = 1 + Math.max(height(node.left), height(node.right));
// Get the balance factor of this ancestor node
const balance = getBalance(node);
// If this node becomes unbalanced, then there are 4 cases
// Left Left Case
if (balance > 1 && key < node.left.key) {
return rightRotate(node);
}
// Right Right Case
if (balance < -1 && key > node.right.key) {
return leftRotate(node);
}
// Left Right Case
if (balance > 1 && key > node.left.key) {
node.left = leftRotate(node.left);
return rightRotate(node);
}
// Right Left Case
if (balance < -1 && key < node.right.key) {
node.right = rightRotate(node.right);
return leftRotate(node);
}
// Return the (unchanged) node pointer
return node;
}
// Function to store the frequency of each element
function store(root, freq) {
// Base Case
if (root === null)
return;
// Recur for left subtree
store(root.left, freq);
// Store item from root in freq
freq.push([root.freq, root.key]);
// Recur for right subtree
store(root.right, freq);
}
// Function to sort the array
// according to frequency of elements
function sortByFreq(arr) {
let n = arr.length;
// create bst and insert all elements
let root = null;
for (let i = 0; i < n; i++) {
root = insert(root, arr[i]);
}
// create a 2d vector to store
// the frequency of each element
let freq = [];
// store the frequency and the element
store(root, freq);
// to sort the frequency in descending order
freq.sort((a, b) => {
if (a[0] === b[0])
return a[1] - b[1];
return b[0] - a[0];
});
// to store the answer
let ans = [];
// push the elements in the answer array
for (let i = 0; i < freq.length; i++) {
for (let j = 0; j < freq[i][0]; j++) {
ans.push(freq[i][1]);
}
}
return ans;
}
let arr = [5, 5, 4, 6, 4];
let ans = sortByFreq(arr);
console.log(ans.join(" "));
Time Complexity: O(n * log n), storing an element in self balancing BST takes O(log n) Time and we are storing n elements, thus the total time required will be O(n * log n). Also, we are sorting the array freq[], which also takes O(n * log n). Thus the overall time complexity will be O(n * log n).
Auxiliary Space: O(n), to store the elements in BST and freq[] array.
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Insertion Sort Algorithm Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Dijkstra's Algorithm to find Shortest Paths from a Source to all Given a weighted undirected graph represented as an edge list and a source vertex src, find the shortest path distances from the source vertex to all other vertices in the graph. The graph contains V vertices, numbered from 0 to V - 1.Note: The given graph does not contain any negative edge. Example
12 min read
Selection Sort Selection Sort is a comparison-based sorting algorithm. It sorts an array by repeatedly selecting the smallest (or largest) element from the unsorted portion and swapping it with the first unsorted element. This process continues until the entire array is sorted.First we find the smallest element an
8 min read