Maximum Difference between Two Elements such that Larger Element Appears after the Smaller Element
Given an array arr[] of integers, find out the maximum difference between any two elements such that larger element appears after the smaller number.
Examples :
Input : arr = {2, 3, 10, 6, 4, 8, 1}
Output : 8
Explanation : The maximum difference is between 10 and 2.
Input : arr = {7, 9, 5, 6, 3, 2}
Output : 2
Explanation : The maximum difference is between 9 and 7.
Naive Approach:
We can solve this problem using two loops. In the outer loop, pick elements one by one and in the inner loop calculate the difference of the picked element with every other element in the array and compare the difference with the maximum difference calculated so far.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
int maxDiff( int arr[], int arr_size)
{
int max_diff = arr[1] - arr[0];
for ( int i = 0; i < arr_size; i++)
{
for ( int j = i+1; j < arr_size; j++)
{
if (arr[j] - arr[i] > max_diff)
max_diff = arr[j] - arr[i];
}
}
return max_diff;
}
int main()
{
int arr[] = {1, 2, 90, 10, 110};
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Maximum difference is " << maxDiff(arr, n);
return 0;
}
|
C
#include<stdio.h>
int maxDiff( int arr[], int arr_size)
{
int max_diff = arr[1] - arr[0];
int i, j;
for (i = 0; i < arr_size; i++)
{
for (j = i+1; j < arr_size; j++)
{
if (arr[j] - arr[i] > max_diff)
max_diff = arr[j] - arr[i];
}
}
return max_diff;
}
int main()
{
int arr[] = {1, 2, 90, 10, 110};
printf ( "Maximum difference is %d" , maxDiff(arr, 5));
getchar ();
return 0;
}
|
Java
import java.io.*;
public class MaximumDifference
{
int maxDiff( int arr[], int arr_size)
{
int max_diff = arr[ 1 ] - arr[ 0 ];
int i, j;
for (i = 0 ; i < arr_size; i++)
{
for (j = i + 1 ; j < arr_size; j++)
{
if (arr[j] - arr[i] > max_diff)
max_diff = arr[j] - arr[i];
}
}
return max_diff;
}
public static void main(String[] args)
{
MaximumDifference maxdif = new MaximumDifference();
int arr[] = { 1 , 2 , 90 , 10 , 110 };
System.out.println( "Maximum difference is " +
maxdif.maxDiff(arr, 5 ));
}
}
|
Python3
def maxDiff(arr, arr_size):
max_diff = arr[ 1 ] - arr[ 0 ]
for i in range ( arr_size ):
for j in range ( i + 1 , arr_size ):
if (arr[j] - arr[i] > max_diff):
max_diff = arr[j] - arr[i]
return max_diff
arr = [ 1 , 2 , 90 , 10 , 110 ]
size = len (arr)
print ( "Maximum difference is" , maxDiff(arr, size))
|
C#
using System;
class GFG {
static int maxDiff( int [] arr, int arr_size)
{
int max_diff = arr[1] - arr[0];
int i, j;
for (i = 0; i < arr_size; i++) {
for (j = i + 1; j < arr_size; j++) {
if (arr[j] - arr[i] > max_diff)
max_diff = arr[j] - arr[i];
}
}
return max_diff;
}
public static void Main()
{
int [] arr = { 1, 2, 90, 10, 110 };
Console.Write( "Maximum difference is " +
maxDiff(arr, 5));
}
}
|
Javascript
<script>
function maxDiff( arr, arr_size)
{
let max_diff = arr[1] - arr[0];
for (let i = 0; i < arr_size; i++)
{
for (let j = i+1; j < arr_size; j++)
{
if (arr[j] - arr[i] > max_diff)
max_diff = arr[j] - arr[i];
}
}
return max_diff;
}
let arr = [1, 2, 90, 10, 110];
let n = arr.length;
document.write( "Maximum difference is " + maxDiff(arr, n));
</script>
|
PHP
<?php
function maxDiff( $arr , $arr_size )
{
$max_diff = $arr [1] - $arr [0];
for ( $i = 0; $i < $arr_size ; $i ++)
{
for ( $j = $i +1; $j < $arr_size ; $j ++)
{
if ( $arr [ $j ] - $arr [ $i ] > $max_diff )
$max_diff = $arr [ $j ] - $arr [ $i ];
}
}
return $max_diff ;
}
$arr = array (1, 2, 90, 10, 110);
$n = sizeof( $arr );
echo "Maximum difference is " .
maxDiff( $arr , $n );
|
Output
Maximum difference is 109
Time Complexity : O(n^2)
Auxiliary Space : O(1)
Efficient Approach:
In this method, instead of taking difference of the picked element with every other element, we take the difference with the minimum element found so far. So we need to keep track of 2 things:
1) Maximum difference found so far (max_diff).
2) Minimum number visited so far (min_element).
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
int maxDiff( int arr[], int arr_size)
{
int max_diff = arr[1] - arr[0];
int min_element = arr[0];
for ( int i = 1; i < arr_size; i++)
{
if (arr[i] - min_element > max_diff)
max_diff = arr[i] - min_element;
if (arr[i] < min_element)
min_element = arr[i];
}
return max_diff;
}
int main()
{
int arr[] = {1, 2, 90, 10, 110};
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Maximum difference is " << maxDiff(arr, n);
return 0;
}
|
C
#include<stdio.h>
int maxDiff( int arr[], int arr_size)
{
int max_diff = arr[1] - arr[0];
int min_element = arr[0];
int i;
for (i = 1; i < arr_size; i++)
{
if (arr[i] - min_element > max_diff)
max_diff = arr[i] - min_element;
if (arr[i] < min_element)
min_element = arr[i];
}
return max_diff;
}
int main()
{
int arr[] = {1, 2, 6, 80, 100};
int size = sizeof (arr)/ sizeof (arr[0]);
printf ( "Maximum difference is %d" , maxDiff(arr, size));
getchar ();
return 0;
}
|
Java
import java.io.*;
public class MaximumDifference
{
int maxDiff( int arr[], int arr_size)
{
int max_diff = arr[ 1 ] - arr[ 0 ];
int min_element = arr[ 0 ];
int i;
for (i = 1 ; i < arr_size; i++)
{
if (arr[i] - min_element > max_diff)
max_diff = arr[i] - min_element;
if (arr[i] < min_element)
min_element = arr[i];
}
return max_diff;
}
public static void main(String[] args)
{
MaximumDifference maxdif = new MaximumDifference();
int arr[] = { 1 , 2 , 90 , 10 , 110 };
int size = arr.length;
System.out.println( "MaximumDifference is " +
maxdif.maxDiff(arr, size));
}
}
|
Python3
def maxDiff(arr, arr_size):
max_diff = arr[ 1 ] - arr[ 0 ]
min_element = arr[ 0 ]
for i in range ( 1 , arr_size ):
if (arr[i] - min_element > max_diff):
max_diff = arr[i] - min_element
if (arr[i] < min_element):
min_element = arr[i]
return max_diff
arr = [ 1 , 2 , 6 , 80 , 100 ]
size = len (arr)
print ( "Maximum difference is" ,
maxDiff(arr, size))
|
C#
using System;
class GFG {
static int maxDiff( int [] arr, int arr_size)
{
int max_diff = arr[1] - arr[0];
int min_element = arr[0];
int i;
for (i = 1; i < arr_size; i++) {
if (arr[i] - min_element > max_diff)
max_diff = arr[i] - min_element;
if (arr[i] < min_element)
min_element = arr[i];
}
return max_diff;
}
public static void Main()
{
int [] arr = { 1, 2, 90, 10, 110 };
int size = arr.Length;
Console.Write( "MaximumDifference is " +
maxDiff(arr, size));
}
}
|
Javascript
<script>
function maxDiff(arr, arr_size)
{
let max_diff = arr[1] - arr[0];
let min_element = arr[0];
let i;
for (i = 1; i < arr_size; i++) {
if (arr[i] - min_element > max_diff)
max_diff = arr[i] - min_element;
if (arr[i] < min_element)
min_element = arr[i];
}
return max_diff;
}
let arr = [ 1, 2, 90, 10, 110 ];
let size = arr.length;
document.write( "Maximum difference is " + maxDiff(arr, size));
</script>
|
PHP
<?php
function maxDiff( $arr , $arr_size )
{
$max_diff = $arr [1] - $arr [0];
$min_element = $arr [0];
for ( $i = 1; $i < $arr_size ; $i ++)
{
if ( $arr [ $i ] - $min_element > $max_diff )
$max_diff = $arr [ $i ] - $min_element ;
if ( $arr [ $i ] < $min_element )
$min_element = $arr [ $i ];
}
return $max_diff ;
}
$arr = array (1, 2, 90, 10, 110);
$n = count ( $arr );
echo "Maximum difference is " .
maxDiff( $arr , $n );
?>
|
Output
Maximum difference is 109
Time Complexity : O(n)
Auxiliary Space : O(1)
Approach Using Kadane’s Algorithm:
First find the difference between the adjacent elements of the array and store all differences in an auxiliary array diff[] of size n-1. Now this problems turns into finding the maximum sum subarray of this difference array. Thanks to Shubham Mittal for suggesting this solution.
Below is the implementation :
C++
#include <bits/stdc++.h>
using namespace std;
int maxDiff ( int arr[], int n)
{
int diff = arr[1]-arr[0];
int curr_sum = diff;
int max_sum = curr_sum;
for ( int i=1; i<n-1; i++)
{
diff = arr[i+1]-arr[i];
if (curr_sum > 0)
curr_sum += diff;
else
curr_sum = diff;
if (curr_sum > max_sum)
max_sum = curr_sum;
}
return max_sum;
}
int main()
{
int arr[] = {80, 2, 6, 3, 100};
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Maximum difference is " << maxDiff(arr, n);
return 0;
}
|
Java
import java.io.*;
public class GFG
{
static int maxDiff ( int arr[], int n)
{
int diff = arr[ 1 ] - arr[ 0 ];
int curr_sum = diff;
int max_sum = curr_sum;
for ( int i = 1 ; i < n - 1 ; i++)
{
diff = arr[i + 1 ] - arr[i];
if (curr_sum > 0 )
curr_sum += diff;
else
curr_sum = diff;
if (curr_sum > max_sum)
max_sum = curr_sum;
}
return max_sum;
}
public static void main(String[] args)
{
int arr[] = { 80 , 2 , 6 , 3 , 100 };
int n = arr.length;
System.out.print( "Maximum difference is " +
maxDiff(arr, n));
}
}
|
Python3
def maxDiff (arr, n):
diff = arr[ 1 ] - arr[ 0 ]
curr_sum = diff
max_sum = curr_sum
for i in range ( 1 , n - 1 ):
diff = arr[i + 1 ] - arr[i]
if (curr_sum > 0 ):
curr_sum + = diff
else :
curr_sum = diff
if (curr_sum > max_sum):
max_sum = curr_sum
return max_sum
if __name__ = = '__main__' :
arr = [ 80 , 2 , 6 , 3 , 100 ]
n = len (arr)
print ( "Maximum difference is" ,
maxDiff(arr, n))
|
C#
using System;
class GFG
{
static int maxDiff ( int [] arr, int n)
{
int diff = arr[1] - arr[0];
int curr_sum = diff;
int max_sum = curr_sum;
for ( int i = 1; i < n - 1; i++)
{
diff = arr[i + 1] - arr[i];
if (curr_sum > 0)
curr_sum += diff;
else
curr_sum = diff;
if (curr_sum > max_sum)
max_sum = curr_sum;
}
return max_sum;
}
public static void Main()
{
int [] arr = {80, 2, 6, 3, 100};
int n = arr.Length;
Console.WriteLine( "Maximum difference is " +
maxDiff(arr, n));
}
}
|
Javascript
<script>
function maxDiff (arr, n)
{
let diff = arr[1] - arr[0];
let curr_sum = diff;
let max_sum = curr_sum;
for (let i = 1; i < n - 1; i++)
{
diff = arr[i + 1] - arr[i];
if (curr_sum > 0)
curr_sum += diff;
else
curr_sum = diff;
if (curr_sum > max_sum)
max_sum = curr_sum;
}
return max_sum;
}
let arr = [ 80, 2, 6, 3, 100 ];
let n = arr.length;
document.write( "Maximum difference is " +
maxDiff(arr, n));
</script>
|
PHP
<?php
function maxDiff ( $arr , $n )
{
$diff = $arr [1] - $arr [0];
$curr_sum = $diff ;
$max_sum = $curr_sum ;
for ( $i = 1; $i < $n - 1; $i ++)
{
$diff = $arr [ $i + 1] - $arr [ $i ];
if ( $curr_sum > 0)
$curr_sum += $diff ;
else
$curr_sum = $diff ;
if ( $curr_sum > $max_sum )
$max_sum = $curr_sum ;
}
return $max_sum ;
}
$arr = array (80, 2, 6, 3, 100);
$n = sizeof( $arr );
echo "Maximum difference is " ,
maxDiff( $arr , $n );
?>
|
Output
Maximum difference is 98
Time Complexity : O(n)
Auxiliary Space : O(1)
Below is a variation of this problem:
Maximum difference of sum of elements in two rows in a matrix
Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem
Last Updated :
23 Nov, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...