text: GeeksforGeeks App
  Open App
  Browser
  Continue
  
  # 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++
  
   `// C++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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`` ` `/* 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`
  
  ## PHP
  
   ` ``\$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)`
  
  ## Javascript
  
   ``
  
  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++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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`` ` `/* 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`
  
  ## PHP
  
   ` ``\$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``?>`
  
  ## Javascript
  
   ``
  
  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++
  
   `// C++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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
  
   `// 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 the``array 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
  
   `# 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 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 Code``if` `__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#
  
   `// 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 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 Code``public` `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
  
   `= 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``?>`
  
  ## Javascript
  
   ``
  
  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++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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 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;``}`
  
  ## C
  
   `#include`` ` `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 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
  
   `// Java program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``import` `java.io.*;``public` `class` `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`
  
  ## Python3
  
   `# 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#
  
   `// 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`
  
  ## PHP
  
   ` 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 calling``echo` `"Maximum difference is "` `. ``             ``maxDiff(``\$arr``, ``\$n``);`` ` `// This code is contributed ``// by Akanksha Rai`
  
  ## Javascript
  
   ``
  
  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++
  
   `// C++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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 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)`
  
  ## PHP
  
   ` 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``?>`
  
  ## Javascript
  
   ``
  
  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
distilabel_metadata.content: Evaluate the user given text extract and determine if it contains a math question and optionally and answer to this question.
  
  Output rules:
  
  1. Briefly describe the document and mention if it contains a question or a question and answer.
  2. Finalize the output with: Label: no-question,question,question-and-answer,multiple-question,multiple-question-and-answer
distilabel_metadata.role: system
distilabel_metadata.content: GeeksforGeeks App
  Open App
  Browser
  Continue
  
  # 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++
  
   `// C++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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`` ` `/* 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`
  
  ## PHP
  
   ` ``\$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)`
  
  ## Javascript
  
   ``
  
  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++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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`` ` `/* 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`
  
  ## PHP
  
   ` ``\$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``?>`
  
  ## Javascript
  
   ``
  
  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++
  
   `// C++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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
  
   `// 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 the``array 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
  
   `# 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 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 Code``if` `__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#
  
   `// 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 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 Code``public` `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
  
   `= 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``?>`
  
  ## Javascript
  
   ``
  
  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++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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 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;``}`
  
  ## C
  
   `#include`` ` `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 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
  
   `// Java program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``import` `java.io.*;``public` `class` `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`
  
  ## Python3
  
   `# 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#
  
   `// 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`
  
  ## PHP
  
   ` 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 calling``echo` `"Maximum difference is "` `. ``             ``maxDiff(``\$arr``, ``\$n``);`` ` `// This code is contributed ``// by Akanksha Rai`
  
  ## Javascript
  
   ``
  
  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++
  
   `// C++ program to find Maximum difference ``// between two elements such that larger ``// element appears after the smaller number``#include ``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 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)`
  
  ## PHP
  
   ` 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``?>`
  
  ## Javascript
  
   ``
  
  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
distilabel_metadata.role: user
distilabel_metadata.raw_output_q_a_detector_0: The provided text contains a detailed explanation and implementation of a problem related to finding the maximum difference between two elements in an array, where the larger element appears after the smaller one. The text includes multiple methods to solve the problem, each with its own code implementation in various programming languages. Here's a brief summary:
  
  ### Problem Statement:
  Given an array `arr[]` of integers, find the maximum difference between any two elements such that the larger element appears after the smaller number.
  
  ### Example:
  - **Input:** `arr = {2, 3, 10, 6, 4, 8, 1}`
  - **Output:** `8`
  - **Explanation:** The maximum difference is between 10 and 2.
  
  ### Methods to Solve the Problem:
  
  1. **Method 1 (Simple):**
     - Use two nested loops to find the maximum difference.
     - Time Complexity: O(n^2)
     - Space Complexity: O(1)
  
  2. **Method 2 (Tricky and Efficient):**
     - Keep track of the minimum element visited so far and the maximum difference.
     - Time Complexity: O(n)
     - Space Complexity: O(1)
  
  3. **Method 3 (Another Tricky Solution):