优先考虑时间复杂度

在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。

但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。

所以我们如今已经不需要再特别关注一个算法的空间复杂度。

🔎时间复杂度

一般所说时间复杂度为最坏情况下的时间复杂度

🌻大O渐近法

用1来取代执行次数中加法常数

举例：执行次数N²+2N+10——>N²+2N+1

只保留最高阶项

举例：执行次数N²+2N+1——>N²

如果最高阶项系数不为1，将其修改为1

举例：执行次数3N²——>N²

🌻举例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²+2N+10次

大O渐近法表示则是O(N²)

O(N²+2N+10——>N²+2N+1——>N²)

🌻举例2

共执行2N+10次

时间复杂度：0(N)

🌻举例3

共执行M+N次

时间复杂度：0(M+N)

如果M和N相等，时间复杂度：0(N)

🌻举例4

共执行100次

时间复杂度：0(1)

🌻举例5

第一次嵌套的for循环执行N-1-0次，第二次嵌套的for循环执行N-1-1次，因为N的值在递减

共执行[(N-1)+(N-2)+(N-3)+…+1]次——>N*(N-1)——>也就是N²-N次

时间复杂度：0(N²)

🌻举例6

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;
    }

🌻举例7

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

递归的时间复杂度：递归的次数*递归后代码的执行次数

假设N为4，那么递归了4次

当N是一个未知数时，递归了N次

每次递归后代码均执行了1次，因为时一个三目运算符，只能选择其中一项

时间复杂度：O(N*1)——>O(N)

🔎空间复杂度

空间复杂度是指一个算法在运行过程中临时占用存储空间大小

也是采用大O渐近法表示

🌻举例1

空间复杂度：O(1)

这里没有计算数组的空间，因为数组作为参数是必须开辟空间的，而不是在运行过程中临时开辟存储空间

🌻举例2

空间复杂度：O(N+1)——>O(N)

🌻举例3

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

当N为3时，递归了3次，所以在栈上临时开辟了3块空间

当N是一个未知数时，临时开辟了N块空间

空间复杂度：O(N)