Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Medium
  • Last Updated : 08 Dec, 2021

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

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

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)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!