Skip to content
Related Articles
Minimum insertions to sort an array
• Difficulty Level : Medium
• Last Updated : 22 Mar, 2021

Given an array of integer numbers, we need to sort this array in a minimum number of steps where in one step we can insert any array element from its position to any other position.
Examples :

```Input  : arr[] = [2, 3, 5, 1, 4, 7, 6]
Output : 3
We can sort above array in 3 insertion
steps as shown below,
1 before array value 2
4 before array value 5
6 before array value 7

Input : arr[] = {4, 6, 5, 1}
Output : 2```

We can solve this problem using dynamic programming. The main thing to observe is that moving an element doesn’t change the relative order of elements other than the element which is being moved. Now consider longest increasing subsequence (LIS) in which equal element are also taken as part of the increasing sequence, now if keep the element of this increasing sequence as it is and move all other elements then it will take the least number of steps because we have taken longest subsequence which does not need to be moved. Finally, the answer will be the size of the array minus the size of the longest increasing subsequence.
As LIS problem can be solved in O(N^2) with O(N) extra space using Dynamic Programming.
Below is the implementation of above idea.

## C++

 `// C++ program to get minimum number of insertion``// steps to sort an array``#include ``using` `namespace` `std;` `//  method returns min steps of insertion we need``// to perform to sort array 'arr'``int` `minInsertionStepToSortArray(``int` `arr[], ``int` `N)``{``    ``// lis[i] is going to store length of lis``    ``// that ends with i.``    ``int` `lis[N];` `    ``/* Initialize lis values for all indexes */``    ``for` `(``int` `i = 0; i < N; i++)``        ``lis[i] = 1;` `    ``/* Compute optimized lis values in bottom up manner */``    ``for` `(``int` `i = 1; i < N; i++)``        ``for` `(``int` `j = 0; j < i; j++)``            ``if` `(arr[i] >= arr[j] && lis[i] < lis[j] + 1)``                ``lis[i] = lis[j] + 1;` `    ``/* The overall LIS must end with of the array``       ``elements. Pick maximum of all lis values */``    ``int` `max = 0;``    ``for` `(``int` `i = 0; i < N; i++)``        ``if` `(max < lis[i])``            ``max = lis[i];` `    ``// return size of array minus length of LIS``    ``// as final result``    ``return` `(N - max);``}` `// Driver code to test above methods``int` `main()``{``    ``int` `arr[] = {2, 3, 5, 1, 4, 7, 6};``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << minInsertionStepToSortArray(arr, N);``    ``return` `0;``}`

## Java

 `// Java program to get minimum number of insertion``// steps to sort an array``class` `Main``{` `    ``//  method returns min steps of insertion we need``    ``// to perform to sort array 'arr'``    ``static` `int` `minInsertionStepToSortArray(``int` `arr[], ``int` `N)``    ``{``        ``// lis[i] is going to store length of lis``        ``// that ends with i.``        ``int``[] lis = ``new` `int``[N];``     ` `        ``/* Initialize lis values for all indexes */``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``lis[i] = ``1``;``     ` `        ``/* Compute optimized lis values in bottom up manner */``        ``for` `(``int` `i = ``1``; i < N; i++)``            ``for` `(``int` `j = ``0``; j < i; j++)``                ``if` `(arr[i] >= arr[j] && lis[i] < lis[j] + ``1``)``                    ``lis[i] = lis[j] + ``1``;``     ` `        ``/* The overall LIS must end with of the array``           ``elements. Pick maximum of all lis values */``        ``int` `max = ``0``;``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``if` `(max < lis[i])``                ``max = lis[i];``     ` `        ``// return size of array minus length of LIS``        ``// as final result``        ``return` `(N - max);``    ``}``     ` `    ``// Driver code to test above methods``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `arr[] = {``2``, ``3``, ``5``, ``1``, ``4``, ``7``, ``6``};``        ``int` `N = arr.length;``        ``System.out.println(minInsertionStepToSortArray(arr, N));``    ``}``}` `/* This code is contributed by Harsh Agarwal */`

## Python 3

 `# Python3 program to get minimum number``# of insertion steps to sort an array` `# method returns min steps of insertion``# we need to perform to sort array 'arr'``def` `minInsertionStepToSortArray(arr, N):` `    ``# lis[i] is going to store length``    ``# of lis that ends with i.``    ``lis ``=` `[``0``] ``*` `N` `    ``# Initialize lis values for all indexes``    ``for` `i ``in` `range``(N):``        ``lis[i] ``=` `1` `    ``# Compute optimized lis values in``    ``# bottom up manner``    ``for` `i ``in` `range``(``1``, N):``        ``for` `j ``in` `range``(i):``            ``if` `(arr[i] >``=` `arr[j] ``and``                ``lis[i] < lis[j] ``+` `1``):``                ``lis[i] ``=` `lis[j] ``+` `1` `    ``# The overall LIS must end with of the array``    ``# elements. Pick maximum of all lis values``    ``max` `=` `0``    ``for` `i ``in` `range``(N):``        ``if` `(``max` `< lis[i]):``            ``max` `=` `lis[i]` `    ``# return size of array minus length``    ``# of LIS as final result``    ``return` `(N ``-` `max``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``2``, ``3``, ``5``, ``1``, ``4``, ``7``, ``6``]``    ``N ``=` `len``(arr)``    ``print` `(minInsertionStepToSortArray(arr, N))` `# This code is contributed by ita_c`

