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.

Javascript

 
// Javascript program to implement
// Alexander Bogomolny UnOrdered
// Permutation Algorithm
 
let level = -1;
   
// A function to print
// the permutation.
function prlet(perm, N)
{
    for (let i = 0; i < N; i++)
        document.write(" " + perm[i]);
    document.write("<br/>");
}
   
// A function implementing
// Alexander Bogomolyn algorithm.
function AlexanderBogomolyn(perm, N, k)
{
   
    // Assign level to
    // zero at start.
    level = level + 1;
    perm[k] = level;
   
    if (level == N)
        prlet(perm, N);
    else
        for (let 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 program
 
    let i, N = 3;
    let perm = Array.from({length: N}, (_, i) => 0);
    AlexanderBogomolyn(perm, N, 0);
     

输出：

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