What is a Permutation Array in DSA?

A permutation array, often called a permutation or permuted array, is an arrangement of elements from a source array in a specific order different from their original placement.

The critical characteristic of a permutation array is that it contains all the elements from the source array but in a different order.

Imagine you have an array of elements, such as [1, 2, 3]. A permutation of this array, like [3, 1, 2], represents a different order of the original elements.

How to Create a Permutation Array

Creating a permutation array involves rearranging the elements of a source array in a different order. Various methods and algorithms can be used to generate permutations, including recursive algorithms, iterative approaches, and mathematical techniques like the Lehmer code.

Here, we'll look at a simple example of how to create a permutation of a one-dimensional array using recursive approach.

Below is the implementation of the above idea:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function for swapping two numbers
void swap(int& x, int& y)
{
    int temp = x;
    x = y;
    y = temp;
}

// Function to find the possible
// permutations
void permutations(vector<vector<int> >& res,
                vector<int> nums, int l, int h)
{
    // Base case
    // Add the vector to result and return
    if (l == h) {
        res.push_back(nums);
        return;
    }

    // Permutations made
    for (int i = l; i <= h; i++) {

        // Swapping
        swap(nums[l], nums[i]);

        // Calling permutations for
        // next greater value of l
        permutations(res, nums, l + 1, h);

        // Backtracking
        swap(nums[l], nums[i]);
    }
}

// Function to get the permutations
vector<vector<int> > permute(vector<int>& nums)
{
    // Declaring result variable
    vector<vector<int> > res;
    int x = nums.size() - 1;

    // Calling permutations for the first
    // time by passing l
    // as 0 and h = nums.size()-1
    permutations(res, nums, 0, x);
    return res;
}

// Driver Code
int main()
{
    vector<int> nums = { 1, 2, 3 };
    vector<vector<int> > res = permute(nums);

    // printing result
    for (auto x : res) {
        for (auto y : x) {
            cout << y << " ";
        }
        cout << endl;
    }

    return 0;
}

// Java program for the above approach

import java.util.ArrayList;
import java.util.Arrays;

public class GFG 
{
    // Function for swapping two numbers
    static void swap(int nums[], int l, int i)
    {
        int temp = nums[l];
        nums[l] = nums[i];
        nums[i] = temp;
    }

    // Function to find the possible
    // permutations
    static void permutations(ArrayList<int[]> res,
                            int[] nums, int l, int h)
    {
        // Base case
        // Add the array to result and return
        if (l == h) {
            res.add(Arrays.copyOf(nums, nums.length));
            return;
        }

        // Permutations made
        for (int i = l; i <= h; i++) {
            // Swapping
            swap(nums, l, i);

            // Calling permutations for
            // next greater value of l
            permutations(res, nums, l + 1, h);

            // Backtracking
            swap(nums, l, i);
        }
    }

    // Function to get the permutations
    static ArrayList<int[]> permute(int[] nums)
    {
        // Declaring result variable
        ArrayList<int[]> res = new ArrayList<int[]>();
        int x = nums.length - 1;

        // Calling permutations for the first
        // time by passing l
        // as 0 and h = nums.size()-1
        permutations(res, nums, 0, x);
        return res;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int[] nums = { 1, 2, 3 };
        ArrayList<int[]> res = permute(nums);

        // printing result
        for (int[] x : res) {
            for (int y : x) {
                System.out.print(y + " ");
            }
            System.out.println();
        }
    }
}

// This code is contributed by jainlovely450

# Python program for the above approach 

# Function to find the possible
# permutations
def permutations(res, nums, l, h) :
    
    # Base case
    # Add the vector to result and return
    if (l == h) :
        res.append(nums);
        for i in range(len(nums)):
            print(nums[i], end=' ');

        print('')
        return;

    # Permutations made
    for i in range(l, h + 1):
        
        # Swapping
        temp = nums[l];
        nums[l] = nums[i];
        nums[i] = temp;

        # Calling permutations for
        # next greater value of l
        permutations(res, nums, l + 1, h);

        # Backtracking
        temp = nums[l];
        nums[l] = nums[i];
        nums[i] = temp;

# Function to get the permutations
def permute(nums):
    
    # Declaring result variable
    x = len(nums) - 1;
    res = [];
    
    # Calling permutations for the first
    # time by passing l
    # as 0 and h = nums.size()-1
    permutations(res, nums, 0, x);
    return res;

# Driver Code
nums = [ 1, 2, 3 ];
res = permute(nums);

# This code is contributed by Saurabh Jaiswal

using System;
using System.Collections.Generic;

class GFG
{
    // Function for swapping two numbers
    static void swap(int[] nums, int l, int i)
    {
        int temp = nums[l];
        nums[l] = nums[i];
        nums[i] = temp;
    }

    // Function to find the possible permutations
    static void permutations(List<int[]> res, int[] nums, int l, int h)
    {
        // Base case: Add the array to result and return
        if (l == h)
        {
            res.Add((int[])nums.Clone());
            return;
        }

        // Permutations made
        for (int i = l; i <= h; i++)
        {
            // Swapping
            swap(nums, l, i);

            // Calling permutations for next greater value of l
            permutations(res, nums, l + 1, h);

            // Backtracking
            swap(nums, l, i);
        }
    }

    // Function to get the permutations
    static List<int[]> permute(int[] nums)
    {
        // Declaring result variable
        List<int[]> res = new List<int[]>();
        int x = nums.Length - 1;

        // Calling permutations for the first time by passing l as 0 and h = nums.size()-1
        permutations(res, nums, 0, x);
        return res;
    }

    // Driver Code
    static void Main(string[] args)
    {
        int[] nums = { 1, 2, 3 };
        List<int[]> res = permute(nums);

        // printing result
        foreach (int[] x in res)
        {
            foreach (int y in x)
            {
                Console.Write(y + " ");
            }
            Console.WriteLine();
        }
    }
}

<script>

// JavaScript program for the above approach 

// Function to find the possible
// permutations
function permutations(res, nums, l, h) 
{
    
    // Base case
    // Add the vector to result and return
    if (l == h) 
    {
        res.push(nums);
        for(let i = 0; i < nums.length; i++)
            document.write(nums[i] + ' ');

        document.write('<br>')
        return;
    }

    // Permutations made
    for(let i = l; i <= h; i++) 
    {
        
        // Swapping
        let temp = nums[l];
        nums[l] = nums[i];
        nums[i] = temp;

        // Calling permutations for
        // next greater value of l
        permutations(res, nums, l + 1, h);

        // Backtracking
        temp = nums[l];
        nums[l] = nums[i];
        nums[i] = temp;
    }
}

// Function to get the permutations
function permute(nums)
{
    
    // Declaring result variable
    let x = nums.length - 1;
    let res = [];
    
    // Calling permutations for the first
    // time by passing l
    // as 0 and h = nums.size()-1
    permutations(res, nums, 0, x);
    return res;
}

// Driver Code
let nums = [ 1, 2, 3 ];
let res = permute(nums);

// This code is contributed by Potta Lokesh

</script>

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

Problems Based on Permutation Arrays

These problems involve various operations and applications related to permutation arrays, ranging from basic tasks like finding permutations to more complex operations such as inverting permutations or sorting using a permutation array.

Uses of Permutation Arrays

Permutation arrays find applications in a wide range of fields, including:

• Cryptography: permutations are used to create secure keys, encrypt data, and ensure the confidentiality and integrity of information.
• Game Development: Permutations are used in game development to randomize game elements, create random mazes, and introduce unpredictability to gameplay.
• Statistics and Sampling: permutation tests are employed to assess the significance of observed data and draw meaningful conclusions.
• Data Compression: Permutations play a role in data compression algorithms, helping reduce data size without significant loss of information.

Conclusion

Permutation arrays are a fundamental concept with a multitude of applications. Whether you're exploring combinatorial problems, securing data, or adding randomness to your projects, understanding permutations and their uses is essential in various domains of computer science and mathematics. Permutations provide the tools to rearrange and manipulate elements, offering creative solutions to an array of challenges.