Open In App
Related Articles

Maximum Difference between Two Elements such that Larger Element Appears after the Smaller Element

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report
 

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++

// C++ program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
#include <bits/stdc++.h>
using namespace std;
 
/* The function assumes that there are
   at least two elements in array. The
   function returns a negative value if the
   array is sorted in decreasing order and 
   returns 0 if elements are equal */
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;
}
 
/* Driver program to test above function */
int main()
{
  int arr[] = {1, 2, 90, 10, 110};
  int n = sizeof(arr) / sizeof(arr[0]);
   
  // Function calling
  cout << "Maximum difference is " << maxDiff(arr, n);
 
  return 0;
}

                    

C

#include<stdio.h>
 
/* The function assumes that there are at least two
   elements in array.
   The function returns a negative value if the array is
   sorted in decreasing order.
   Returns 0 if elements are equal */
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;
}   
 
/* Driver program to test above function */
int main()
{
  int arr[] = {1, 2, 90, 10, 110};
  printf("Maximum difference is %d",  maxDiff(arr, 5));
  getchar();
  return 0;
}

                    

Java

// Java program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
import java.io.*;
public class MaximumDifference
{
    /* The function assumes that there are at least two
       elements in array.
       The function returns a negative value if the array is
       sorted in decreasing order.
       Returns 0 if elements are equal */
    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;
    }
 
    /* Driver program to test above functions */
    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));
    }
}
 
// This code has been contributed by Mayank Jaiswal

                    

Python3

# Python 3 code to find Maximum difference
# between two elements such that larger
# element appears after the smaller number
 
# The function assumes that there are at
# least two elements in array. The function
# returns a negative value if the array is
# sorted in decreasing order. Returns 0
# if elements are equal
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
     
# Driver program to test above function
arr = [1, 2, 90, 10, 110]
size = len(arr)
print ("Maximum difference is", maxDiff(arr, size))
 
# This code is contributed by Swetank Modi

                    

C#

// C# code to find Maximum difference
using System;
 
class GFG {
 
    // The function assumes that there
    // are at least two elements in array.
    // The function returns a negative
    // value if the array is sorted in
    // decreasing order. Returns 0 if
    // elements are equal
    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;
    }
 
    // Driver code
    public static void Main()
    {
 
        int[] arr = { 1, 2, 90, 10, 110 };
        Console.Write("Maximum difference is " +
                                maxDiff(arr, 5));
    }
}
 
// This code is contributed by Sam007

                    

Javascript

<script>
// javascript  program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
 
/* The function assumes that there are
   at least two elements in array. The
   function returns a negative value if the
   array is sorted in decreasing order and 
   returns 0 if elements are equal */
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;
}
 
    // Driver program to test above function
    let arr = [1, 2, 90, 10, 110];
    let n = arr.length;
     
    // Function calling
    document.write("Maximum difference is " + maxDiff(arr, n));
     
    // This code is contributed by jana_sayantan.
</script>

                    

PHP

<?php
// PHP program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
 
/* The function assumes that there are
at least two elements in array. The
function returns a negative value if the
array is sorted in decreasing order and
returns 0 if elements are equal */
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;
}
 
// Driver Code
$arr = array(1, 2, 90, 10, 110);
$n = sizeof($arr);
 
// Function calling
echo "Maximum difference is " .
             maxDiff($arr, $n);
 
// This code is contributed
// by Akanksha Rai(Abby_akku)

                    

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++

// C++ program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
#include <bits/stdc++.h>
using namespace std;
 
/* The function assumes that there are
   at least two elements in array. The
   function returns a negative value if the
   array is sorted in decreasing order and 
   returns 0 if elements are equal */
int maxDiff(int arr[], int arr_size)
{
     // Maximum difference found so far
     int max_diff = arr[1] - arr[0];
      
     // Minimum number visited so far
     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;
}
 
/* Driver program to test above function */
int main()
{
  int arr[] = {1, 2, 90, 10, 110};
  int n = sizeof(arr) / sizeof(arr[0]);
   
  // Function calling
  cout << "Maximum difference is " << maxDiff(arr, n);
 
  return 0;
}

                    

C

#include<stdio.h>
 
/* The function assumes that there are at least two
elements in array.
The function returns a negative value if the array is
sorted in decreasing order.
Returns 0 if elements are equal */
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;
}
 
/* Driver program to test above function */
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

// Java program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
import java.io.*;
public class MaximumDifference
{
    /* The function assumes that there are at least two
       elements in array.
       The function returns a negative value if the array is
       sorted in decreasing order.
       Returns 0 if elements are equal  */
    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;
    }
 
    /* Driver program to test above functions */
    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));
    }
}
 
