Maximum difference between two elements such that larger element appears after the smaller number

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.

Method 1 (Simple)
Use 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

#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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find Maximum difference 
// between two elements such that larger 
// element appears after the smaller number
class MaximumDiffrence 
{
    /* 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) 
    {
        MaximumDiffrence maxdif = new MaximumDiffrence();
        int arr[] = {1, 2, 90, 10, 110};
        System.out.println("Maximum differnce is "
                                maxdif.maxDiff(arr, 5));
    }
}
  
// This code has been contributed by Mayank Jaiswal

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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( 0, 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 differnce is "
                                maxDiff(arr, 5));
    }
}
  
// This code is contributed by Sam007

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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)

chevron_right



Output :

Maximum difference is 109

Time Complexity : O(n^2)
Auxiliary Space : O(1)

Method 2 (Tricky and Efficient)
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).

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

#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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find Maximum difference 
// between two elements such that larger 
// element appears after the smaller number
class MaximumDiffrence 
{
    /* 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) 
    {
        MaximumDiffrence maxdif = new MaximumDiffrence();
        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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



Output:

Maximum difference is 109

Time Complexity : O(n)
Auxiliary Space : O(1)

Like min element, we can also keep track of max element from right side. Thanks to Katamaran for suggesting this approach. Below is the implementation :

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 Result
    int maxDiff = -1; 
      
    // Initialize max element from right side
    int maxRight = arr[n-1]; 
  
    for (int i = n-2; i >= 0; i--)
    {
        if (arr[i] > maxRight)
            maxRight = arr[i];
        else
        {
            int diff = maxRight - arr[i];
            if (diff > maxDiff)
            {
                maxDiff = diff;
            }
        }
    }
    return maxDiff;
}
  
/* 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;
}

chevron_right


Method 3 (Another Tricky Solution)
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

filter_none

edit
close

play_arrow

link
brightness_4
code

#include<stdio.h>
  
int maxDiff(int arr[], int n)
{
    // Create a diff array of size n-1. The array will hold
    //  the difference of adjacent elements
    int diff[n-1];
    for (int i=0; i < n-1; i++)
        diff[i] = arr[i+1] - arr[i];
  
    // Now find the maximum sum subarray in diff array
    int max_diff = diff[0];
    for (int i=1; i<n-1; i++)
    {
        if (diff[i-1] > 0)
            diff[i] += diff[i-1];
        if (max_diff < diff[i])
            max_diff = diff[i];
    }
    return max_diff;
}
  
/* Driver program to test above function */
int main()
{
    int arr[] = {80, 2, 6, 3, 100};
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("Maximum difference is %d",  maxDiff(arr, size));
    return 0;
}

chevron_right


C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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)
{
    // Create a diff array of size n-1. 
    // The array will hold the difference 
    // of adjacent elements
    int diff[n-1];
    for (int i=0; i < n-1; i++)
        diff[i] = arr[i+1] - arr[i];
  
    // Now find the maximum sum 
    // subarray in diff array
    int max_diff = diff[0];
    for (int i=1; i<n-1; i++)
    {
        if (diff[i-1] > 0)
            diff[i] += diff[i-1];
        if (max_diff < diff[i])
            max_diff = diff[i];
    }
    return max_diff;
}
  
/* 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find Maximum difference 
// between two elements such that larger 
// element appears after the smaller number
class MaximumDiffrence 
{
    int maxDiff(int arr[], int n) 
    {
        // Create a diff array of size n-1. The array will hold
        //  the difference of adjacent elements
        int diff[] = new int[n - 1];
        for (int i = 0; i < n - 1; i++)
            diff[i] = arr[i + 1] - arr[i];
  
        // Now find the maximum sum subarray in diff array
        int max_diff = diff[0];
        for (int i = 1; i < n - 1; i++) 
        {
            if (diff[i - 1] > 0
                diff[i] += diff[i - 1];
            if (max_diff < diff[i])
                max_diff = diff[i];
        }
        return max_diff;
    }
  
    // Driver program to test above functions
    public static void main(String[] args) 
    {
        MaximumDiffrence mxdif = new MaximumDiffrence();
        int arr[] = {80, 2, 6, 3, 100};
        int size = arr.length;
        System.out.println(mxdif.maxDiff(arr, size));
    }
}
// This code has been contributed by Mayank Jaiswal

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 code to find Maximum difference
# between two elements such that larger 
# element appears after the smaller number
  
def maxDiff(arr, n):
    diff = [0] * (n - 1)
    for i in range (0, n-1):
        diff[i] = arr[i+1] - arr[i]
          
    # Now find the maximum sum 
    # subarray in diff array    
    max_diff = diff[0]
    for i in range(1, n-1):
        if (diff[i-1] > 0):
            diff[i] += diff[i-1]
      
        if (max_diff < diff[i]):
            max_diff = diff[i]
      
    return max_diff
  
# Driver program to test above function 
arr = [80, 2, 6, 3, 100]
size = len(arr)
print ("Maximum difference is"
       maxDiff(arr, size))
  
# This code is contributed by Swetank Modi

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# code to find Maximum difference
using System;
  
class GFG {
    static int maxDiff(int[] arr, int n)
    {
          
        // Create a diff array of size n-1.
        // The array will hold the
        // difference of adjacent elements
        int[] diff = new int[n - 1];
        for (int i = 0; i < n - 1; i++)
            diff[i] = arr[i + 1] - arr[i];
  
        // Now find the maximum sum
        // subarray in diff array
        int max_diff = diff[0];
        for (int i = 1; i < n - 1; i++) {
            if (diff[i - 1] > 0)
                diff[i] += diff[i - 1];
            if (max_diff < diff[i])
                max_diff = diff[i];
        }
        return max_diff;
    }
  
    // Driver code
    public static void Main()
    {
        int[] arr = { 80, 2, 6, 3, 100 };
        int size = arr.Length;
        Console.Write(maxDiff(arr, size));
    }
}
  
// This code is contributed by Sam007

chevron_right



Output:

Maximum difference is 98

Time Complexity : O(n)
Auxiliary Space : O(n)

We can modify the above method to work in O(1) extra space. Instead of creating an auxiliary array, we can calculate diff and max sum in same loop. Following is the space optimized version.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find Maximum 
// difference between two elements 
// such that larger element appears 
// after the smaller number 
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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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)

chevron_right


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



My Personal Notes arrow_drop_up