衡量一个算法的好坏就是看它的时间复杂度和空间复杂度

时间复杂度是衡量一个算法的运行的时间，空间复杂度是衡量一个算法所需要的空间。

🎃时间复杂度

计算算法的时间复杂度是一个数学函数，理论上是没有办法计算的，只有在机器中跑起来的时候才可以知道，所以在实际操作中，我们一般采用大O的渐进表示法。

🍑大O渐进表达式

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

大O渐进表达式的规则：

1.用常数1取代运行时间中的所有加法常数 2.只保留最高阶项 3.如果最高阶项存在且不是1，则去除与这个项目相乘的常数

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

第一个循环语句执行N^2次，第二个循环语句执行2*N次，第三个执行10次

所以F(N)=N^2+2*N+10,根据我们前面大O渐进表达式的规则，最后结果就是N^2。

注意⚠️：一般讨论时间复杂度都是最坏情况下的时间复杂度

递归的时间复杂度 = 递归的次数 * 每次递归执行的次数

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

F(N) = N

🎃空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 ，算的是变量的个数。空间复杂度也使用大O渐进表达法

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(1)

递归的空间复杂度 = 递归的次数

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

动态开辟了N个空间，空间复杂度为 O(N)