在仅允许相邻交换的情况下生成排列

给定一个长度为N的字符串。您只能交换相邻的元素，每个元素最多可以交换一次。找到执行交换后可以生成的字符串的排列编号。

例子：

Input : 12345
Output : 12345 12354 12435 13245 13254 
         21345 21354 21435

资料来源：高盛访谈

考虑字符串的第i个字符。此字符有两种可能性：
1.)不要交换它，即不要对此字符执行任何操作并移至下一个字符。
2.)交换它。由于可以与其相邻交换，
……..a。)将其与下一个字符交换。因为每个字符最多可以交换一次，所以我们将移至位置(i + 2)。
……。 b。)将其与前一个字符交换–我们不需要单独考虑这种情况，因为第i个字符是第(i-1)个字符的下一个字符，与情况2.a相同。

C++

// CPP program to generate permutations with only
// one swap allowed.
#include 
#include 
using namespace std;
  
void findPermutations(char str[], int index, int n)
{
    if (index >= n || (index + 1) >= n) {
        cout << str << endl;
        return;
    }
  
    // don't swap the current position
    findPermutations(str, index + 1, n);
  
    // Swap with the next character and
    // revert the changes. As explained
    // above, swapping with previous is
    // is not needed as it anyways happens
    // for next character.
    swap(str[index], str[index + 1]);
    findPermutations(str, index + 2, n);
    swap(str[index], str[index + 1]);
}
  
// Driver code
int main()
{
    char str[] = { "12345" };
    int n = strlen(str);
    findPermutations(str, 0, n);
    return 0;
}

Java

// Java program to generate permutations with only
// one swap allowed.
  
class GFG {
  
    static void findPermutations(char str[], int index, int n) {
        if (index >= n || (index + 1) >= n) {
            System.out.println(str);
            return;
        }
  
        // don't swap the current position
        findPermutations(str, index + 1, n);
  
        // Swap with the next character and
        // revert the changes. As explained
        // above, swapping with previous is
        // is not needed as it anyways happens
        // for next character.
        swap(str, index);
        findPermutations(str, index + 2, n);
        swap(str, index);
    }
  
    static void swap(char arr[], int index) {
        char temp = arr[index];
        arr[index] = arr[index + 1];
        arr[index + 1] = temp;
    }
// Driver code
  
    public static void main(String[] args) {
        char str[] = "12345".toCharArray();
        int n = str.length;
        findPermutations(str, 0, n);
    }
}
// This code is contributed by 29AjayKumar

Python3

# Python3 program to generate permutations 
# with only one swap allowed.
def findPermutations(string, index, n):
    if index >= n or (index + 1) >= n:
        print(''.join(string))
        return
  
    # don't swap the current position
    findPermutations(string, index + 1, n)
  
    # Swap with the next character and
    # revert the changes. As explained
    # above, swapping with previous is
    # is not needed as it anyways happens
    # for next character.
    string[index], \
    string[index + 1] = string[index + 1], \
                        string[index]
                          
    findPermutations(string, index + 2, n)
      
    string[index], \
    string[index + 1] = string[index + 1], \
                        string[index]
  
# Driver Code
if __name__ == "__main__":
    string = list("12345")
    n = len(string)
    findPermutations(string, 0, n)
  
# This code is contributed by
# sanjeev2552

C#

// C# program to generate permutations with only 
// one swap allowed. 
using System; 
public class GFG { 
  
    static void findPermutations(char []str, int index, int n) { 
        if (index >= n || (index + 1) >= n) { 
            Console.WriteLine(str); 
            return; 
        } 
  
        // don't swap the current position 
        findPermutations(str, index + 1, n); 
  
        // Swap with the next character and 
        // revert the changes. As explained 
        // above, swapping with previous is 
        // is not needed as it anyways happens 
        // for next character. 
        swap(str, index); 
        findPermutations(str, index + 2, n); 
        swap(str, index); 
    } 
  
    static void swap(char []arr, int index) { 
        char temp = arr[index]; 
        arr[index] = arr[index + 1]; 
        arr[index + 1] = temp; 
    } 
// Driver code 
  
    public static void Main() { 
        char []str = "12345".ToCharArray(); 
        int n = str.Length; 
        findPermutations(str, 0, n); 
    } 
} 
  
// This code is contributed by Rajput-Ji

PHP

= $n || ($index + 1) >= $n) 
    { 
        echo $str, "\n"; 
        return; 
    } 
  
    // don't swap the current position 
    findPermutations($str, $index + 1, $n); 
  
    // Swap with the next character and 
    // revert the changes. As explained 
    // above, swapping with previous is 
    // is not needed as it anyways happens 
    // for next character. 
    list($str[$index], 
         $str[$index + 1]) = array($str[$index + 1], 
                                   $str[$index]);
  
    findPermutations($str, $index + 2, $n); 
    list($str[$index], 
         $str[$index + 1]) = array($str[$index + 1],
                                   $str[$index]);
} 
  
// Driver code 
$str = "12345" ; 
$n = strlen($str); 
findPermutations($str, 0, $n); 
  
// This code is contributed by Sach_Code
?>

输出：

12345
12354
12435
13245
13254
21345
21354
21435