# Find the Minimum length Unsorted Subarray, sorting which makes the complete array sorted

Given an unsorted array arr[0..n-1] of size n, find the minimum length subarray arr[s..e] such that sorting this subarray makes the whole array sorted.
Examples:

1. If the input array is [10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60], your program should be able to find that the subarray lies between indexes 3 and 8.
2. If the input array is [0, 1, 15, 25, 6, 7, 30, 40, 50], your program should be able to find that the subarray lies between indexes 2 and 5.
Recommended Practice

Approach 1:

Idea/Intuition :

```Make a temporary array same as the given array ,sort the temporary array . Now check
from starting at which index the element of the given array and temporary array are
unequal and store it in temporary variable s . Repeat the above From the end and store
the index at another temporary variable e . The length e-s+1 is the length of smallest
unequal subarray .```

Algorithm :

• Declare a temporary array temp same as given array arr.
• Sort the temporary array .
• Initialize variable s with 0 and e with 0.
• Checking the unequal element from start and storing it in s variable .
• Checking the equal element from end and storing it in e variable.
• Returning (e-s+1) .
• Printing the result .

Below is the implementation of above approach .

Code :

## C++

 `#include ` `using` `namespace` `std;`   `// function performing calculation` `int` `minLength(vector<``int``>& arr)` `{` `    ``// temporary array equal to given array` `    ``vector<``int``> temp = arr;` `    ``// sorting the temporary array` `    ``sort(temp.begin(), temp.end());` `    ``// initializing indices` `    ``int` `s = 0, e = 0;` `    ``// checking the unequal element from start and storing` `    ``// it in s variable` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``if` `(arr[i] != temp[i]) {` `            ``s = i;` `            ``break``;` `        ``}` `    ``}` `    ``// checking the unequal element from end and storing it` `    ``// in e variable` `    ``for` `(``int` `i = arr.size() - 1; i >= 0; i--) {` `        ``if` `(arr[i] != temp[i]) {` `            ``e = i;` `            ``break``;` `        ``}` `    ``}` `    ``// returning minimum length` `    ``return` `(e - s + 1);` `}`   `// driver function` `int` `main()` `{` `    ``// given array arr` `    ``vector<``int``> arr` `        ``= { 10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60 };` `    ``// calling the function performing calculation and` `    ``// printing the result` `    ``cout << ``"Minimum length of subarray is : "` `         ``<< minLength(arr);` `    ``return` `0;` `}`

## Python3

 `# importing the library` `from` `typing ``import` `List`   `# function performing calculation` `def` `minLength(arr: ``List``[``int``]) ``-``> ``int``:` `  `  `    ``# temporary array equal to given array` `    ``temp ``=` `arr[:]` `    `  `    ``# sorting the temporary array` `    ``temp.sort()` `    `  `    ``# initializing indices` `    ``s ``=` `0` `    ``e ``=` `0` `    `  `    ``# checking the unequal element from start and storing` `    ``# it in s variable` `    ``for` `i ``in` `range``(``len``(arr)):` `        ``if` `arr[i] !``=` `temp[i]:` `            ``s ``=` `i` `            ``break` `            `  `    ``# checking the unequal element from end and storing it` `    ``# in e variable` `    ``for` `i ``in` `range``(``len``(arr)``-``1``, ``-``1``, ``-``1``):` `        ``if` `arr[i] !``=` `temp[i]:` `            ``e ``=` `i` `            ``break` `            `  `    ``# returning minimum length` `    ``return` `(e ``-` `s ``+` `1``)`   `# driver function` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``# given array arr` `    ``arr ``=` `[``10``, ``12``, ``20``, ``30``, ``25``, ``40``, ``32``, ``31``, ``35``, ``50``, ``60``]` `    `  `    ``# calling the function performing calculation and` `    ``# printing the result` `    ``print``(``"Minimum length of subarray is : "``, minLength(arr))` `    `  `# This code is contributed by divyansh2212`

