使用回溯打印没有重复的数组/向量的所有可能排列

给定向量nums ，任务是使用回溯打印给定向量的所有可能排列

例子：

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

方法：任务可以在回溯的帮助下解决。为了更好地理解，这里有一篇类似的文章：打印给定字符串的所有排列

下面是上述代码的实现：

C++

// C++ program for the above approach
#include 
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 >& res,
                  vector 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 > permute(vector& nums)
{
    // Declaring result variable
    vector > 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 nums = { 1, 2, 3 };
    vector > 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

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

输出

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

时间复杂度： O(N*N!) 注意有 N!排列，它需要 O(N) 时间来打印排列。
辅助空间： O(r – l)