Algorithm 循环中递归函数的大O复杂度

我遇到了一个Leetcode问题的解决方案，即寻找越来越多的子序列。我认为该解决方案的复杂性为O（N！），可能无法扩展到大型阵列

你能详细说明一下你是如何计算这个问题的复杂性的吗

public class IncreasingSubsequences {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = new int[]{4, 6, 7, 8};
        findSubsequences(a);
    }

    public static List<List<Integer>> findSubsequences(int[] nums) {
        List<List<Integer>> res = new LinkedList<>();
        helper(new LinkedList<Integer>(), 0, nums, res);
        return res;
    }

    // [4, 6, 7, 7]
    private static void helper(LinkedList<Integer> list, int index, int[] nums, List<List<Integer>> res) {

        if (list.size() > 1){
            res.add(new LinkedList<Integer>(list));
            System.out.println(Arrays.toString(list.toArray()));
        }

        Set<Integer> used = new HashSet<>();

        for (int i = index; i < nums.length; i++) {
            if (used.contains(nums[i]))
                continue;
            if (list.size() == 0 || nums[i] >= list.peekLast()) {
                used.add(nums[i]);
                list.add(nums[i]);
                helper(list, i + 1, nums, res);
                System.out.println("Will remove" + list.get(list.size() - 1));
                list.remove(list.size() - 1);
                //System.out.println(">>" + Arrays.toString(list.toArray()));
            }
        }
    }

}

公共类递增子序列{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int[]a=新的int[]{4,6,7,8}；
发现子序列（a）；
}
公共静态列表查找子序列（int[]nums）{
List res=new LinkedList（）；
助手（新的LinkedList（），0，nums，res）；
返回res；
}
// [4, 6, 7, 7]
私有静态void帮助器（LinkedList列表、int索引、int[]nums、list res）{
如果（list.size（）>1）{
res.add（新链接列表（列表））；
System.out.println（Arrays.toString（list.toArray（））；
}
Set used=新的HashSet（）；
for（int i=索引；i=list.peekLast（））{
添加（nums[i]）；
增加（nums[i]）；
助手（列表，i+1，nums，res）；
System.out.println（“将删除”+list.get（list.size（）-1））；
list.remove（list.size（）-1）；
//System.out.println（“>>”+Arrays.toString（list.toArray（））；
}
}
}
}

正如您所怀疑的，时间和内存的复杂性几乎是O（N！）。更准确地说，附加内存是O（N*2N），时间是O（M*2N）。其中M是

nums

的长度，原始列表，N是其中唯一值的数量（s.t.N时间和内存复杂性几乎是O（N！），正如您所怀疑的。更准确地说，额外内存是O（N*2N），时间是O（M*2N）其中M是

nums

的长度，是原始列表，N是其中唯一值的数量（s.t.N