全排列问题是一个非常经典的问题，在 LeetCode 上也有很多相关的题目。解决全排列问题的方法有很多种，下面将介绍两种常用的方法：回溯法和交换法。

回溯法

回溯法是解决全排列问题最常见的方法之一。回溯法采用递归的方式来生成所有可能的排列。

1. 定义一个递归函数 permute，该函数用于生成全排列。
2. 在 permute 函数中，首先判断当前排列的长度是否等于输入数组的长度，如果等于则将当前排列加入结果集中。
3. 如果当前排列长度不等于输入数组长度，则遍历输入数组中的每个元素，将元素添加到当前排列中。
4. 递归调用 permute 函数，继续生成下一个元素添加到当前排列中。
5. 在递归调用之后，将添加的元素移除，恢复当前排列的状态。

下面是使用回溯法解决全排列问题的代码示例：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List> permute(int[] nums) {
        List> res = new ArrayList<>();
        List perm = new ArrayList<>();
        boolean[] visited = new boolean[nums.length];
        backtrack(nums, res, perm, visited);
        return res;
    }
    
    private void backtrack(int[] nums, List> res, List perm, boolean[] visited) {
        if (perm.size() == nums.length) {
            res.add(new ArrayList<>(perm));
            return;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (visited[i]) {
                continue;
            }
            perm.add(nums[i]);
            visited[i] = true;
            backtrack(nums, res, perm, visited);
            visited[i] = false;
            perm.remove(perm.size() - 1);
        }
    }
}
Java

交换法

交换法是另一种解决全排列问题的常见方法。该方法通过交换数组中的元素来生成所有可能的排列。

1. 定义一个递归函数 permute，该函数用于生成全排列。
2. 在 permute 函数中，首先判断当前排列的长度是否等于输入数组的长度，如果等于则将当前排列加入结果集中。
3. 如果当前排列长度不等于输入数组长度，则遍历当前排列长度到输入数组长度的每个元素，将其与当前排列中当前位置的元素交换。
4. 递归调用 permute 函数，生成下一个位置的排列。
5. 在递归调用之后，将交换过的元素恢复到原来的位置。

下面是使用交换法解决全排列问题的代码示例：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List> permute(int[] nums) {
        List> res = new ArrayList<>();
        backtrack(nums, 0, res);
        return res;
    }
    
    private void backtrack(int[] nums, int start, List> res) {
        if (start == nums.length) {
            List perm = new ArrayList<>();
            for (int num : nums) {
                perm.add(num);
            }
            res.add(perm);
            return;
        }
        
        for (int i = start; i < nums.length; i++) {
            swap(nums, start, i);
            backtrack(nums, start + 1, res);
            swap(nums, start, i);
        }
    }
    
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}
Java

使用回溯法和交换法都可以解决全排列问题，它们的思路略有不同，但是都能够生成所有可能的排列。在实际应用中，可以根据具体情况选择合适的方法来解决全排列问题。希望以上的解答对您有帮助！