// This code has been contributed by Mayank Jaiswal

                    

Python3

# Python 3 code to find Maximum difference
# between two elements such that larger
# element appears after the smaller number
 
# The function assumes that there are
# at least two elements in array.
# The function returns a negative
# value if the array is sorted in
# decreasing order. Returns 0 if
# elements are equal
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
     
# Driver program to test above function
arr = [1, 2, 6, 80, 100]
size = len(arr)
print ("Maximum difference is",
        maxDiff(arr, size))
 
# This code is contributed by Swetank Modi

                    

C#

// C# code to find Maximum difference
using System;
 
class GFG {
     
    // The function assumes that there
    // are at least two elements in array.
    // The function returns a negative
    // value if the array is sorted in
    // decreasing order.Returns 0 if
    // elements are equal
    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;
    }
 
    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 2, 90, 10, 110 };
        int size = arr.Length;
        Console.Write("MaximumDifference is " +
                               maxDiff(arr, size));
    }
}
 
// This code is contributed by Sam007

                    

Javascript

<script>
 
    // Javascript code to find Maximum difference
    // between two elements such that larger
   // element appears after the smaller number
     
    // The function assumes that there
    // are at least two elements in array.
    // The function returns a negative
    // value if the array is sorted in
    // decreasing order.Returns 0 if
    // elements are equal
    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
// PHP program to find Maximum
// difference between two elements
// such that larger element appears
// after the smaller number
 
// The function assumes that there
// are at least two elements in array.
// The function returns a negative
// value if the array is sorted in
// decreasing order and returns 0
// if elements are equal 
function maxDiff($arr, $arr_size)
{
    // Maximum difference found so far
    $max_diff = $arr[1] - $arr[0];
     
    // Minimum number visited so far
    $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;
}
 
// Driver Code
$arr = array(1, 2, 90, 10, 110);
$n = count($arr);
 
// Function calling
echo "Maximum difference is " .
             maxDiff($arr, $n);
 
// This code is contributed by Sam007
?>

                    

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++

// C++ program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
#include <bits/stdc++.h>
using namespace std;
 
/* The function assumes that there are
   at least two elements in array. The
   function returns a negative value if the
   array is sorted in decreasing order and 
   returns 0 if elements are equal */
int maxDiff (int arr[], int n)
{
    // Initialize diff, current sum and max sum
    int diff = arr[1]-arr[0];
    int curr_sum = diff;
    int max_sum = curr_sum;
 
    for(int i=1; i<n-1; i++)
    {
        // Calculate current diff
        diff = arr[i+1]-arr[i];
 
        // Calculate current sum
        if (curr_sum > 0)
        curr_sum += diff;
        else
        curr_sum = diff;
 
        // Update max sum, if needed
        if (curr_sum > max_sum)
        max_sum = curr_sum;
    }
 
    return max_sum;
}
 
/* Driver program to test above function */
int main()
{
  int arr[] = {80, 2, 6, 3, 100};
  int n = sizeof(arr) / sizeof(arr[0]);
   
  // Function calling
  cout << "Maximum difference is " << maxDiff(arr, n);
 
  return 0;
}

                    

Java

// Java program to find Maximum
// difference between two elements
// such that larger element appears
// after the smaller number
import java.io.*;
public class GFG
{
     
/* The function assumes that there
are at least two elements in array.
The function returns a negative
value if the array is sorted in
decreasing order and returns 0 if
elements are equal */
static int maxDiff (int arr[], int n)
{
    // Initialize diff, current
    // sum and max sum
    int diff = arr[1] - arr[0];
    int curr_sum = diff;
    int max_sum = curr_sum;
 
    for(int i = 1; i < n - 1; i++)
    {
        // Calculate current diff
        diff = arr[i + 1] - arr[i];
 
        // Calculate current sum
        if (curr_sum > 0)
        curr_sum += diff;
        else
        curr_sum = diff;
 
        // Update max sum, if needed
        if (curr_sum > max_sum)
        max_sum = curr_sum;
    }
 
    return max_sum;
}
 
// Driver Code
public static void main(String[] args)
{
int arr[] = {80, 2, 6, 3, 100};
int n = arr.length;
     
// Function calling
System.out.print("Maximum difference is " +
                          maxDiff(arr, n));
}
}
 
// This code is contributed by Smitha

                    

Python3

# Python3 program to find Maximum difference
# between two elements such that larger
# element appears after the smaller number
 
