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 4Explanation:Perform the following swaps:

Swap A[1] and A[2], now A[] = { 3, 1, 2, 4 }

Swap A[0] and A[1], now A[] = { 1, 3, 2, 4 }

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

Swap A[0] and A[1], now A[] = { 1, 2, 4, 3, 6, 5 }

Swap A[2] and A[3], now A[] = { 1, 2, 3, 4, 6, 5 }

Swap A[4] and A[5], 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 <bits/stdc++.h>` `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<pair<` `int` `, ` `int` `>, ` `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[0]);` ` ` ` ` `findSmallestArray(A, n);` ` ` ` ` `return` `0;` `}` |

## Python3

`# Python3 implementation to find the` `# lexicographically smallest array by` `# at most single swap for every pair` `# of adjacent indices` ` ` `# Function to find the` `# lexicographically smallest array` `def` `findSmallestArray(A, n):` ` ` ` ` `# Maximum swaps possible` ` ` `count ` `=` `n ` `-` `1` ` ` ` ` `# Hash to store swaps performed` ` ` `mp ` `=` `{''}` ` ` ` ` `for` `i ` `in` `range` `(` `0` `, n):` ` ` `if` `(count <` `=` `0` `):` ` ` `break` `;` ` ` ` ` `# Let current element be` ` ` `# the minimum possible` ` ` `mn ` `=` `A[i]` ` ` `pos ` `=` `i` ` ` ` ` `# Find actual position of` ` ` `# the minimum element` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, n):` ` ` ` ` `# Update minimum element ` ` ` `# and its position` ` ` `if` `(A[j] < mn):` ` ` `mn ` `=` `A[j]` ` ` `pos ` `=` `j` ` ` ` ` `# Perform swaps if possible` ` ` `while` `(pos > i ` `and` `count > ` `0` `and` ` ` `((pos ` `-` `1` `, pos) ` `not` `in` `mp)):` ` ` ` ` `# Insert current swap in hash` ` ` `mp.add((pos ` `-` `1` `, pos))` ` ` ` ` `A[pos], A[pos ` `-` `1` `] ` `=` `A[pos ` `-` `1` `], A[pos]` ` ` `pos ` `-` `=` `1` ` ` `count ` `-` `=` `1` ` ` ` ` `# Print the required array` ` ` `for` `i ` `in` `range` `(` `0` `, n):` ` ` `print` `(A[i], end ` `=` `" "` `)` ` ` `# Driver code` `A ` `=` `[ ` `2` `, ` `1` `, ` `4` `, ` `3` `, ` `6` `, ` `5` `]` `n ` `=` `len` `(A)` ` ` `findSmallestArray(A, n)` ` ` `# This code is contributed by Sanjit_Prasad` |

**Output:**

1 2 3 4 5 6

**Time Complexity:*** O(N ^{2})*

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**