Print all possible permutations of an Array/Vector without duplicates using Backtracking

Given vector nums, the task is to print all the possible permutations of the given vector using backtracking 

Examples:

Input: nums[] = {1, 2, 3}
Output: {1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 2, 1}, {3, 1, 2}
Explanation: There are 6 possible permutations

Input: nums[] = {1, 3}
Output: {1, 3}, {3, 1}
Explanation: There are 2 possible permutations

Approach: The task can be solved with the help of backtracking. A similar article for better understanding is here: Print all permutations of a given string

Below is the implementation of the above code:

C++

// 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

// 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

Python3

# 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

C#

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();
        }
    }
}

Javascript

<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>

Output

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

Time Complexity: O(N*N!) Note that there are N! permutations and it requires O(N) time to print a permutation.
Auxiliary Space: O(r – l)