# The function assumes that there are
# at least two elements in array. The
# function returns a negative value if
# the array is sorted in decreasing
# order and returns 0 if elements are equal
def maxDiff (arr, n):
     
    # Initialize diff, current
    # sum and max sum
    diff = arr[1] - arr[0]
    curr_sum = diff
    max_sum = curr_sum
 
    for i in range(1, n - 1):
         
        # Calculate current diff
        diff = arr[i + 1] - arr[i]
 
        # Calculate current sum
        if (curr_sum > 0):
            curr_sum += diff
        else:
            curr_sum = diff
 
        # Update max sum, if needed
        if (curr_sum > max_sum):
            max_sum = curr_sum
    return max_sum
 
# Driver Code
if __name__ == '__main__':
    arr = [80, 2, 6, 3, 100]
    n = len(arr)
         
    # Function calling
    print("Maximum difference is",
                  maxDiff(arr, n))
 
# This code is contributed
# by 29AjayKumar

                    

C#

// C# program to find Maximum
// difference between two elements
// such that larger element appears
// after the smaller number
using System;
class GFG
{
     
/* The function assumes that there
are at least two elements in array.
The function returns a negative
value if the array is sorted in
decreasing order and returns 0 if
elements are equal */
static int maxDiff (int[] arr, int n)
{
    // Initialize diff, current
    // sum and max sum
    int diff = arr[1] - arr[0];
    int curr_sum = diff;
    int max_sum = curr_sum;
 
    for(int i = 1; i < n - 1; i++)
    {
        // Calculate current diff
        diff = arr[i + 1] - arr[i];
 
        // Calculate current sum
        if (curr_sum > 0)
        curr_sum += diff;
        else
        curr_sum = diff;
 
        // Update max sum, if needed
        if (curr_sum > max_sum)
        max_sum = curr_sum;
    }
 
    return max_sum;
}
 
// Driver Code
public static void Main()
{
int[] arr = {80, 2, 6, 3, 100};
int n = arr.Length;
     
// Function calling
Console.WriteLine("Maximum difference is " +
                        maxDiff(arr, n));
}
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)

                    

Javascript

<script>
 
// Javascript program to find Maximum
// difference between two elements
// such that larger element appears
// after the smaller number
 
/* The function assumes that there
are at least two elements in array.
The function returns a negative
value if the array is sorted in
decreasing order and returns 0 if
elements are equal */
function maxDiff (arr, n)
{
     
    // Initialize diff, current
    // sum and max sum
    let diff = arr[1] - arr[0];
    let curr_sum = diff;
    let max_sum = curr_sum;
  
    for(let i = 1; i < n - 1; i++)
    {
         
        // Calculate current diff
        diff = arr[i + 1] - arr[i];
  
        // Calculate current sum
        if (curr_sum > 0)
            curr_sum += diff;
        else
            curr_sum = diff;
  
        // Update max sum, if needed
        if (curr_sum > max_sum)
            max_sum = curr_sum;
    }
    return max_sum;
}
 
// Driver Code
let arr = [ 80, 2, 6, 3, 100 ];
let n = arr.length;
 
// Function calling   
document.write("Maximum difference is " +
               maxDiff(arr, n));
 
// This code is contributed by rag2127
 
</script>

                    

PHP

<?php
// PHP program to find Maximum difference
// between two elements such that larger
// element appears after the smaller number
 
/* The function assumes that there are
at least two elements in array. The
function returns a negative value if the
array is sorted in decreasing order and
returns 0 if elements are equal */
function maxDiff ($arr, $n)
{
    // Initialize diff, current sum
    // and max sum
    $diff = $arr[1] - $arr[0];
    $curr_sum = $diff;
    $max_sum = $curr_sum;
 
    for($i = 1; $i < $n - 1; $i++)
    {
        // Calculate current diff
        $diff = $arr[$i + 1] - $arr[$i];
 
        // Calculate current sum
        if ($curr_sum > 0)
            $curr_sum += $diff;
        else
            $curr_sum = $diff;
 
        // Update max sum, if needed
        if ($curr_sum > $max_sum)
        $max_sum = $curr_sum;
    }
 
    return $max_sum;
}
 
// Driver Code
$arr = array(80, 2, 6, 3, 100);
$n = sizeof($arr);
 
// Function calling
echo "Maximum difference is ",
            maxDiff($arr, $n);
 
// This code is contributed
// by Sach_code
?>

                    

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
Previous
Next
Share your thoughts in the comments
Similar Reads