## C#

 `// C# program to get minimum number of``// insertion steps to sort an array``using` `System;` `class` `GfG {``    ` `    ``// method returns min steps of insertion``    ``// we need to perform to sort array 'arr'``    ``static` `int` `minInsertionStepToSortArray(``                             ``int` `[]arr, ``int` `N)``    ``{``        ` `        ``// lis[i] is going to store length``        ``// of lis that ends with i.``        ``int``[] lis = ``new` `int``[N];``    ` `        ``/* Initialize lis values for all``        ``indexes */``        ``for` `(``int` `i = 0; i < N; i++)``            ``lis[i] = 1;``    ` `        ``/* Compute optimized lis values in``        ``bottom up manner */``        ``for` `(``int` `i = 1; i < N; i++)``            ``for` `(``int` `j = 0; j < i; j++)``                ``if` `(arr[i] >= arr[j] &&``                        ``lis[i] < lis[j] + 1)``                    ``lis[i] = lis[j] + 1;``    ` `        ``/* The overall LIS must end with of``        ``the array elements. Pick maximum``        ``of all lis values */``        ``int` `max = 0;``        ` `        ``for` `(``int` `i = 0; i < N; i++)``            ``if` `(max < lis[i])``                ``max = lis[i];``    ` `        ``// return size of array minus length``        ``// of LIS as final result``        ``return` `(N - max);``    ``}``    ` `    ``// Driver code to test above methods``    ``public` `static` `void` `Main (String[] args)``    ``{``        ``int` `[]arr = {2, 3, 5, 1, 4, 7, 6};``        ``int` `N = arr.Length;``        ` `        ``Console.Write(``          ``minInsertionStepToSortArray(arr, N));``    ``}``}` `// This code is contributed by parashar.`

## PHP

 `= ``\$arr``[``\$j``] &&``                ``\$lis``[``\$i``] < ``\$lis``[``\$j``] + 1)``                ` `                ``\$lis``[``\$i``] = ``\$lis``[``\$j``] + 1;` `    ``/* The overall LIS must end with``    ``of the array elements. Pick``    ``maximum of all lis values */``    ``\$max` `= 0;``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$N``; ``\$i``++)``        ``if` `(``\$max` `< ``\$lis``[``\$i``])``            ``\$max` `= ``\$lis``[``\$i``];` `    ``// return size of array minus``    ``// length of LIS as final result``    ``return` `(``\$N` `- ``\$max``);``}` `// Driver code``\$arr` `= ``array``(2, 3, 5, 1, 4, 7, 6);``\$N` `= sizeof(``\$arr``) / sizeof(``\$arr``);``echo` `minInsertionStepToSortArray(``\$arr``, ``\$N``);``    ` `// This code is contributed by nitin mittal``?>`

## Javascript

 ``

Output :

`3`

This article is contributed by Utkarsh Trivedi. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up