递归回溯：实现全排列的一个算法题

问题：
输入一个整数，例如165，数字打乱之后，重新排序，可以组成： 156,651,615，561,516 等5种情况，要求，找到比它本身小的，最大的一个
例如比165小的，最大的是156，
如果输入 156，没有比其更小的，返回 -1

import java.util.*;

public class shoppe2 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String nStr = scan.nextLine();
        int n = Integer.parseInt(nStr);
        // 首先把这个 int  变成一个数组，
        int[] nums = new int[nStr.length()];

        for(int i=0;i<nums.length;i++){
            nums[i] = Integer.parseInt(nStr.charAt(i)+"");
        }
        // 然后得到所有组合情况
        List<List<Integer>>  resAll =  permute(nums);
        // 遍历组合情况 得到数字
        ArrayList<Integer> arrayList = new ArrayList<>();
        for(List<Integer> list1 : resAll){
            StringBuffer sb = new StringBuffer();
            for(int i=0;i<list1.size();i++){
                sb.append(list1.get(i));
            }
            arrayList.add(Integer.parseInt(sb.toString()));
        }
        // 对结果进行排序  拿到最大的那个
        Collections.sort(arrayList);
        for(int i=0;i<arrayList.size();i++){
            if(arrayList.get(i)>=n){
                if(i>0){
                    System.out.println("最终答案是 ： "+arrayList.get(i-1));
                    break;
                }else{
                    System.out.println("已经是最小的了");
                    break;
                }
            }
        }
    }
    
    public static  List<List<Integer>> permute (int[] nums ){
        int len = nums.length;
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(len==0){
            return res;
        }
        Deque<Integer> path = new ArrayDeque<Integer>();
        boolean[] used = new  boolean[len];
        dfs(nums,len,0,path,used,res );
        return  res;
    }
    private static  void dfs(int[] nums,int len,int depth,Deque<Integer> path ,boolean[] used ,List<List<Integer>> res ){
        if(depth==len){
            res.add(new ArrayList<>(path)); // 这里需要来一个深拷贝，否则添加的只是一个引用
            // 添加进去之后，还会被改变
        }
        for(int i=0;i<len;i++){
            if(used[i]){
                continue;
            }
            path.addLast(nums[i]);
            used[i] = true;
            dfs(nums,len,depth+1,path,used,res );
            // 进行回溯
            path.removeLast();
            used[i] = false;
        }
    }
}