时间和空间复杂度分析

上期回顾

this

this：表示当前对象的引用this 关键字能否出现在静态方法中？

一定存在对象才有this，静态方法根本就不存在对象，何来当前对象之说

代码块

当类中存在静态变量，静态代码块[1…N]

则在类加载时，这些静态变量的赋值以及静态代码块，最终都会合并为一个大的静态代码块，由JVM执行。

---

时间和空间复杂度分析

1. 算法效率

算法效率分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，空间效率被称作空间复杂度。时间复杂度主要衡量的是一个算法的运行速度，空间复杂度主要衡量一个算法所需要的额外空间，一般来说，行数越多(循环和递归)，时间越长。

一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

void func1(int N){
    int count = 0;
    for(int i = 0; i < N ; i++){
        for(int j = 0; j < N; j++){			//N^2
            count++;
        }
    }
    for(int k = 0; k < 2 * N ; k++){        //2N
        count++;
    }
    int M = 10;
    while((M--) > 0) {						//10
        count++;
    }
}

$$func1执行的基本操作次数：F(N)=N^2+2N+10$$

2. 大O渐进表示法

O() -> 是一个函数渐进的数学符号

大O阶函数的推导原则：

1. 用常数1来表示所有的加法常数 10, 2 => 1
2. 最后的大O函数只保留最高阶想，只保留N²
3. 若最高阶项还有系数， 3N², 4N², 去除这个系数，保留1即可 -> N²

只要代码的执行 行数 不是个变量，100行，1000行，10000行，我们都认为这是O(1) ==>常数时间内的算法

3. 算法运行时间

最坏的时间复杂度 任意输入规模的最大运行次数(上界)

最好情况的时间复杂度 任意输入规模的最小运行次数(下界)

平均情况的时间复杂度 任意输入规模的期望运行次数

最坏的情况：O(n)

最好的情况：O(1)

平均情况：所有情况/情况的个数

1+2+3+…+n = (n+1)*n/2 = > 所有情况 除以情况个数n => (n+1)/2 => 只保留最高阶 => n/2

情况的个数n n/2 ， 去除系数==>O(n)

时间复杂度

例题

计算func3的时间复杂度

//计算func3的时间复杂度
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);
}//此时M和N都是变量，无法确定谁大谁小，时间复杂度就是O(M+N)

计算func4的时间复杂度

void func4(int N) {
    int count = 0;
    for (int k = 0; k < 100; k++) {
        count++;
    }
    System.out.println(count);
}//此时这个变量N不影响循环的次数     O(1)

计算bubblesort的时间复杂度

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;
        }
    }
}//O(n * n = n^2)

计算binarySearch的时间复杂度？

// 计算binarySearch的时间复杂度？
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;
}

千万不要看见循环就是O(n)，要看这个循环下次开始条件是啥

再下一次循环开始的时候，循环的起始或者终止就变成了区间的一半

n/2/2/2==1最终求到底执行了多少次除法操作

log₂N => 换底公式：log_NM = log_cM / log_cN

O(logn) => 对数时间复杂度，与底数无关

任意算法，若是不断除以任何数字，最终等于0或者1，这个算法的执行次数就是O(logn)

计算阶乘递归factorial的时间复杂度？

// 计算阶乘递归factorial的时间复杂度？
long factorial(int N) {
	return N < 2 ? N : factorial(N-1) * N; 
}

一个递归函数的时间复杂度，要把这个递归函数展开，看一下递归的次数与变量N的关系
$$N\ast N-1\ast N-2\ast ...\ast 1=>乘了N次。执行N次，O(N)$$

计算斐波那契递归fibonacci的时间复杂度？

// 计算斐波那契递归fibonacci的时间复杂度？
int fibonacci(int N) {
 return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

$$fibo(n)=fibo(n-1)+fibo(n-2)$$

$$等比数列求和：Sn=\frac{a_1-a_{n}q}{1-q}$$
运用等比公式求得总共方块个数为 2ⁿ-1 个方块，时间复杂度为O(2ⁿ)

重点

$$重点掌握O(1)O(N)O(N^2)O(logn)一个算法一般来说只需要看循环就行$$

---

空间复杂度

所谓的空间复杂度指的是算法在执行过程中”额外“开辟的内存空间！！！

判断方法

就看算法中有没有额外开辟“数组”空间 new一个数组

一般对象也是O(1)

for (int i = 0; i < 10; i++) {
    for (int i = 0; i < 100; i++) {//变量变的是值不是内存

    }
}

变量变的是值不是内存

所以还是O(1)

例题

计算bubbleSort的空间复杂度？

// 计算bubbleSort的空间复杂度？
    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;
            }
        }
    }

计算fibonacci的空间复杂度？

// 计算fibonacci的空间复杂度？
    int[] fibonacci(int n) {
        long[] fibArray = new long[n + 1];
        fibArray[0] = 0;
        fibArray[1] = 1;
        for (int i = 2; i <= n; i++) {
            fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
        }
        return fibArray;
    }

长度为n+1的long数组

这个数组就是存储从1，…n的斐波那契数

这个算法的空间复杂度为 O(N)

计算阶乘递归Factorial的空间复杂度？

// 计算阶乘递归Factorial的空间复杂度？
    long factorial(int N) {
        return N < 2 ? N : factorial(N - 1) * N;
    }

每次函数的调用过程，就对应一个函数的“栈帧”在栈中的入栈过程，递归函数调用几次，就需要开辟多少个栈帧空间，每个栈帧使用了常数个空间。空间复杂度为O(N)

计算test的空间复杂度

public void test(int n) {
    if (n == 1) {
        return;
    }
    int[] data = new int[n];
    test(n--);
}

O(N²)：总共执行了N次，每个函数的内部都会开辟大小为n的数组，乘起来就是N²

开辟N个栈帧，在每个栈帧里每次都开辟大小为N的整形数组

就是方法中有没有额外开辟空间的问题

• 就定义了几个临时变量，O(1)

• 定义了一堆变量，且这些变量的个数与N有关，int[] data = new int[n] => O(N)

总结

空间复杂度99%就两种：
$$O(1)和O(N)$$