## C#

 `using` `System;` `using` `System.Linq;`   `class` `Program` `{` `  ``//function performing calculations ` `    ``static` `int` `MinLength(``int``[] arr)` `    ``{` `      ``//temporary array equal to given array` `        ``int``[] temp = arr.ToArray();` `      ``//sorting the temporary array` `        ``Array.Sort(temp);` `        ``//initializing indices` `        ``int` `s = 0;` `        ``int` `e = 0;` `        ``//checking the unequal element from start and storing it in s variable` `        ``for` `(``int` `i = 0; i < arr.Length; i++)` `        ``{` `            ``if` `(arr[i] != temp[i])` `            ``{` `                ``s = i;` `                ``break``;` `            ``}` `        ``}` `        ``//checking the unequal elements from end and storing it in e variable` `        ``for` `(``int` `i = arr.Length - 1; i >= 0; i--)` `        ``{` `            ``if` `(arr[i] != temp[i])` `            ``{` `                ``e = i;` `                ``break``;` `            ``}` `        ``}` `        `  `      ``//returning minimum length` `        ``return` `e - s + 1;` `    ``}`   `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``int``[] arr = ``new` `int``[] { 10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60 };` `        ``Console.WriteLine(``"Minimum length of subarray is : "` `+ MinLength(arr));` `    ``}` `}` `//This code is contributed by snehalsalokhe`

## Java

 `import` `java.util.*;`   `public` `class` `GFG {` `    ``// function performing calculation` `    ``public` `static` `int` `minLength(ArrayList arr) {` `        ``// temporary array equal to given array` `        ``ArrayList temp = ``new` `ArrayList(arr);` `        ``// sorting the temporary array` `        ``Collections.sort(temp);` `        ``// initializing indices` `        ``int` `s = ``0``, e = ``0``;` `        ``// checking the unequal element from start and storing` `        ``// it in s variable` `        ``for` `(``int` `i = ``0``; i < arr.size(); i++) {` `            ``if` `(arr.get(i) != temp.get(i)) {` `                ``s = i;` `                ``break``;` `            ``}` `        ``}` `        ``// checking the unequal element from end and storing it` `        ``// in e variable` `        ``for` `(``int` `i = arr.size() - ``1``; i >= ``0``; i--) {` `            ``if` `(arr.get(i) != temp.get(i)) {` `                ``e = i;` `                ``break``;` `            ``}` `        ``}` `        ``// returning minimum length` `        ``return` `(e - s + ``1``);` `    ``}`   `    ``// driver function` `    ``public` `static` `void` `main(String[] args) {` `        ``// given array arr` `        ``ArrayList arr = ``new` `ArrayList(` `            ``Arrays.asList(``10``, ``12``, ``20``, ``30``, ``25``, ``40``, ``32``, ``31``, ``35``, ``50``, ``60``)` `        ``);` `        ``// calling the function performing calculation and` `        ``// printing the result` `        ``System.out.println(``"Minimum length of subarray is : "` `+ minLength(arr));` `    ``}` `}`

## Javascript

 `// function performing calculation` `function` `minLength(arr)` `{` `    ``// temporary array equal to given array` `    ``let temp = [];` `    ``for``(let i=0;i= 0; i--) {` `        ``if` `(arr[i] != temp[i]) {` `            ``e = i;` `            ``break``;` `        ``}` `    ``}` `    `  `    ``// returning minimum length` `    ``return` `(e - s + 1);` `}`   `// driver function` `  ``// given array arr` `let arr = [ 10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60 ];`   `  ``// calling the function performing calculation and` `  ``// printing the result` `console.log(``"Minimum length of subarray is : "` `        ``+ minLength(arr));` `        `  `// This code is contributed by akashish__`

Output

`Minimum length of subarray is : 6`

Time Complexity : O(NLog(N)) , where N is the size of given array

Space Complexity : O(N) , Space for temporary array temp .

Approach 2:

