if语句的Big-O表示法？

Question

I was wondering what the Big O notation for this would be. I know the for loop is O(n). I wasn't sure if the if statements were O(n log n). If so, doesn't that make the run time complexity (n)*((n log n)^3). Or would it be ((n^2)(log^3n)) ? Also I know storage in an array is O(n) and was wondering if calling elements in a the same array is O(n) or had a different run tim complexity. (Written in Java eclipse)

    for (i=0;i<numberOfProblems;i++){                       
    String string1= ap.nextString("P or NP?");
    if(string1=P){
        pOrNPValue[i]=0;
    }else{
        pOrNPValue[i]=1;


        String string2 = ap.nextString("Best Case Run Time?");

        if(string2==ok){
            bestCaseValue[i]=0;
        }else if(string2=oLogLogN){
            bestCaseValue[i]=1;
        } else if(string2=oLogN){
            bestCaseValue[i]=2;
        }else if(string2=oNC){
            bestCaseValue[i]=3;
        }else if(string2=oN){
            bestCaseValue[i]=4;
        }else if(string2=oNLogStarN){
            bestCaseValue[i]=5;
        }else if(string2=oNLogN){
            bestCaseValue[i]=6;
        }else if(string2=oNK){
            bestCaseValue[i]=7;
        }else if(string2=oCN){
            bestCaseValue[i]=8;
        }else if(string2=oNFactorial){
            bestCaseValue[i]=9;
        }

        String string3 = ap.nextString("Average Case Run Time?");

        if(string3=ok){
            averageCaseValue[i]=0;
        }else if(string3=oLogLogN){
            averageCaseValue[i]=1;
        } else if(string3=oLogN){
            averageCaseValue[i]=2;
        }else if(string3=oNC){
            averageCaseValue[i]=3;
        }else if(string3=oN){
            averageCaseValue[i]=4;
        }else if(string3=oNLogStarN){
            averageCaseValue[i]=5;
        }else if(string3=oLogLogN){
            averageCaseValue[i]=6;
        }else if(string3=oNK){
            averageCaseValue[i]=7;
        }else if(string3=oCN){
            averageCaseValue[i]=8;
        }else if(string3=oNFactorial){
            averageCaseValue[i]=9;
        }

        String string4 = ap.nextString("Worst Case Run Time?");

        if(string4=ok){
            worstCaseValue[i]=0;
        }else if(string4=oLogLogN){
            worstCaseValue[i]=1;
        } else if(string4=oLogN){
            worstCaseValue[i]=2;
        }else if(string4=oNC){
            worstCaseValue[i]=3;
        }else if(string4=oN){
            worstCaseValue[i]=4;
        }else if(string3=oNLogStarN){
            worstCaseValue[i]=5;
        }else if(string4=oLogLogN){
            worstCaseValue[i]=6;
        }else if(string4=oNK){
            worstCaseValue[i]=7;
        }else if(string4=oCN){
            worstCaseValue[i]=8;
        }else if(string4=oNFactorial){
            worstCaseValue[i]=9;

Answer 1

String comparisons take time proportional to the length of the longer of the two strings (you only need to compare characters up to that point in the worst-case). Since all of the string comparisons that are being made here are against constant strings, each comparison individually takes time O(1). Since there's only a fixed number of comparisons, each of which does O(1) work if true (array accesses take time O(1) regardless of the index), the total time required for all the comparisons is O(1) per iteration. Thus the total amount of work done is O(n): there are O(n) loop iterations, and each of them does O(1) work.

(Technically speaking, you need to account for the work done reading characters from the user, which could be unbounded because the user could just hold down a key indefinitely. I'll ignore that for now by assuming there's a fixed limit to the total number of characters the user can type at each prompt.)

In general, comparisons themselves take O(1) time and the real question is how much work is required to evaluate the boolean expression.

Hope this helps!