Java 计算递归算法的最佳运行时复杂度？

在课堂上，我开始学习如何计算各种算法的运行时复杂度函数，我发现这很困难。我试图计算下面递归算法的最佳情况下符文时间复杂度

现在，我选择我的基本运算作为两个字符索引之间的比较，并且假设我试图尽快找到算法输出结果的路径，我认为如果第一次比较是错误的，那么如果我是正确的，我的算法就会这样做

我认为该算法的最佳运行时复杂度函数为t（n）=1，并将索引比较作为基本操作，这是否正确

public class StringShuffleTest {

    public static boolean isOrderedShuffle(String a, String b, String c){

        //variables for the size of Strings a, b and c.
        int n = a.length();
        int m = b.length();
        int len = c.length();     

        //if the length of c is not the length of a + b, return false.
        if (len != (n + m)){
            return false;
        }

        //if String c contains String b as a substring, then remove String b from c and make m = 0.
        //This statement avoids errors when dealing with Strings with very similar characters.
        if (c.contains(b)){
            c = c.replace(b, "");
            m = 0;
        }

        //if the length of a or b is 0, and c equals a or b, return true, otherwise,
        //return false.
        if (n == 0 || m == 0){
            if (c.equals(a) || c.equals(b)){
                return true;
            }
            else
                return false;
        }

        //if String a has length 1, remove a from String c and make String a empty.
        if (n == 1){
                c = c.substring(0, c.indexOf(a.charAt(0))) + c.substring(c.indexOf(a.charAt(0)) +1);
                a = "";
                return isOrderedShuffle(a, b, c);

            }

        //An ordered shuffle of two given strings, a and b, is a string that can be formed by interspersing
        //the characters of a and b in a way that maintains the left-to-right order of the characters from each
        //string.

        //Recursive algorithm to determine if String c is an ordered shuffle of a and b.
        else
        if (c.indexOf(a.charAt(0)) >= 0){

            int indexOfFirsta = c.indexOf(a.charAt(0));
            int indexOfSeconda = c.indexOf(a.charAt(1));

            if (indexOfFirsta <= indexOfSeconda){//Taking as fund operation.
            c = c.substring(0, indexOfFirsta) + c.substring(indexOfFirsta +1);
            a = a.substring(1, n);
                System.out.println(a);
                System.out.println(c);                   
            return isOrderedShuffle(a, b, c);
            }

        else
            if (c.indexOf(b.charAt(0)) >= 0){
                    int indexOfFirstb = c.indexOf(b.charAt(0));
                    int indexOfSecondb = c.indexOf(b.charAt(1));

                    if (indexOfFirstb <= indexOfSecondb){
                        c = c.substring(0, indexOfFirstb) + c.substring(indexOfFirstb +1);
                        b = b.substring(1, m);
                        System.out.println(b);
                        System.out.println(c);

                    return isOrderedShuffle(a, b, c);

                }
        }

        }
    return false;         
    }       

public static void main(String[] args) {

    System.out.println(StringShuffleTest.isOrderedShuffle("abc", "def", "abedcf")); 

}

}

公共类StringShuffleTest{
公共静态布尔isOrderedShuffle（字符串a、字符串b、字符串c）{
//字符串a、b和c的大小变量。
int n=a.长度（）；
int m=b.长度（）；
int len=c.长度（）；
//如果c的长度不是a+b的长度，则返回false。
如果（len！=（n+m））{
返回false；
}
//如果字符串c包含字符串b作为子字符串，则从c中删除字符串b并使m=0。
//此语句可避免在处理字符非常相似的字符串时出错。
如果（c）包含（b））{
c=c。替换（b，“”；
m=0；
}
//如果a或b的长度为0，且c等于a或b，则返回true，否则，
//返回false。
如果（n==0 | | m==0）{
如果（c等于（a）| | c等于（b））{
返回true；
}
其他的
返回false；
}
//如果字符串a的长度为1，则从字符串c中删除a并使字符串a为空。
如果（n==1）{
c=c子串（0，c.indexOf（a.charAt（0））+c子串（c.indexOf（a.charAt（0））+1；
a=“”；
返回按顺序无序排列（a、b、c）；
}
//两个给定字符串a和b的有序混洗是一个可以通过穿插形成的字符串
//a和b中的字符保持从左到右的顺序
//绳子。
//确定字符串c是否是a和b的有序混洗的递归算法。
其他的
如果（c.indexOf（a.charAt（0））>=0）{
int indexOfFirsta=c.indexOf（a.charAt（0））；
int indexOfSeconda=c.indexOf（a.charAt（1））；
如果（indexOfFirsta=0）{
int indexOfFirstb=c.indexOf（b.charAt（0））；
int indexOfSecondb=c.indexOf（b.charAt（1））；
if（indexOfFirstb Yes，此算法的最佳情况时间为O（1），因为它可以用两个有界长度的字符串（例如长度为0的字符串和长度为1的字符串）调用，并且第一次测试可能失败。（对于任意长度的字符串，它是否仍然是最佳情况O（1）取决于Java中如何实现字符串--if
length（）
必须遍历所有字符以“测量”长度，那么它的最佳大小写复杂度不能超过O（n）。）通常最坏情况下的时间更有趣/重要，不过！@j_random_hacker非常感谢您的评论，这非常有用！那么我认为该算法最坏情况下的运行时复杂性是t（n）是正确的吗=2N？因为我认为每个if语句的时间是恒定的，并且要遍历长度为N的每个字符，每次必须执行两个if语句。我感到困惑。像
if（c.contains（b））
这样的语句必须至少花费O（N）时间，即使是最快的字符串比较算法（比如Knuth-Morris-Pratt）使用，如果使用简单的比较（许多编程语言标准库仍然以这种方式实现
contains（）
），则可能与O（n^2）一样糟糕。因此，“将每个if语句都视为常量时间”对我来说没有意义。是的，此算法的最佳情况时间是O（1），因为它可以用两个有界长度的字符串（例如，长度为0的字符串和长度为1的字符串）调用，而第一个测试可能会失败。（对于任意长度的字符串，它是否仍然是最佳情况O（1）取决于Java中如何实现字符串--if
length（）
必须迭代所有字符以“测量”最坏情况下的时间长度不能比O（n）更好。通常最坏情况下的时间更有趣/重要，不过！@j_random_hacker非常感谢你的评论，这非常有用！那么我认为该算法最坏情况下的运行时复杂度是t（n）是正确的吗=2N？因为我认为每个if语句的时间是恒定的，并且要遍历长度为N的每个字符，每次必须执行两个if语句。我感到困惑。像
if（c.contains（b））
这样的语句必须至少花费O（N）时间，即使是最快的字符串比较算法（比如Knuth-Morris-Pratt）使用，如果使用简单的比较（许多编程语言标准库仍然以这种方式实现
contains（）
），则可能与O（n^2）一样糟糕。因此，“将每个if语句都当作常量时间”对我来说没有意义。