# Lexicographically smallest array formed by at most one swap for every pair of adjacent indices

Given an array A[] of length N, the task is to find lexicographically smallest array by swapping adjacent elements for each index atmost once. Thus, for any index: , at most one swap between A[K] and A[K+1] is allowed.

Example:

Input: A[] = { 3, 2, 1, 4}
Output: 1 3 2 4
Explanation: Perform the following swaps:
Swap A and A, now A[] = { 3, 1, 2, 4 }
Swap A and A, now A[] = { 1, 3, 2, 4 }
No further swaps are possible as A and A have already been swapped.

Input: A[] = { 2, 1, 4, 3, 6, 5 }
Output: 1 2 3 4 5 6
Explanation: Perform the following swaps:
Swap A and A, now A[] = { 1, 2, 4, 3, 6, 5 }
Swap A and A, now A[] = { 1, 2, 3, 4, 6, 5 }
Swap A and A, now A[] = { 1, 2, 3, 4, 5, 6 }

Approach:
To solve the problem mentioned above we can apply Greedy method. We know that we can perform at most N – 1 swaps to make the given array as smallest as possible.

• Create a counter variable and initialize with N-1 and a hash-map to store performed swaps.
• Find the position of the minimum element from current index onward.
• Now perform swap backwards until we reach current element position.
• Also check if current swap is possible or not and decrement the counter also at each swap.
• Finally print the required array.

Below is the implementation of above approach:

## C++

 `// C++ implementation to find the ` `// lexicographically smallest ` `// array by at most single swap ` `// for every pair of adjacent indices ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to find the ` `// lexicographically smallest array ` `void` `findSmallestArray(``int` `A[], ``int` `n) ` `{ ` `    ``// maximum swaps possible ` `    ``int` `count = n - 1; ` ` `  `    ``// hash to store swaps performed ` `    ``map, ``int``> mp; ` ` `  `    ``for` `(``int` `i = 0; i < n && count > 0; ++i) { ` ` `  `        ``// let current element be ` `        ``// the minimum possible ` `        ``int` `mn = A[i], pos = i; ` ` `  `        ``// Find actual position of ` `        ``// the minimum element ` `        ``for` `(``int` `j = i + 1; j < n; ++j) { ` ` `  `            ``// Update minimum element and ` `            ``// its position ` `            ``if` `(A[j] < mn) { ` `                ``mn = A[j]; ` `                ``pos = j; ` `            ``} ` `        ``} ` ` `  `        ``// Perform swaps if possible ` `        ``while` `(pos > i && count > 0 ` `               ``&& !mp[{ pos - 1, pos }]) { ` ` `  `            ``// Insert current swap in hash ` `            ``mp[{ pos - 1, pos }] = 1; ` ` `  `            ``swap(A[pos], A[pos - 1]); ` `            ``--pos; ` `            ``--count; ` `        ``} ` `    ``} ` ` `  `    ``// print the required array ` `    ``for` `(``int` `i = 0; i < n; ++i) ` `        ``cout << A[i] << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `A[] = { 2, 1, 4, 3, 6, 5 }; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A); ` ` `  `    ``findSmallestArray(A, n); ` ` `  `    ``return` `0; ` `} `

Output:

```1 2 3 4 5 6
```

Time Complexity: O(N2)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

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.