Java 我有一个基本的想法

我正在考虑计算以下代码的时间复杂度。代码所做的是一个递归调用来求解，它试图执行

清空

操作，直到所有石头都在一个杯子中

到目前为止，我得到的是递归调用从limit调用

solve

，直到limit现在为1。所以O很大（极限，极限-1，极限-2一直到极限=1）

这个递归函数是O（n）吗

public void solve（Cups、整数限制、布尔调试）{
字符串prevState=cups.toString（）；
对于（int i=0；i“+emptyCups）；
}
如果（emptyCups.size（）==1）{//基本大小写
StringBuilder解决方案=新建StringBuilder（“移动：+emptyCups.moveList”）；
解决方案。附加（“杯子：”）；
对于（int j=0；j1）{
解决（清空UPS，限制-1，调试）；

我假设，不管你有多少个杯子，大小都是一个常数

该代码将是（O（n）），n是limit的值。这是因为此方法运行一次额外的时间，每次增加1。如果limit高，与低时相比，我在方法中看不到工作量的增加。每次调用该方法时都需要做很多事情，但因为它是有限的每一次的“东西”，它并不影响复杂性

public void solve(Cups cups, int limit, boolean debug){
        String prevState = cups.toString();
        for(int i = 0; i < cups.size(); i++){ //for every cup
          Cups emptyCups = cups.empty(i); //make a new instance and empty the contents of cup
          emptyCups.stateList.addAll(cups.stateList);
          emptyCups.stateList.add(prevState); //add previous state to stateList arraylist
          emptyCups.moveList.addAll(cups.moveList); //add all moves to arraylist
          emptyCups.moveList.add(i); //add i position to move list
          if(debug = true){
            System.err.println(prevState + " empty-cup:"+ i +
                               ", limit:" + limit + " => " + emptyCups);
          }
          if(emptyCups.size() == 1){ //base case
            StringBuilder solution = new StringBuilder("moves:" + emptyCups.moveList);
            solution.append(" cups:");
            for(int j = 0; j < emptyCups.stateList.size(); j++){
              solution.append(emptyCups.stateList.get(j) + " ");
            }
            solution.append(emptyCups.toString());
            System.out.println(solution);
            unsolvable = false;
          } else if(limit > 1){
            solve(emptyCups, limit - 1, debug);