1. Find the candidate unsorted subarray
1. Scan from left to right and find the first element which is greater than the next element. Let s be the index of such an element. In the above example 1, s is 3 (index of 30).
2. Scan from right to left and find the first element (first in right to left order) which is smaller than the next element (next in right to left order). Let e be the index of such an element. In the above example 1, e is 7 (index of 31).
2. Check whether sorting the candidate unsorted subarray makes the complete array sorted or not. If not, then include more elements in the subarray.
1. Find the minimum and maximum values in arr[s..e]. Let minimum and maximum values be min and max. min and max for [30, 25, 40, 32, 31] are 25 and 40 respectively.
2. Find the first element (if there is any) in arr[0..s-1] which is greater than min, change s to index of this element. There is no such element in above example 1.
3. Find the last element (if there is any) in arr[e+1..n-1] which is smaller than max, change e to index of this element. In the above example 1, e is changed to 8 (index of 35)
3. Print s and e.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the Minimum length Unsorted Subarray, ` `// sorting which makes the complete array sorted` `#include` `using` `namespace` `std;`   `void` `printUnsorted(``int` `arr[], ``int` `n)` `{` `int` `s = 0, e = n-1, i, max, min; `   `// step 1(a) of above algo` `for` `(s = 0; s < n-1; s++)` `{` `    ``if` `(arr[s] > arr[s+1])` `    ``break``;` `}` `if` `(s == n-1)` `{` `    ``cout << ``"The complete array is sorted"``;` `    ``return``;` `}`   `// step 1(b) of above algo` `for``(e = n - 1; e > 0; e--)` `{` `    ``if``(arr[e] < arr[e-1])` `    ``break``;` `}`   `// step 2(a) of above algo` `max = arr[s]; min = arr[s];` `for``(i = s + 1; i <= e; i++)` `{` `    ``if``(arr[i] > max)` `    ``max = arr[i];` `    ``if``(arr[i] < min)` `    ``min = arr[i];` `}`   `// step 2(b) of above algo` `for``( i = 0; i < s; i++)` `{` `    ``if``(arr[i] > min)` `    ``{ ` `    ``s = i;` `    ``break``;` `    ``}     ` `} `   `// step 2(c) of above algo` `for``( i = n -1; i >= e+1; i--)` `{` `    ``if``(arr[i] < max)` `    ``{` `    ``e = i;` `    ``break``;` `    ``} ` `} ` `    `  `// step 3 of above algo` `cout << ``"The unsorted subarray which"` `     ``<< ``" makes the given array"` `<< endl` `     ``<< ``"sorted lies between the indices "` `     ``<< s << ``" and "` `<< e;` `return``;` `}`   `int` `main()` `{` `    ``int` `arr[] = {10, 12, 20, 30, 25,` `                 ``40, 32, 31, 35, 50, 60};` `    ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);` `    ``printUnsorted(arr, arr_size);` `    ``getchar``();` `    ``return` `0;` `}`   `// This code is contributed ` `// by Akanksha Rai`

## C

 `// C program to find the Minimum length Unsorted Subarray, ` `// sorting which makes the complete array sorted` `#include` ` `  `void` `printUnsorted(``int` `arr[], ``int` `n)` `{` `  ``int` `s = 0, e = n-1, i, max, min;   ` ` `  `  ``// step 1(a) of above algo` `  ``for` `(s = 0; s < n-1; s++)` `  ``{` `    ``if` `(arr[s] > arr[s+1])` `      ``break``;` `  ``}` `  ``if` `(s == n-1)` `  ``{` `    ``printf``(``"The complete array is sorted"``);` `    ``return``;` `  ``}` ` `  `  ``// step 1(b) of above algo` `  ``for``(e = n - 1; e > 0; e--)` `  ``{` `    ``if``(arr[e] < arr[e-1])` `      ``break``;` `  ``}` ` `  `  ``// step 2(a) of above algo` `  ``max = arr[s]; min = arr[s];` `  ``for``(i = s + 1; i <= e; i++)` `  ``{` `    ``if``(arr[i] > max)` `      ``max = arr[i];` `    ``if``(arr[i] < min)` `      ``min = arr[i];` `  ``}` ` `  `  ``// step 2(b) of above algo` `  ``for``( i = 0; i < s; i++)` `  ``{` `    ``if``(arr[i] > min)` `    ``{  ` `      ``s = i;` `      ``break``;` `    ``}      ` `  ``} ` ` `  `  ``// step 2(c) of above algo` `  ``for``( i = n -1; i >= e+1; i--)` `  ``{` `    ``if``(arr[i] < max)` `    ``{` `      ``e = i;` `      ``break``;` `    ``} ` `  ``}  ` `     `  `  ``// step 3 of above algo` `  ``printf``(``" The unsorted subarray which makes the given array "` `         ``" sorted lies between the indees %d and %d"``, s, e);` `  ``return``;` `}` ` `  `int` `main()` `{` `  ``int` `arr[] = {10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60};` `  ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);` `  ``printUnsorted(arr, arr_size);` `  ``getchar``();` `  ``return` `0;` `}`

