Open In App

Print All Permutations of an Array

Improve
Improve
Like Article
Like
Save
Share
Report

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)



Last Updated : 03 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads