Compare two Version numbers
Last Updated :
19 Apr, 2024
A version number is a string that is used to identify the unique state of a software product. A version number looks like a.b.c.d, where a, b, etc are numbers, so the version number is a string in which numbers are separated by dots. These numbers generally represent the hierarchy from major to minor (a is major and d is minor).
In this problem, we are given two version numbers. We need to compare them and conclude which one is the latest version number (that is, which version number is greater).
Example:
Input:
V1 = “1.0.31”
V2 = “1.0.27”
Output: v1 is latest
Because V2 < V1
Input:
V1 = “1.0.10”
V2 = “1.0.27”
Output: v2 is latest
Because V1 < V2
Approach: It is not possible to compare them directly because of the dot, but the versions can compare numeric part wise and then the latest version can be found. Traverse through strings and separate numeric parts and compare them. If equal, then the next numeric part is compared and so on until they differ, otherwise flag them as equal.
Implement a method to compare the two versions. If there are more than two versions, then the below versionCompare method can be used as a compare method of sort method, which will sort all versions according to the specified comparison.
Implementation:
C++
// C/C++ program to compare
// two version number
#include <bits/stdc++.h>
using namespace std;
// Method to compare two versions.
// Returns 1 if v2 is smaller, -1
// if v1 is smaller, 0 if equal
int versionCompare(string v1, string v2)
{
// vnum stores each numeric
// part of version
int vnum1 = 0, vnum2 = 0;
// loop until both string are
// processed
for (int i = 0, j = 0; (i < v1.length()
|| j < v2.length());) {
// storing numeric part of
// version 1 in vnum1
while (i < v1.length() && v1[i] != '.') {
vnum1 = vnum1 * 10 + (v1[i] - '0');
i++;
}
// storing numeric part of
// version 2 in vnum2
while (j < v2.length() && v2[j] != '.') {
vnum2 = vnum2 * 10 + (v2[j] - '0');
j++;
}
if (vnum1 > vnum2)
return 1;
if (vnum2 > vnum1)
return -1;
// if equal, reset variables and
// go for next numeric part
vnum1 = vnum2 = 0;
i++;
j++;
}
return 0;
}
// Driver method to check above
// comparison function
int main()
{
string version1 = "1.0.3";
string version2 = "1.0.7";
if (versionCompare(version1, version2) < 0)
cout << version1 << " is smaller\n";
else if (versionCompare(version1, version2) > 0)
cout << version2 << " is smaller\n";
else
cout << "Both version are equal\n";
return 0;
}
// Java program to compare two version number
import java.util.*;
class GFG {
// Method to compare two versions.
// Returns 1 if v2 is
// smaller, -1 if v1 is smaller, 0 if equal
static int versionCompare(String v1, String v2)
{
// vnum stores each numeric part of version
int vnum1 = 0, vnum2 = 0;
// loop until both String are processed
for (int i = 0, j = 0; (i < v1.length()
|| j < v2.length());) {
// Storing numeric part of
// version 1 in vnum1
while (i < v1.length()
&& v1.charAt(i) != '.') {
vnum1 = vnum1 * 10
+ (v1.charAt(i) - '0');
i++;
}
// storing numeric part
// of version 2 in vnum2
while (j < v2.length()
&& v2.charAt(j) != '.') {
vnum2 = vnum2 * 10
+ (v2.charAt(j) - '0');
j++;
}
if (vnum1 > vnum2)
return 1;
if (vnum2 > vnum1)
return -1;
// if equal, reset variables and
// go for next numeric part
vnum1 = vnum2 = 0;
i++;
j++;
}
return 0;
}
// Driver method to check above
// comparison function
public static void main(String[] args)
{
String version1 = "1.0.3";
String version2 = "1.0.7";
if (versionCompare(version1, version2) < 0)
System.out.println(version1 + " is smaller");
else if (versionCompare(version1, version2) > 0)
System.out.println(version2 + " is smaller");
else
System.out.println("Both version are equal");
}
}
// This code is contributed by shivanisinghss2110
# Python program to compare two version number
# Method to compare two versions.
# Return 1 if v2 is smaller,
# -1 if v1 is smaller,,
# 0 if equal
def versionCompare(v1, v2):
# This will split both the versions by '.'
arr1 = v1.split(".")
arr2 = v2.split(".")
n = len(arr1)
m = len(arr2)
# converts to integer from string
arr1 = [int(i) for i in arr1]
arr2 = [int(i) for i in arr2]
# compares which list is bigger and fills
# smaller list with zero (for unequal delimiters)
if n>m:
for i in range(m, n):
arr2.append(0)
elif m>n:
for i in range(n, m):
arr1.append(0)
# returns 1 if version 1 is bigger and -1 if
# version 2 is bigger and 0 if equal
for i in range(len(arr1)):
if arr1[i]>arr2[i]:
return 1
elif arr2[i]>arr1[i]:
return -1
return 0
# Driver program to check above comparison function
version1 = "1.0.3"
version2 = "1.0.7"
ans = versionCompare(version1, version2)
if ans < 0:
print (version1 + " is smaller")
elif ans > 0:
print (version2 + " is smaller")
else:
print ("Both versions are equal")
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)
# and improved by Tuhin Das (tuhindas221b)
// C# program to compare
// two version number
using System;
class GFG
{
// Method to compare two versions.
// Returns 1 if v2 is smaller, -1
// if v1 is smaller, 0 if equal
static int versionCompare(string v1, string v2)
{
// vnum stores each numeric
// part of version
int vnum1 = 0, vnum2 = 0;
// loop until both string are
// processed
for (int i = 0, j = 0; (i < v1.Length || j < v2.Length);)
{
// storing numeric part of
// version 1 in vnum1
while (i < v1.Length && v1[i] != '.')
{
vnum1 = vnum1 * 10 + (v1[i] - '0');
i++;
}
// storing numeric part of
// version 2 in vnum2
while (j < v2.Length && v2[j] != '.')
{
vnum2 = vnum2 * 10 + (v2[j] - '0');
j++;
}
if (vnum1 > vnum2)
return 1;
if (vnum2 > vnum1)
return -1;
// if equal, reset variables and
// go for next numeric part
vnum1 = vnum2 = 0;
i++;
j++;
}
return 0;
}
// Driver code
static void Main()
{
string version1 = "1.0.3";
string version2 = "1.0.7";
if (versionCompare(version1, version2) < 0)
Console.WriteLine(version1 + " is smaller");
else if (versionCompare(version1, version2) > 0)
Console.WriteLine(version2 + " is smaller");
else
Console.WriteLine("Both version are equal");
}
}
// This code is contributed by divyeshrabadiya07.
<script>
// Javascript implementation
// Method to compare two versions.
// Returns 1 if v2 is smaller, -1
// if v1 is smaller, 0 if equal
function versionCompare(v1, v2)
{
// vnum stores each numeric
// part of version
var vnum1 = 0, vnum2 = 0;
// loop until both string are
// processed
for (var i = 0, j = 0; (i < v1.length
|| j < v2.length);) {
// storing numeric part of
// version 1 in vnum1
while (i < v1.length && v1[i] != '.') {
vnum1 = vnum1 * 10 + (v1[i] - '0');
i++;
}
// storing numeric part of
// version 2 in vnum2
while (j < v2.length && v2[j] != '.') {
vnum2 = vnum2 * 10 + (v2[j] - '0');
j++;
}
if (vnum1 > vnum2)
return 1;
if (vnum2 > vnum1)
return -1;
// if equal, reset variables and
// go for next numeric part
vnum1 = vnum2 = 0;
i++;
j++;
}
return 0;
}
// Driver method to check above
// comparison function
var version1 = "1.0.3";
var version2 = "1.0.7";
if (versionCompare(version1, version2) < 0)
document.write(version1 + " is smaller" + "<br>");
else if (versionCompare(version1, version2) > 0)
document.write(version2 + " is smaller" + "<br>");
else
document.write("Both version are equal" + "<br>");
// This is code is contributed
// by shubhamsingh10
</script>
Complexity Analysis:
- Time Complexity: O(n), where n is the length of the string.
Only one traversal of the string is needed. - Auxiliary space: O(1).
As no extra space is needed.
Another Approach(Using Recursion):
Intuition:
The idea is quite simple, first you split the version strings by the dots. Once you have the constituent parts, you then find the shorter and iterate through the split sections till you hit the lenght of the shorter version number after splitting. Whatever index youre in, it will be at i. What you do next is recursively call the comparison function parsing in a splice of the longer version number starting from the index of the shorter length and the shorter length version is parsed in as ["0"] since leading 0s do not affect the number anyway.
At each stage, check for whichever is greater and appropriately return 0 or 1. When the lengths are equal ater iteration till the end index(Can be checked by seeing if the version lengths are the same as the end loop index), if and no difference can be detected, return 0.
Approach:
- Split version1 and version2 strings into a list on the "." pattern.
- Map each string element in the list into an integer.
- Relying upon the power of pattern matching in function definitions, recursively step down each item in the two lists and compare them.
- Fill in a single item list of [0] where a version's list representation has exhausted all elements.
- If we reach the end of the list, the versions are equivalent; return 0.
C++
// C/C++ program to compare
// two version number
#include <bits/stdc++.h>
using namespace std;
// Method to compare two versions.
// Returns 1 if v2 is smaller, -1
// if v1 is smaller, 0 if equal
int check(string v1, string v2){
if(v1==v2)return 0;
if(v1=="")v1 = "";
if(v2=="")v2 = "";
int p1 = 0, p2 = 0;
int n1 = v1.length(), n2 = v2.length();
//find the location of the next '.' if it exists
if(v1.find('.')!=string::npos){
n1 = v1.find('.');
}
if(v2.find('.')!=string::npos){
n2 = v2.find('.');
}
// create the sub-version string
string str1 = "", str2 = "";
while(p1<n1)str1+=v1[p1++];
while(p2<n2)str2+=v2[p2++];
//convert the subversion string to integer to match it
int st1 = 0, st2 =0 ;
if(str1.length()>0)
st1 = stoi(str1);
if(str2.length()>0)
st2 = stoi(str2);
// check according to the given condition
if(st1<st2) return -1;
else if(st1>st2) return 1;
if(n1< v1.length())
v1 = v1.substr(n1+1);
else v1 = "";
if(n2< v2.length())
v2 = v2.substr(n2+1);
else v2= "";
// if the sub version strings are equal, then check for the next part using recursion
// say 1.001 and 1.02
// 1 and 1 are equal so now check 001 and 02
int ans = check(v1, v2 );
return ans;
}
int compareVersion(string version1, string version2) {
int ans = check(version1, version2);
return ans;
}
// Driver method to check above
// comparison function
int main()
{
string version1 = "1.0.3";
string version2 = "1.0.7";
if (compareVersion(version1, version2) < 0)
cout << version1 << " is smaller\n";
else if (compareVersion(version1, version2) > 0)
cout << version2 << " is smaller\n";
else
cout << "Both version are equal\n";
return 0;
}
public class VersionComparison {
// Method to compare two sub-versions.
// Returns 1 if v2 is smaller, -1 if v1 is smaller, 0 if equal
public static int check(String v1, String v2) {
if (v1.equals(v2)) return 0;
if (v1.isEmpty()) v1 = "";
if (v2.isEmpty()) v2 = "";
int p1 = 0, p2 = 0;
int n1 = v1.length(), n2 = v2.length();
// Find the location of the next '.' if it exists
if (v1.contains(".")) {
n1 = v1.indexOf('.');
}
if (v2.contains(".")) {
n2 = v2.indexOf('.');
}
String str1 = "", str2 = "";
while (p1 < n1) str1 += v1.charAt(p1++);
while (p2 < n2) str2 += v2.charAt(p2++);
int st1 = 0, st2 = 0;
if (!str1.isEmpty()) st1 = Integer.parseInt(str1);
if (!str2.isEmpty()) st2 = Integer.parseInt(str2);
if (st1 < st2) return -1;
else if (st1 > st2) return 1;
if (n1 < v1.length())
v1 = v1.substring(n1 + 1);
else v1 = "";
if (n2 < v2.length())
v2 = v2.substring(n2 + 1);
else v2 = "";
// If the sub-version strings are equal, then check for the next part using recursion
int ans = check(v1, v2);
return ans;
}
// Method to compare two versions.
public static int compareVersion(String version1, String version2) {
int ans = check(version1, version2);
return ans;
}
public static void main(String[] args) {
String version1 = "1.0.3";
String version2 = "1.0.7";
// Compare the versions and display the result
int result = compareVersion(version1, version2);
if (result < 0)
System.out.println(version1 + " is smaller");
else if (result > 0)
System.out.println(version2 + " is smaller");
else
System.out.println("Both versions are equal");
}
}
def compareVersion(version1, version2):
# Helper function to parse a version string into a list of integers
def parse_version(version):
version_parts = version.split('.') # Split the version string by '.'
version_ints = [int(part) for part in version_parts] # Convert each part to an integer
return version_ints
# Parse the input version strings into lists of integers
v1_parts = parse_version(version1)
v2_parts = parse_version(version2)
# Compare each part of the version numbers
for i in range(max(len(v1_parts), len(v2_parts))):
v1_num = v1_parts[i] if i < len(v1_parts) else 0 # Use 0 if no more parts in v1
v2_num = v2_parts[i] if i < len(v2_parts) else 0 # Use 0 if no more parts in v2
if v1_num < v2_num:
return -1 # version1 is smaller
elif v1_num > v2_num:
return 1 # version2 is smaller
return 0 # Both versions are equal
# Example usage:
version1 = "1.0.3"
version2 = "1.0.7"
result = compareVersion(version1, version2)
if result < 0:
print(version1, "is smaller")
elif result > 0:
print(version2, "is smaller")
else:
print("Both versions are equal")
using System;
class Program
{
// Method to compare two version strings.
// Returns 1 if version2 is smaller, -1 if version1 is smaller, 0 if equal.
static int CompareVersion(string version1, string version2)
{
// If both versions are equal, return 0.
if (version1 == version2)
return 0;
// Split the version strings by dot ('.') to compare individual parts.
string[] parts1 = version1.Split('.');
string[] parts2 = version2.Split('.');
int length = Math.Max(parts1.Length, parts2.Length);
for (int i = 0; i < length; i++)
{
int part1 = i < parts1.Length ? int.Parse(parts1[i]) : 0;
int part2 = i < parts2.Length ? int.Parse(parts2[i]) : 0;
// Compare the individual parts of the versions.
if (part1 < part2)
return -1;
else if (part1 > part2)
return 1;
}
// If no difference is found, return 0 (versions are equal).
return 0;
}
static void Main()
{
string version1 = "1.0.3";
string version2 = "1.0.7";
int result = CompareVersion(version1, version2);
if (result < 0)
Console.WriteLine(version1 + " is smaller");
else if (result > 0)
Console.WriteLine(version2 + " is smaller");
else
Console.WriteLine("Both versions are equal");
}
}
// JavaScript Program for the above approach
function check(v1, v2) {
if (v1 === v2) return 0;
if (v1 === "") v1 = "";
if (v2 === "") v2 = "";
let p1 = 0, p2 = 0;
let n1 = v1.length, n2 = v2.length;
// find the location of the next '.' if it exists
if (v1.indexOf('.') !== -1) {
n1 = v1.indexOf('.');
}
if (v2.indexOf('.') !== -1) {
n2 = v2.indexOf('.');
}
// create the sub-version string
let str1 = "", str2 = "";
while (p1 < n1) str1 += v1[p1++];
while (p2 < n2) str2 += v2[p2++];
// convert the subversion string to integer to match it
let st1 = 0, st2 = 0;
if (str1.length > 0)
st1 = parseInt(str1);
if (str2.length > 0)
st2 = parseInt(str2);
// check according to the given condition
if (st1 < st2) return -1;
else if (st1 > st2) return 1;
if (n1 < v1.length)
v1 = v1.substring(n1 + 1);
else v1 = "";
if (n2 < v2.length)
v2 = v2.substring(n2 + 1);
else v2 = "";
// if the sub version strings are equal, then check for the next part using recursion
// say 1.001 and 1.02
// 1 and 1 are equal so now check 001 and 02
let ans = check(v1, v2);
return ans;
}
function compareVersion(version1, version2) {
let ans = check(version1, version2);
return ans;
}
// Driver method to check above comparison function
const version1 = "1.0.3";
const version2 = "1.0.7";
const result = compareVersion(version1, version2);
if (result < 0)
console.log(`${version1} is smaller`);
else if (result > 0)
console.log(`${version2} is smaller`);
else
console.log("Both versions are equal");
// THIS CODE IS CONTRIBUTED BY KIRGI AGARWAL
Time Complexity: O(n), where n is the length of the string, recursive calls in the string.
Auxiliary space: O(n), Auxillary stack space.
Approach:
The approach compares two version numbers by splitting them into individual parts and comparing each part numerically. Here's the intuition behind this approach:
- Splitting the Version Numbers: The approach begins by splitting the input version numbers (v1 and v2) into arrays version1 and version2, respectively. This is done by using the dot (.) as the delimiter. For example, the version number "1.0.3" would be split into the array [1, 0, 3].
- Comparing Corresponding Parts: The approach then iterates through each part of the version numbers, comparing the corresponding parts numerically. It starts with the first part of both version numbers and continues until it reaches the end of the longer version number.
- Handling Missing Parts: If one version number has fewer parts than the other, it is assumed that the missing parts are 0. This is handled by assigning 0 to num1 or num2 when accessing a part beyond the length of the corresponding version number array.
- Numeric Comparison: For each part, the approach compares the numeric values of num1 and num2. If num1 is greater than num2, it means that v1 is larger and the method returns 1. If num2 is greater than num1, it means that v2 is larger, and the method returns -1.
- Equality Check: If the loop completes without any larger or smaller parts being found, it means that the version numbers are equal, and the method returns 0.
- Output: Finally, in the main method, the comparison result is used to print the appropriate message indicating whether version1 is smaller, version2 is smaller, or both versions are equal.
This approach provides a straightforward way to compare version numbers by breaking them down into individual parts and comparing them numerically. It ensures that each part is compared correctly, even if the version numbers have different lengths or contain missing parts.
C++
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
// Method to compare two versions.
// Returns 1 if v2 is smaller, -1 if v1 is smaller, 0 if
// equal
int versionCompare(string v1, string v2)
{
vector<int> version1, version2;
istringstream iss1(v1);
istringstream iss2(v2);
string token;
// Split the versions by dot and store in vectors
while (getline(iss1, token, '.')) {
version1.push_back(stoi(token));
}
while (getline(iss2, token, '.')) {
version2.push_back(stoi(token));
}
int length = max(version1.size(), version2.size());
for (int i = 0; i < length; i++) {
int num1 = (i < version1.size()) ? version1[i] : 0;
int num2 = (i < version2.size()) ? version2[i] : 0;
if (num1 > num2)
return 1;
if (num2 > num1)
return -1;
}
return 0;
}
// Driver method to check above comparison function
int main()
{
string version1 = "1.0.3";
string version2 = "1.0.7";
int result = versionCompare(version1, version2);
if (result < 0)
cout << version1 << " is smaller" << endl;
else if (result > 0)
cout << version2 << " is smaller" << endl;
else
cout << "Both versions are equal" << endl;
return 0;
}
import java.util.*;
class GFG {
// Method to compare two versions.
// Returns 1 if v2 is smaller, -1 if v1 is smaller, 0 if equal
static int versionCompare(String v1, String v2) {
String[] version1 = v1.split("\\.");
String[] version2 = v2.split("\\.");
int length = Math.max(version1.length, version2.length);
for (int i = 0; i < length; i++) {
int num1 = (i < version1.length) ? Integer.parseInt(version1[i]) : 0;
int num2 = (i < version2.length) ? Integer.parseInt(version2[i]) : 0;
if (num1 > num2)
return 1;
if (num2 > num1)
return -1;
}
return 0;
}
// Driver method to check above comparison function
public static void main(String[] args) {
String version1 = "1.0.3";
String version2 = "1.0.7";
int result = versionCompare(version1, version2);
if (result < 0)
System.out.println(version1 + " is smaller");
else if (result > 0)
System.out.println(version2 + " is smaller");
else
System.out.println("Both versions are equal");
}
}
def version_compare(v1, v2):
# Split the input version strings into lists of integers by splitting on the period ('.').
version1 = list(map(int, v1.split('.')) if v1 else []) # Convert v1 to a list of integers, or an empty list if v1 is empty.
version2 = list(map(int, v2.split('.')) if v2 else []) # Convert v2 to a list of integers, or an empty list if v2 is empty.
# Find the maximum length of the version lists to ensure we compare all components.
length = max(len(version1), len(version2))
# Compare each component of the version strings.
for i in range(length):
num1 = version1[i] if i < len(version1) else 0 # Get the component or use 0 if it doesn't exist.
num2 = version2[i] if i < len(version2) else 0 # Get the component or use 0 if it doesn't exist.
if num1 > num2:
return 1 # v1 is greater than v2.
if num2 > num1:
return -1 # v2 is greater than v1.
return 0 # The versions are equal.
# Example version strings to compare
version1 = "1.0.3"
version2 = "1.0.7"
# Call the version_compare function to compare the two versions.
result = version_compare(version1, version2)
# Print the result of the comparison.
if result < 0:
print(f"{version1} is smaller")
elif result > 0:
print(f"{version2} is smaller")
else:
print("Both versions are equal")
using System;
using System.Collections.Generic;
using System.Linq;
class Program {
// Function to compare two version strings.
// Returns 1 if v2 is smaller, -1 if v1 is smaller, 0 if
// equal.
static int VersionCompare(string v1, string v2)
{
// Split version strings by dot and convert them to
// integer lists.
List<int> version1
= v1.Split('.').Select(int.Parse).ToList();
List<int> version2
= v2.Split('.').Select(int.Parse).ToList();
// Determine the maximum length of the two version
// lists.
int length
= Math.Max(version1.Count, version2.Count);
for (int i = 0; i < length; i++) {
// Get the i-th component of each version.
int num1
= (i < version1.Count) ? version1[i] : 0;
int num2
= (i < version2.Count) ? version2[i] : 0;
if (num1 > num2)
return 1;
if (num2 > num1)
return -1;
}
// If no difference is found, the versions are
// equal.
return 0;
}
static void Main(string[] args)
{
string version1 = "1.0.3";
string version2 = "1.0.7";
// Call the VersionCompare function to compare the
// versions.
int result = VersionCompare(version1, version2);
if (result < 0)
Console.WriteLine(version1 + " is smaller");
else if (result > 0)
Console.WriteLine(version2 + " is smaller");
else
Console.WriteLine("Both versions are equal");
}
}
function versionCompare(v1, v2) {
const version1 = v1.split('.').map(Number);
const version2 = v2.split('.').map(Number);
const length = Math.max(version1.length, version2.length);
for (let i = 0; i < length; i++) {
const num1 = i < version1.length ? version1[i] : 0;
const num2 = i < version2.length ? version2[i] : 0;
if (num1 > num2) return 1;
if (num2 > num1) return -1;
}
return 0;
}
const version1 = "1.0.3";
const version2 = "1.0.7";
const result = versionCompare(version1, version2);
if (result < 0)
console.log(version1 + " is smaller");
else if (result > 0)
console.log(version2 + " is smaller");
else
console.log("Both versions are equal");
Output:
1.0.3 is smaller
Time Complexity: O(max(m, n)), where m and n represent the number of parts in the respective version numbers.
Space Complexity: O(max(m, n)).
This article is contributed by Utkarsh Trivedi.
Compare Version Number | DSA Problem
Similar Reads
Basics & Prerequisites
Data Structures
Array Data StructureIn this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
3 min read
String in Data StructureA string is a sequence of characters. The following facts make string an interesting data structure.Small set of elements. Unlike normal array, strings typically have smaller set of items. For example, lowercase English alphabet has only 26 characters. ASCII has only 256 characters.Strings are immut
2 min read
Hashing in Data StructureHashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
2 min read
Linked List Data StructureA linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Here’s the comparison of Linked List vs Arrays Linked List:
2 min read
Stack Data StructureA Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
2 min read
Queue Data StructureA Queue Data Structure is a fundamental concept in computer science used for storing and managing data in a specific order. It follows the principle of "First in, First out" (FIFO), where the first element added to the queue is the first one to be removed. It is used as a buffer in computer systems
2 min read
Tree Data StructureTree Data Structure is a non-linear data structure in which a collection of elements known as nodes are connected to each other via edges such that there exists exactly one path between any two nodes. Types of TreeBinary Tree : Every node has at most two childrenTernary Tree : Every node has at most
4 min read
Graph Data StructureGraph Data Structure is a collection of nodes connected by edges. It's used to represent relationships between different entities. If you are looking for topic-wise list of problems on different topics like DFS, BFS, Topological Sort, Shortest Path, etc., please refer to Graph Algorithms. Basics of
3 min read
Trie Data StructureThe Trie data structure is a tree-like structure used for storing a dynamic set of strings. It allows for efficient retrieval and storage of keys, making it highly effective in handling large datasets. Trie supports operations such as insertion, search, deletion of keys, and prefix searches. In this
15+ min read
Algorithms
Searching AlgorithmsSearching algorithms are essential tools in computer science used to locate specific items within a collection of data. In this tutorial, we are mainly going to focus upon searching in an array. When we search an item in an array, there are two most common algorithms used based on the type of input
2 min read
Sorting AlgorithmsA Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read
Introduction to RecursionThe process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. A recursive algorithm takes one step toward solution and then recursively call itself to further move. The algorithm stops once we reach the solution
14 min read
Greedy AlgorithmsGreedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
3 min read
Graph AlgorithmsGraph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Dynamic Programming or DPDynamic Programming is an algorithmic technique with the following properties.It is mainly an optimization over plain recursion. Wherever we see a recursive solution that has repeated calls for the same inputs, we can optimize it using Dynamic Programming. The idea is to simply store the results of
3 min read
Bitwise AlgorithmsBitwise algorithms in Data Structures and Algorithms (DSA) involve manipulating individual bits of binary representations of numbers to perform operations efficiently. These algorithms utilize bitwise operators like AND, OR, XOR, NOT, Left Shift, and Right Shift.BasicsIntroduction to Bitwise Algorit
4 min read
Advanced
Segment TreeSegment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Pattern SearchingPattern searching algorithms are essential tools in computer science and data processing. These algorithms are designed to efficiently find a particular pattern within a larger set of data. Patten SearchingImportant Pattern Searching Algorithms:Naive String Matching : A Simple Algorithm that works i
2 min read
GeometryGeometry is a branch of mathematics that studies the properties, measurements, and relationships of points, lines, angles, surfaces, and solids. From basic lines and angles to complex structures, it helps us understand the world around us.Geometry for Students and BeginnersThis section covers key br
2 min read
Interview Preparation
Practice Problem