Introducción a la eficiencia del algoritmo en Java

Algoritmo de eficiencia Hay
dos tipos de análisis de eficiencia de algoritmos: el primero es la eficiencia del tiempo, y el segundo es la eficiencia del espacio.
La eficiencia del tiempo se llama complejidad del tiempo, y la eficiencia del espacio se llama complejidad del espacio.
La complejidad del tiempo mide principalmente la velocidad de ejecución de un algoritmo, mientras que la complejidad del espacio mide principalmente el espacio extra requerido por un algoritmo.

Complejidad de tiempo El tiempo que tarda
un algoritmo es proporcional al número de ejecuciones de las declaraciones que contiene. El número de ejecuciones de operaciones básicas en el algoritmo es la complejidad de tiempo del algoritmo.
Cuando se calcula la complejidad de tiempo real, utilizamos gran O notación progresiva .

Big O notation (Big O notation): es un símbolo matemático utilizado para describir el comportamiento progresivo de una función.
Derivación del método de orden O grande:
1. Reemplace todas las constantes de suma en el tiempo de ejecución con una constante de 1.
2. En la función de tiempos de ejecución modificados, solo se retiene el término de orden más alto.
3. Si el término de orden más alto existe y no es 1, elimine la constante multiplicada por este elemento. El resultado obtenido es el gran orden O.

    // 计算func1的时间复杂度？
    static 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);
    }
    //通过推导大O阶方法知道，时间复杂度为 O(N^2)

    // 计算func2的时间复杂度？
    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);
    }
    //func2基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)

    // 计算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);
    }
    //时间复杂度为 O(N+M)

    // 计算func4的时间复杂度？
    void func4(int N) {
        int count = 0;
        for (int k = 0; k < 100; k++) {
            count++;
        }
        System.out.println(count);
    }
    //基本操作执行了100次，通过推导大O阶方法，时间复杂度为 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; 
            } 
        } 
    }
    //基本操作执行最好N次，最坏执行了(N*(N-1))/2次，通过推导大O阶方法+时间复杂度一般看最坏，
    //时间复杂度为 O(N^2)

    // 计算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;
    }
    //基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN)
    // ps：logN在算法分析中表示是底数为2，对数为N。
    // 有些地方会写成lgN。

    // 计算阶乘递归factorial的时间复杂度？
    long factorial(int N) {
        return N < 2 ? N : factorial(N-1) * N;
    }
    //基本操作递归了N次，时间复杂度为O(N)。

    // 计算斐波那契递归fibonacci的时间复杂度？
    int fibonacci(int N) {
        return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
    }
    //基本操作递归了2^N次，时间复杂度为O(2^N)。

Complejidad espacial La complejidad
espacial es una medida de la cantidad de espacio de almacenamiento ocupado temporalmente por un algoritmo durante la operación. La regla de cálculo de la complejidad del espacio es básicamente similar a la complejidad de la práctica, y también se usa la representación progresiva O grande.

    // 计算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(1)

    // 计算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个空间，空间复杂度为 O(N)

    // 计算阶乘递归Factorial的时间复杂度？
    long factorial(int N) {
        return N < 2 ? N : factorial(N-1)*N;
    }
    //递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)
}