Alexander Bogomolny的无序排列算法

Alexander Bogomolyn的算法用于置换前N个自然数。
给定N的值，我们必须输出从1到N的所有数字排列。

例子：

Input : 2
Output : 1 2
         2 1

Input : 3
Output : 1 2 3
         1 3 2
         2 1 3
         3 1 2
         2 3 1
         3 2 1

这个想法是维护一个数组来存储当前排列。静态整数级变量用于定义这些排列。

1. 它初始化当前级别的值，并将剩余的值置换为更高的级别。
2. 当值的分配动作达到最高级别时，它将打印获得的排列。
3. 递归实现此方法以获得所有可能的排列。

C++

// CPP program to implement Alexander
// Bogomolny’s UnOrdered Permutation Algorithm
#include 
using namespace std;
  
// A function to print the permutation.
void print(int perm[], int N)
{
    for (int i = 0; i < N; i++)
        cout << " " << perm[i];
    cout << "\n";
}
  
// A function implementing Alexander Bogomolyn 
// algorithm.
void AlexanderBogomolyn(int perm[], int N, int k)
{
    static int level = -1;
  
    // Assign level to zero at start.
    level = level + 1;
    perm[k] = level;
  
    if (level == N)
        print(perm, N);
    else
        for (int i = 0; i < N; i++)
  
            // Assign values to the array 
            // if it is zero.
            if (perm[i] == 0)
                AlexanderBogomolyn(perm, N, i);
  
    // Decrement the level after all possible
    // permutation after that level.
    level = level - 1;
      
    perm[k] = 0;
}
  
// Driver Function
int main()
{
    int i, N = 3;
    int perm[N] = { 0 };
    AlexanderBogomolyn(perm, N, 0);
    return 0;
}

Java

// Java program to implement 
// Alexander Bogomolny UnOrdered 
// Permutation Algorithm
import java.io.*;
  
class GFG
{
static int level = -1;
  
// A function to print
// the permutation.
static void print(int perm[], int N)
{
    for (int i = 0; i < N; i++)
        System.out.print(" " + perm[i]);
    System.out.println();
}
  
// A function implementing 
// Alexander Bogomolyn algorithm.
static void AlexanderBogomolyn(int perm[], 
                               int N, int k)
{
  
    // Assign level to 
    // zero at start.
    level = level + 1;
    perm[k] = level;
  
    if (level == N)
        print(perm, N);
    else
        for (int i = 0; i < N; i++)
  
            // Assign values 
            // to the array 
            // if it is zero.
            if (perm[i] == 0)
                AlexanderBogomolyn(perm, N, i);
  
    // Decrement the level 
    // after all possible 
    // permutation after 
    // that level.
    level = level - 1;
      
    perm[k] = 0;
}
  
// Driver Code
public static void main (String[] args)
{
    int i, N = 3;
    int perm[] = new int[N];
    AlexanderBogomolyn(perm, N, 0);
}
}
  
// This code is contributed by anuj_67.

Python3

# Python3 program to implement Alexander 
# Bogomolny’s UnOrdered Permutation Algorithm 
  
# A function to prthe permutation. 
def printn(perm, N):
    for i in range(N):
        print(" ",perm[i], sep = "", end = "")
    print()
      
# A function implementing Alexander Bogomolyn 
# algorithm. 
level = [-1] 
def AlexanderBogomolyn(perm, N, k):
  
    # Assign level to zero at start. 
    level[0] = level[0] + 1
    perm[k] = level[0] 
    if (level[0] == N):
        printn(perm, N) 
    else:
        for i in range(N):
              
            # Assign values to the array 
            # if it is zero. 
            if (perm[i] == 0):
                AlexanderBogomolyn(perm, N, i) 
      
    # Decrement the level after all possible 
    # permutation after that level. 
    level[0] = level[0] - 1
      
    perm[k] = 0
    return
  
# Driver code 
N = 3
perm = [0]*N
AlexanderBogomolyn(perm, N, 0) 
  
# This code is contributed by SHUBHAMSINGH10

C#

// C# program to implement 
// Alexander Bogomolny UnOrdered 
// Permutation Algorithm
using System;
  
class GFG
{
static int level = -1;
  
// A function to print
// the permutation.
static void print(int []perm, 
                  int N)
{
    for (int i = 0; i < N; i++)
        Console.Write(" " + perm[i]);
    Console.WriteLine();
}
  
// A function implementing 
// Alexander Bogomolyn algorithm.
static void AlexanderBogomolyn(int []perm, 
                               int N, int k)
{
  
    // Assign level to 
    // zero at start.
    level = level + 1;
    perm[k] = level;
  
    if (level == N)
        print(perm, N);
    else
        for (int i = 0; i < N; i++)
  
            // Assign values 
            // to the array 
            // if it is zero.
            if (perm[i] == 0)
                AlexanderBogomolyn(perm, N, i);
  
    // Decrement the level 
    // after all possible 
    // permutation after 
    // that level.
    level = level - 1;
      
    perm[k] = 0;
}
  
// Driver Code
public static void Main ()
{
    int N = 3;
    int []perm = new int[N];
    AlexanderBogomolyn(perm, N, 0);
}
}
  
// This code is contributed 
// by anuj_67.

输出：

1 2 3
1 3 2
2 1 3
3 1 2
2 3 1
3 2 1