# Longest subarray such that difference of max and min is at-most K

Given an array arr[] of length N, tark is to find the length of longest subarray such that difference of its maximum element and minumum element is not more than an integer K

Examples:

Input: K = 3, arr[]= {1, 4, 5, 6, 9}
Output: 3
Explanation:
Largest Subarray is {4, 5, 6}

Input: K = 4, arr[]= {1, 2, 3, 4, 5}
Output: 5
Explanation:
Largest Subarray is {1, 2, 3, 4, 5}

Naive approach:

Time Complexity: O(N3)

Efficient approach: The idea is to first sort the array, and then use binary search to optimize the approach.

• Sort the given array
• For every distinct element A[i] in the array find the first element A[j] such that (A[j]-A[i]) > K.
• For its implementation we use Binary search or lower_bound and update ans each time as maximum of previous ans and difference of indixes.

Below is the implementation of the above approach:

 `// C++ program to find longest ` `// subarray such that difference ` `// of max and min is at-most K ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate longest ` `// subarray with above condition ` `int` `findLargestSubarray( ` `    ``vector<``int``>& arr, ` `    ``int` `N, ``int` `K) ` `{ ` ` `  `    ``// Sort the array ` `    ``sort(arr.begin(), arr.end()); ` ` `  `    ``int` `value1 = arr, value2 = 0; ` `    ``int` `index1, index2, i, MAX; ` `    ``index1 = index2 = 0; ` `    ``i = 0, MAX = 0; ` ` `  `    ``// Loop which will terminate ` `    ``// when no further elements ` `    ``// can be included in the subarray ` ` `  `    ``while` `(index2 != N) { ` ` `  `        ``// first value such that ` `        ``// arr[index2] - arr[index1] > K ` `        ``value2 = value1 + (K + 1); ` ` `  `        ``// calculate its index using lower_bound ` `        ``index2 = lower_bound(arr.begin(), ` `                             ``arr.end(), value2) ` `                 ``- arr.begin(); ` ` `  `        ``// index2- index1 will give ` `        ``// the accurate length ` `        ``// of suarray then compare ` `        ``// for MAX length and store ` `        ``// in MAX variable ` `        ``MAX = max(MAX, (index2 - index1)); ` ` `  `        ``// change the index1 ` `        ``// to next greater element ` `        ``// than previous one ` `        ``// and recalculate the value1 ` `        ``index1 ` `            ``= lower_bound( ` `                  ``arr.begin(), ` `                  ``arr.end(), arr[index1] + 1) ` `              ``- arr.begin(); ` `        ``value1 = arr[index1]; ` `    ``} ` ` `  `    ``// finally return answer MAX ` `    ``return` `MAX; ` `} ` `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N, K; ` `    ``N = 18; ` `    ``K = 5; ` `    ``vector<``int``> arr{ 1, 1, 1, 2, 2, ` `                     ``2, 2, 2, 3, ` `                     ``3, 3, 6, 6, 7, ` `                     ``7, 7, 7, 7 }; ` `    ``cout << findLargestSubarray(arr, N, K); ` `    ``return` `0; ` `} `

Output:

```15
```

Time Complexity: O(N*log(N)) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.