输出元素组成数组的排列组合形式

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型vector 
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > exportAllOrders(vector<int>& array) {
        // write code here
        vector<vector<int> > res;
        if (array.size() == 0) return res;
        sort(array.begin(), array.end());
        do {
            res.push_back(array);
        } while (next_permutation(array.begin(), array.end()));
        return res;
    }
};

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型二维数组
     */
    public int[][] exportAllOrders(int[] array) {
        List<List<Integer>> list = permute(array);
        int[][] arr = new int[list.size()][array.length];
         for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < array.length; j++) {
                arr[i][j] = list.get(i).get(j);
            }
        }
        return arr;
    }


    public List<List<Integer>> permute(int[] nums) {
        int len = nums.length;
        List<List<Integer>> list = new ArrayList<>();
        if (len == 0) return list;
        boolean[] used = new boolean[len];
        List<Integer> path = new ArrayList<>();
        dfs(nums, len, 0, path, used, list);
        return list;
    }

    private void dfs(int[] nums, int len, int depth, List<Integer> path, boolean[] used, List<List<Integer>> res) {
        if (depth == len) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < len; i++) {
            if (!used[i]) {
                path.add(nums[i]);
                used[i] = true;
                dfs(nums, len, depth + 1, path, used, res);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型二维数组
     */
    public int[][] exportAllOrders (int[] array) {
        // write code here
        int n = array.length;
        int l = getLength(n);
        int[][] res = new int[l][n];
        Arrays.sort(array);
        List<Integer> ls = new ArrayList<>();
        List<List<Integer>> list = new ArrayList<>();
        Set<Integer> set = new HashSet<>();
        back(array,0,ls,list,set);
        for(int i=0;i<list.size();i++){
            List<Integer> temp = list.get(i);
            for(int j=0;j<temp.size();j++){
                res[i][j] = temp.get(j);
            }
        }
        return res;
    }
    public void back(int[] array, int start, List<Integer> ls, List<List<Integer>> list, Set<Integer> set){
        if(ls.size()==array.length){
            list.add(new ArrayList<>(ls));
            return;
        }
        for(int i=0;i<array.length;i++){
            if(!set.contains(i)){
                set.add(i);
                ls.add(array[i]);
                back(array,start+1,ls,list,set);
                set.remove(i);
                ls.remove(ls.size()-1);
            }else{
                continue;
            }
        }
    }
    public int getLength(int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }else{
            return n*getLength(n-1);
        }
        
    }
}