Alexander Bogomolny’s UnOrdered Permutation Algorithm

Alexander Bogomolny's algorithm is used to permute first N natural numbers.
Given the value of N, we have to output all the permutations of numbers from 1 to N.
Examples:

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

The idea is to maintain an array to store the current permutation. A static integer level variable is used to define these permutations.

It initializes the value of the current level and permutes the remaining values to higher levels.
As the assigning action of the values reaches the highest level, it prints the permutation obtained.
This approach is recursively implemented to obtain all possible permutations.

C++

// C++ program to implement
// Alexander Bogomolny UnOrdered
// Permutation Algorithm
#include <bits/stdc++.h>
using namespace std;

// A function implementing
// Alexander Bogomolny algorithm.
void solve(vector<int>& v, int n, string& s,
           vector<vector<int> >& vv)
{

    // if all the numbers are added
    // to the vector
    if (v.size() == n) 
    {

        // Append the vector
        // to the answer
        vv.push_back(v);

        return;
    }

    for (int i = 0; i < n; i++) 
    {
      
          // if the number is not taken
        if (s[i] != '1') 
        {
          
            s[i] = '1';
            v.push_back(i + 1);
          
              // Recursive call to the function
            solve(v, n, s, vv);
          
              // Backtrakking step
            s[i] = '0';
            v.pop_back();
        }
    }
}

int main()
{
    int n = 3;
      vector<int> v;
    vector<vector<int>> vv;
    string s;
    for (int i = 0; i < n; i++)
        s += '0';
    solve(v, n, s, vv);
    for (int i = 0; i < vv.size(); i++) 
    {
        for (int j = 0; j < vv[i].size(); j++) 
        {
            cout << vv[i][j] << " ";
        }
        cout << endl;
    }
}

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 Bogomolny 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 print permutation. 
def printn(perm, N):
    for i in range(N):
        print(" ",perm[i], sep = "", end = "")
    print()
    
# A function implementing Alexander Bogomolny 
# 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# 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 Bogomolny 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

<script>

// Javascript program to implement 
// Alexander Bogomolny UnOrdered 
// Permutation Algorithm

let level = -1;
  
// A function to print
// the permutation.
function print(perm, N)
{
    for (let i = 0; i < N; i++)
        document.write(" " + perm[i]);
    document.write("<br/>");
}
  
// A function implementing 
// Alexander Bogomolny algorithm.
function AlexanderBogomolyn(perm, N, k)
{
  
    // Assign level to 
    // zero at start.
    level = level + 1;
    perm[k] = level;
  
    if (level == N)
        print(perm, N);
    else
        for (let i = 0; i < N; i++)
  
            // Assign values 
            // to the array 
            // if it is zero.
            if (perm[i] == 0)
                AlexanderBogomolny(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);
    AlexanderBogomolny(perm, N, 0);
    
</script>

Output

Time Complexity: O(N*N!), where N is the given integer.
Auxiliary Space: O(N*N!), for storing all the permutations of the first N natural numbers.

Alexander Bogomolny’s UnOrdered Permutation Algorithm

Explore