## Java

 `// Java program to find the Minimum length Unsorted Subarray, ` `// sorting which makes the complete array sorted` `import` `java.io.*;` `class` `Main` `{` `    ``static` `void` `printUnsorted(``int` `arr[], ``int` `n)` `    ``{` `      ``int` `s = ``0``, e = n-``1``, i, max, min;   ` `      `  `      ``// step 1(a) of above algo` `      ``for` `(s = ``0``; s < n-``1``; s++)` `      ``{` `        ``if` `(arr[s] > arr[s+``1``])` `          ``break``;` `      ``}` `      ``if` `(s == n-``1``)` `      ``{` `        ``System.out.println(``"The complete array is sorted"``);` `        ``return``;` `      ``}` `      `  `      ``// step 1(b) of above algo` `      ``for``(e = n - ``1``; e > ``0``; e--)` `      ``{` `        ``if``(arr[e] < arr[e-``1``])` `          ``break``;` `      ``}` `      `  `      ``// step 2(a) of above algo` `      ``max = arr[s]; min = arr[s];` `      ``for``(i = s + ``1``; i <= e; i++)` `      ``{` `        ``if``(arr[i] > max)` `          ``max = arr[i];` `        ``if``(arr[i] < min)` `          ``min = arr[i];` `      ``}` `      `  `      ``// step 2(b) of above algo` `      ``for``( i = ``0``; i < s; i++)` `      ``{` `        ``if``(arr[i] > min)` `        ``{  ` `          ``s = i;` `          ``break``;` `        ``}      ` `      ``} ` `      `  `      ``// step 2(c) of above algo` `      ``for``( i = n -``1``; i >= e+``1``; i--)` `      ``{` `        ``if``(arr[i] < max)` `        ``{` `          ``e = i;` `          ``break``;` `        ``} ` `      ``}  ` `          `  `      ``// step 3 of above algo` `      ``System.out.println(``" The unsorted subarray which"``+` `                         ``" makes the given array sorted lies"``+` `                       ``"  between the indices "``+s+``" and "``+e);` `      ``return``;` `    ``}` `      `  `    ``public` `static` `void` `main(String args[])` `    ``{` `      ``int` `arr[] = {``10``, ``12``, ``20``, ``30``, ``25``, ``40``, ``32``, ``31``, ``35``, ``50``, ``60``};` `      ``int` `arr_size = arr.length;` `      ``printUnsorted(arr, arr_size);` `    ``}` `}`

## Python3

 `# Python3 program to find the Minimum length Unsorted Subarray, ` `# sorting which makes the complete array sorted` `def` `printUnsorted(arr, n):` `    ``e ``=` `n``-``1` `    ``# step 1(a) of above algo` `    ``for` `s ``in` `range``(``0``,n``-``1``):` `        ``if` `arr[s] > arr[s``+``1``]:` `            ``break` `        `  `    ``if` `s ``=``=` `n``-``1``:` `        ``print` `(``"The complete array is sorted"``)` `        ``exit()`   `    ``# step 1(b) of above algo` `    ``e``=` `n``-``1` `    ``while` `e > ``0``:` `        ``if` `arr[e] < arr[e``-``1``]:` `            ``break` `        ``e ``-``=` `1`   `    ``# step 2(a) of above algo` `    ``max` `=` `arr[s]` `    ``min` `=` `arr[s]` `    ``for` `i ``in` `range``(s``+``1``,e``+``1``):` `        ``if` `arr[i] > ``max``:` `            ``max` `=` `arr[i]` `        ``if` `arr[i] < ``min``:` `            ``min` `=` `arr[i]` `            `  `    ``# step 2(b) of above algo` `    ``for` `i ``in` `range``(s):` `        ``if` `arr[i] > ``min``:` `            ``s ``=` `i` `            ``break`   `    ``# step 2(c) of above algo` `    ``i ``=` `n``-``1` `    ``while` `i >``=` `e``+``1``:` `        ``if` `arr[i] < ``max``:` `            ``e ``=` `i` `            ``break` `        ``i ``-``=` `1` `    `  `    ``# step 3 of above algo` `    ``print` `(``"The unsorted subarray which makes the given array"``)` `    ``print` `(``"sorted lies between the indexes %d and %d"``%``( s, e))`   `arr ``=` `[``10``, ``12``, ``20``, ``30``, ``25``, ``40``, ``32``, ``31``, ``35``, ``50``, ``60``]` `arr_size ``=` `len``(arr)` `printUnsorted(arr, arr_size)`   `# This code is contributed by Shreyanshi Arun`

