Java 难以找到时间复杂度

我刚刚解决了一个关于leetcode的问题，要求我找到一个给定目标的数字总和。我刚刚解决了它，但我很难找到它的时间复杂性。请帮忙

import java.util.*;
class Solution
{
    List<List<Integer>> result=new ArrayList();
    public List<List<Integer>> combinationSum2(int[] candidates, int target)
    {
        HashMap<List<Integer>,Integer> map=new HashMap();
        List<Integer> temp=new ArrayList();
        Arrays.sort(candidates);
        help(candidates,0,target,map,temp);
        return result;
    }
    private void help(int[] arr,int start,int target,HashMap<List<Integer>,Integer> storage,List<Integer> temp)
    {
        if(start>=arr.length)
            return;
        List<Integer> check=new ArrayList<>(temp);
        check.add(arr[start]);
        if(arr[start]==target)
        {

            if(storage.containsKey(check))
            {
                help(arr,start+1,target,storage,temp);
                return;
            }
            else
            {
                temp.add(arr[start]);
                result.add(temp);
                storage.put(temp,1);
                return;
            }
        }
        if(arr[start]>target)
        {
            return;
        }
        help(arr,start+1,target,storage,temp);
        help(arr,start+1,target-arr[start],storage,check);

    }
}

import java.util.*；
类解决方案
{
列表结果=新建ArrayList（）；
公共列表组合SUM2（int[]候选项，int目标）
{
HashMap=newHashMap（）；
List temp=new ArrayList（）；
数组。排序（候选）；
帮助（候选、0、目标、映射、临时）；
返回结果；
}
私有void帮助（int[]arr、int start、int target、HashMap存储、List temp）
{
如果（开始>=arr.length）
回来
列表检查=新阵列列表（临时）；
检查。添加（arr[start]）；
if（arr[start]==目标）
{
if（存储容器（检查））
{
帮助（arr、启动+1、目标、存储、温度）；
回来
}
其他的
{
临时添加（arr[开始]）；
结果。添加（温度）；
储存。放置（温度，1）；
回来
}
}
如果（arr[启动]>目标）
{
回来
}
帮助（arr、启动+1、目标、存储、温度）；
帮助（arr，开始+1，目标arr[start]，存储，检查）；
}
}

您有1个

数组。排序（候选）

通常

O（nlog（n））

。您还有1个递归调用和2个调用，它应该是

O（2^n）

。因此，最坏的情况应该是

O（2^n）

（O1）一个算法被称为运行恒定时间，而不管我们称之为O（1）的输入大小

intgetfirst（int[]arr）{
返回arr[0]；//O（1）
}
Map Map=newhashmap（）{{
put（1,10）；
}};
map.get（1）//O（1）

O（n），如果它运行线性时间。

      int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += n[i];
        }

public int fibo(int n) {
    if (n < 2) return n;
    return fibo(n - 2) + fibo(n - 1);
}

int和=0；
对于（int i=0；i

O（logN）以对数计时运行

像二进制搜索

O（n^2）2循环嵌套。 更多的嵌套迭代将导致O（n^3）O（n^4）

for（int i=0；i

O（2^n）每增加一次输入，它就会增长一倍。

      int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += n[i];
        }

public int fibo(int n) {
    if (n < 2) return n;
    return fibo(n - 2) + fibo(n - 1);
}

public int fibo（int n）{
如果（n<2）返回n；
返回fibo（n-2）+fibo（n-1）；
}

我没有详细介绍代码中的提前终止，以及它们发生的频率。但是，使用

n-1

元素的双重递归调用是

O（2^n）

的“签名”。感谢您的帮助。我也有同样的想法，但仍然不确定我的答案：）