Java 不总是运行的两个嵌套循环的复杂性

我需要写一个复杂程度最低的答案。我的问题是关于不总是运行的嵌套循环。我有一个for循环，它根据字符串的长度迭代N次，并搜索“char”值。当它找到它时，它从这一点开始再次迭代循环，寻找更多的“char”值。 我写了以下方法：

public static int subStrMaxC(String s, char c, int k) {
    char[] stringChars=new char[s.length()];
    //System.out.print("the string of the characters is");
    for(int i=0;i<stringChars.length;i++) {
        stringChars[i]=s.charAt(i);
    //  System.out.print(stringChars[i]);
    }
    int count=0;
    int bigcount=0;
    int[] charArray=new int[s.length()];
    for(int i=0;i<stringChars.length;i++) {
            count=0;
            if(stringChars[i]=='c') {
                count++;
                for(int j=i+1;j<stringChars.length;j++) {
                      if(stringChars[j]=='c') {
                            count++;
                            if((count>=2)&&(count<=k+2)) {
                                bigcount++;
                                if(count==k+2) {
                                    count=0;
                                    j=stringChars.length-1;
                                }
                            }
                      }
                }
            }
    }
    return bigcount;
}

公共静态int subStrMaxC（字符串s、字符c、int k）{
char[]stringChars=新字符[s.length（）]；
//System.out.print（“字符串为”）；
对于（int i=0；i我很肯定这是你能做的最好的了，但我当然可能错了。你的方法的问题是你对空间复杂性的使用有限。使用下面的方法，你只对字符串迭代一次（即没有导致n平方问题的“j”循环）。在这里，您使用空间/内存构建候选子字符串。现在您只需迭代候选子字符串，它的时间复杂度比第一种方法低得多

public class MaxKSubstring {

public static void main(String[] args) {

    String INPUT = "testingwithtees";
    char C = 't';
    int K = 1;

    int count = subStrMaxC(INPUT, C, K);
    System.out.println(count);

}
public static int subStrMaxC(String s, char c, int k) {
    char letters[] = s.toCharArray();
    int valid = 0;
    List<Candidate> candidates = new ArrayList<Candidate>();
    for (int i=0; i< s.length(); i++) {
        if (letters[i] == c)
            candidates.add(new Candidate(k, c));

        for (Candidate candidate : candidates) {
            if (candidate.addLetter(letters[i])) {
                System.out.println(candidate.value);
                valid++;
            }
        }

    }
    return valid;
    }
}

class Candidate {

final int K;
final char C;

public Candidate(int k, char c) {
    super();
    K = k;
    C = c;
}
boolean endsWithC = false;
String value = "";
int kValue = 0;
public boolean addLetter(char letter) {
    endsWithC = false;
    value = value+letter;
    if (letter == C) {
        kValue++;
        endsWithC = true;
    }
    return endsWithC && kValue <= K+2 && value.length() > 1;
}

}

公共类MaxKSubstring{
公共静态void main（字符串[]args）{
字符串输入=“testingwithtees”；
字符C='t'；
int K=1；
int count=subStrMaxC（输入，C，K）；
系统输出打印项次（计数）；
}
公共静态int subStrMaxC（字符串s、字符c、int k）{
字符字母[]=s.toCharArray（）；
int valid=0；
列表候选项=新的ArrayList（）；
对于（int i=0；i
O（n）最佳情况，
O（n2）最坏情况

我不确定你所说的最小复杂性是什么意思。如果你指的是最佳情况，那就是O（n）性能（父循环只迭代，嵌套循环从不迭代），因为匹配的情况：

if(stringChars[i]=='c')

但是，最坏情况下的时间复杂度通常是O（n2），这是因为条件
if（stringChars[i]='c'）
每次都返回
true
。
Big O表示最坏情况，即当这里所有运行的复杂度都是O（N^2），你确定代码是正确的吗？我认为文字“c”应该是c。请解释你的方法应该做什么。当前的复杂性是O（n2），但当你解释你的任务时，我们可能会说你如何达到O（n）复杂性。您好，谢谢所有的评论。我需要接收一个字符串、一个字符C和一个数字K，并找出该字符串中存在多少子字符串，它们是：1.以字符C开头和结尾，2.子字符串中的C字符最大数量为K（不包括第一个和最后一个字符）。我希望这是清楚的。谢谢！您只需要计算字符串中的C数，然后您就可以计算结果值，而无需循环中的循环（我认为计算算法实际上是您的任务）。