计算时间复杂度（大o的渐进表示法）

1.大o的渐进表示法使用原则

①用常数1取代运行时间中的所有加法常数

②在修改后的运行次数函数中，只保留最高阶

③如果最高阶项存在且不是1，则去除与这个项目相乘的常数。

2.常见时间复杂度计算举例

①                              

 void func1(int N){
       int count=0;
       for (int i=0;i<N;i++){
           for (int j=0;j<N;j++){
               count++;
           }
           int M=10;
           while((M--)>0){
               count++;
           }
           System.out.println(count);
       }
    }

F(N)=+2*N+10  ------>  使用大O的渐进表示法得时间复杂度为O()

②

void func2(int N) {
        int count = 0;
        for (int k = 0; k < 2 * N; k++) {
            count++;
        }
        int M=10;
        while((M--)>0){
            count++;
        }
        System.out.println(count);
    }

F(N)=2*N+10  ------>  使用大O的渐进表示法得时间复杂度为O(N)

③

void func3(int N,int M) {
        int count = 0;
        for (int k = 0; k <M; k++) {
            count++;
        }
        for (int k = 0; k < N; k++) {
            count++;
        }
        System.out.println(count);
    }

F(N)=M+N  ------>  使用大O的渐进表示法得时间复杂度为O(M+N)

④

 void func4(int N) {
        int count = 0;
        for (int k = 0; k < 100; k++) {
            count++;
        }
        System.out.println(count);
    }

F(N)=100 ------>  使用大O的渐进表示法得时间复杂度为O(1)

⑤

 void bubblesort(int[] array){
        for (int end=array.length;end>0;end--){
            boolean sorted=true;
            for (int i=1;i<end;i++){
                if (array[i-1]>array[i]) {
                    swap(array, i - 1, i);
                    sorted = false;
                }
            }
            if (sorted==true){
                break;
            }
        }

         F(N)     =（N-1）+（N-2）+...+2+1      =    （（N-1）+1）*（N1）/2       =       (-N)/2                  ------>  使用大O的渐进表示法得时间复杂度为O()

⑥

int binarySearch(int[] array,int value){
        int begin=0;
        int end=array.length-1;
        while(begin<=end){
            int mid=begin+((end-begin)/2);
            if (array[mid]<value){
                begin=mid+1;
            }else if (array[mid]>value){
                end=mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }

N/ ------> x= 使用大O的渐进表示法得时间复杂度为O()

⑦

long factorial(int N){
        return N<2?N:factorial(N-1)*N;
    }

递归的时间复杂度=递归的次数*每次递归执行的次数=（N-1）*1=N-1

 ------>  使用大O的渐进表示法得时间复杂度为O(N)

⑧

 int fibonacci(int N){
        return N<2?N:fibonacci(N-1)+fibonacci(N-2);
    }

2^0+2^1+2*2+……+2^(N-2)+2^(N-1)=-1

------>  使用大O的渐进表示法得时间复杂度为O()