## C#

 `// C# program to find the Minimum length Unsorted Subarray, ` `// sorting which makes the complete array sorted`   `using` `System;`   `class` `GFG` `{` `    ``static` `void` `printUnsorted(``int` `[]arr, ``int` `n)` `    ``{` `    ``int` `s = 0, e = n-1, i, max, min; ` `        `  `    ``// step 1(a) of above algo` `    ``for` `(s = 0; s < n-1; s++)` `    ``{` `        ``if` `(arr[s] > arr[s+1])` `        ``break``;` `    ``}` `    ``if` `(s == n-1)` `    ``{` `        ``Console.Write(``"The complete "` `+` `                            ``"array is sorted"``);` `        ``return``;` `    ``}` `        `  `    ``// step 1(b) of above algo` `    ``for``(e = n - 1; e > 0; e--)` `    ``{` `        ``if``(arr[e] < arr[e-1])` `        ``break``;` `    ``}` `        `  `    ``// step 2(a) of above algo` `    ``max = arr[s]; min = arr[s];` `    `  `    ``for``(i = s + 1; i <= e; i++)` `    ``{` `        ``if``(arr[i] > max)` `            ``max = arr[i];` `        `  `        ``if``(arr[i] < min)` `            ``min = arr[i];` `    ``}` `        `  `    ``// step 2(b) of above algo` `    ``for``( i = 0; i < s; i++)` `    ``{` `        ``if``(arr[i] > min)` `        ``{ ` `            ``s = i;` `            ``break``;` `        ``}     ` `    ``} ` `        `  `    ``// step 2(c) of above algo` `    ``for``( i = n -1; i >= e+1; i--)` `    ``{` `        ``if``(arr[i] < max)` `        ``{` `            ``e = i;` `            ``break``;` `        ``} ` `    ``} ` `            `  `    ``// step 3 of above algo` `    ``Console.Write(``" The unsorted subarray which"``+` `            ``" makes the given array sorted lies \n"``+` `              ``" between the indices "``+s+``" and "``+e);` `    ``return``;` `    ``}` `        `  `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `[]arr = {10, 12, 20, 30, 25, 40,` `                                ``32, 31, 35, 50, 60};` `        ``int` `arr_size = arr.Length;` `        `  `        ``printUnsorted(arr, arr_size);` `    ``}` `}`   `// This code contributed by Sam007`

## PHP

 ` ``\$arr``[``\$s` `+ 1])` `        ``break``;` `    ``}` `    ``if` `(``\$s` `== ``\$n` `- 1)` `    ``{` `        ``echo` `"The complete array is sorted"``;` `        ``return``;` `    ``}` `    `  `    ``// step 1(b) of above algo` `    ``for``(``\$e` `= ``\$n` `- 1; ``\$e` `> 0; ``\$e``--)` `    ``{` `        ``if``(``\$arr``[``\$e``] < ``\$arr``[``\$e` `- 1])` `        ``break``;` `    ``}` `    `  `    ``// step 2(a) of above algo` `    ``\$max` `= ``\$arr``[``\$s``]; ` `    ``\$min` `= ``\$arr``[``\$s``];` `    ``for``(``\$i` `= ``\$s` `+ 1; ``\$i` `<= ``\$e``; ``\$i``++)` `    ``{` `        ``if``(``\$arr``[``\$i``] > ``\$max``)` `            ``\$max` `= ``\$arr``[``\$i``];` `        ``if``(``\$arr``[``\$i``] < ``\$min``)` `            ``\$min` `= ``\$arr``[``\$i``];` `    ``}` `    `  `    ``// step 2(b) of above algo` `    ``for``( ``\$i` `= 0; ``\$i` `< ``\$s``; ``\$i``++)` `    ``{` `        ``if``(``\$arr``[``\$i``] > ``\$min``)` `        ``{ ` `            ``\$s` `= ``\$i``;` `            ``break``;` `        ``}     ` `    ``} ` `    `  `    ``// step 2(c) of above algo` `    ``for``( ``\$i` `= ``\$n` `- 1; ``\$i` `>= ``\$e` `+ 1; ``\$i``--)` `    ``{` `        ``if``(``\$arr``[``\$i``] < ``\$max``)` `        ``{` `            ``\$e` `= ``\$i``;` `            ``break``;` `        ``} ` `    ``} ` `        `  `    ``// step 3 of above algo` `    ``echo` `" The unsorted subarray which makes "` `. ` `                     ``"the given array "` `. ``"\n"` `. ` `            ``" sorted lies between the indees "` `. ` `                              ``\$s` `. ``" and "` `. ``\$e``;` `    ``return``;` `}`   `// Driver code` `\$arr` `= ``array``(10, 12, 20, 30, 25, 40, ` `             ``32, 31, 35, 50, 60);` `\$arr_size` `= sizeof(``\$arr``);` `printUnsorted(``\$arr``, ``\$arr_size``);`   `// This code is contributed ` `// by ChitraNayal` `?>`

## Javascript

 ``

Output

```The unsorted subarray which makes the given array
sorted lies between the indices 3 and 8```

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

Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next