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

21 Jun, 2022
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++
C
Java
Python3
C#
PHP
Javascript
// 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;}
#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 program to find Maximum difference // between two elements such that larger // element appears after the smaller numberclass 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
# 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 equaldef 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# code to find Maximum differenceusing 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
<?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 thearray 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 callingecho "Maximum difference is " .              maxDiff($arr, $n);  // This code is contributed // by Akanksha Rai(Abby_akku)
<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>
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++
C
Java
Python3
C#
PHP
Javascript
// 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;}
#include<stdio.h>  /* The function assumes that there are at least twoelements in array.The function returns a negative value if the array issorted 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 program to find Maximum difference // between two elements such that larger // element appears after the smaller numberclass 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
# 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 equaldef 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# code to find Maximum differenceusing 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
<?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 callingecho "Maximum difference is " .             maxDiff($arr, $n);  // This code is contributed by Sam007?>
<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>
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++
Java
Python3
C#
PHP
Javascript
// 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;}
// Java  program to find Maximum difference // between two elements such that larger // element appears after the smaller number  import java.io.*;  class GFG {/* The function assumes that there are at least two elements in array. The function returns a negative value if thearray is sorted in decreasing order and returns 0 if elements are equal */static 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 */    public static void main (String[] args) {        int arr[] = {1, 2, 90, 10, 110};        int n = arr.length;  // Function calling    System.out.println ("Maximum difference is " + maxDiff(arr, n));    }//This code is contributed by Tushil..    }
# 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 equaldef maxDiff(arr, n):          # Initialize Result    maxDiff = -1          # Initialize max element from     # right side    maxRight = arr[-1]       for i in reversed(arr[:-1]):        if (i > maxRight):            maxRight = i        else:            diff = maxRight - i            if (diff > maxDiff):                maxDiff = diff    return maxDiff  # Driver Codeif __name__ == '__main__':    arr = [1, 2, 90, 10, 110]    n = len(arr)          # Function calling    print("Maximum difference is",                  maxDiff(arr, n))  # This code is contributed by 29AjayKumar
// C# program to find Maximum difference // between two elements such that larger // element appears after the smaller numberusing System;  class GFG{/* The function assumes that there are at least two elements in array. The function returns a negative value if thearray is sorted in decreasing order and returns 0 if elements are equal */static 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 Codepublic static void Main () {    int[] arr = {1, 2, 90, 10, 110};    int n = arr.Length;      // Function calling    Console.WriteLine("Maximum difference is " +                                maxDiff(arr, n));}}  // This code is contributed // by Akanksha Rai
<?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 Result     $maxDiff = -1;           // Initialize max element from    // right side     $maxRight = $arr[$n - 1];       for ($i = $n - 2; $i >= 0; $i--)     {         if ($arr[$i] > $maxRight)             $maxRight = $arr[$i];         else        {             $diff = $maxRight - $arr[$i];             if ($diff > $maxDiff)             {                 $maxDiff = $diff;             }         }     }     return $maxDiff; }   // 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 ajit?>
<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 Result        let maxDiff = -1;          // Initialize max element from right side        let maxRight = arr[n-1];          for (let i = n-2; i >= 0; i--)        {            if (arr[i] > maxRight)                maxRight = arr[i];            else            {                let diff = maxRight - arr[i];                if (diff > maxDiff)                {                    maxDiff = diff;                }            }        }        return maxDiff;    }          let arr = [1, 2, 90, 10, 110];    let n = arr.length;       // Function calling    document.write("Maximum difference is " + maxDiff(arr, n));      </script>
Output: 
Maximum difference is 109
Time Complexity : O(n) Auxiliary Space : O(1)
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++
C
Java
Python3
C#
PHP
Javascript
// 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;}
#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;}
// Java program to find Maximum difference // between two elements such that larger // element appears after the smaller numberclass MaximumDifference {    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)     {        MaximumDifference mxdif = new MaximumDifference();        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
# 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
// C# code to find Maximum differenceusing 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
<?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 thearray is sorted in decreasing order and returns 0 if elements are equal */function maxDiff($arr, $n){    // Create a diff array of size n-1.     // The array will hold the difference     // of adjacent elements    $diff[$n-1] = array();    for ($i=0; $i < $n-1; $i++)        $diff[$i] = $arr[$i+1] - $arr[$i];      // Now find the maximum sum     // subarray in diff array    $max_diff = $diff[0];    for ($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$arr = array(80, 2, 6, 3, 100);$n = sizeof($arr);  // Function callingecho "Maximum difference is " .              maxDiff($arr, $n);  // This code is contributed // by Akanksha Rai
<script>  // JavaScript program to find Maximum difference// between two elements such that larger// element appears after the smaller number  /* The function assumes that there areat least two elements in array. Thefunction returns a negative value if thearray is sorted in decreasing order andreturns 0 if elements are equal */function maxDiff(arr, n){          // Create a diff array of size n-1.    // The array will hold the difference    // of adjacent elements    let diff = new Array(n - 1);    for(let i = 0; i < n - 1; i++)        diff[i] = arr[i + 1] - arr[i];      // Now find the maximum sum    // subarray in diff array    let max_diff = diff[0];    for(let 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 codelet arr = [ 80, 2, 6, 3, 100 ];let n = arr.length;  // Function callingdocument.write("Maximum difference is " +                maxDiff(arr, n));  // This code is contributed by Mayank Tyagi  </script>
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++
Java
Python3
C#
PHP
Javascript
// 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 program to find Maximum // difference between two elements // such that larger element appears // after the smaller number class GFG{      /* The function assumes that thereare at least two elements in array. The function returns a negative value if the array is sorted in decreasing order and returns 0 ifelements 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 Codepublic 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 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 equaldef 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 Codeif __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# 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 thereare at least two elements in array. The function returns a negative value if the array is sorted in decreasing order and returns 0 ifelements 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 Codepublic 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)
<?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 thearray 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 callingecho "Maximum difference is ",            maxDiff($arr, $n);  // This code is contributed // by Sach_code?>
<script>  // Javascript program to find Maximum// difference between two elements// such that larger element appears// after the smaller number  /* The function assumes that thereare at least two elements in array.The function returns a negativevalue if the array is sorted indecreasing order and returns 0 ifelements 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 Codelet 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>
Output: 
Maximum difference is 98
Time Complexity : O(n) Auxiliary Space : O(1) 
Maximum difference between two elements (larger element appears after smaller) | GeeksforGeeks - YouTubeGeeksforGeeks530K subscribersMaximum difference between two elements (larger element appears after smaller) | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 11:18•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=SO0bwMziLlU" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Below is a variation of this problem: Maximum difference of sum of elements in two rows in a matrixPlease write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem 
Sam007
Smitha Dinesh Semwal
Akanksha_Rai
jit_t
Sach_Code
29AjayKumar
jana_sayantan
decode2207
suresh07
mayanktyagi1709
rag2127
saurabh1990aror
devnawfalahmed
202051178
_shinchancode
Amazon
Hike
MakeMyTrip
Ola Cabs
SAP Labs
Arrays
Amazon
Hike
MakeMyTrip
Ola Cabs
SAP Labs
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Multidimensional Arrays in Java
Introduction to Arrays
K'th Smallest/Largest Element in Unsorted Array | Set 1
Subset Sum Problem | DP-25
Introduction to Data Structures
Python | Using 2D arrays/lists the right way
Search an element in a sorted and rotated array
Find Second largest element in an array
Find the Missing Number
Count Inversions in an array | Set 1 (Using Merge Sort)