时间复杂度和空间复杂度的计算

1. 时间复杂度分为以下几个级别

• 常数级时间复杂度O（1）

/**
* 时间复杂度O（1）
* 无论多少次。只要跟输入次数n没关系，就是O(1)的时间复杂度。可以说是O（2），O(3).最终都是O(1)的复杂度
*/
function calculate(n){
    console.log(1);
    console.log(2);
    console.log(3;
    ....
    
}

• O(n)

for(var i = 0 ； i < n ;i++){
    console.log(1);
}

• O(logN)

for(var i = 1; i < n ; i = i*2){
    console.log(1);
}

• O(n^2)

for(var i = 1; i < n ; i++){
    for(var j = 1 ; j < n ; j++){
        console.log(1);    
    }
}

• O(NlogN)

/**
* 归并排序
*/
public class MergeSort {

    public void mergeSort(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = (left + right) / 2;
        mergeSort(array, left, mid);
        mergeSort(array, mid + 1, right);
        merge(array, left, mid, right);
    }

    private void merge(int[] array, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int leftPos = left;
        int rightPos = mid + 1;
        int tempPos = 0;
        while (leftPos <= mid && rightPos <= right) {
            if (array[leftPos] <= array[rightPos]) {
                temp[tempPos++] = array[leftPos++];
            } else {
                temp[tempPos++] = array[rightPos++];
            }
        }
        if (leftPos > mid) {
            while (rightPos <= right) {
                temp[tempPos++] = array[rightPos++];
            }
        } else {
            while (leftPos <= mid) {
                temp[tempPos++] = array[leftPos++];
            }
        }
        for (int i = 0; i < temp.length; i++) {
            array[i + left] = temp[i];
        }
    }

    @Test
    public void test() {
        int[] array1 = {6, 9, 1, 5, 9, 4, 2};
        System.out.println(Arrays.toString(array1));
        mergeSort(array1, 0, array1.length - 1);
        System.out.println(Arrays.toString(array1));
        int[] array2 = {6, 9, 1, 5, 9, 4, 2, 7};
        System.out.println(Arrays.toString(array2));
        mergeSort(array2, 0, array2.length - 1);
        System.out.println(Arrays.toString(array2));
    }

}

• O(K^N)

function fib(n){
    if(n < 2){return n;}
    return fib(n-1)+fib(n-2);
}

• O(N!)

long long factorial(unsigned n) {
    if (n==1)
        return 1;
    long long sum = 0;
    for (unsigned i=0; i<n; ++i)
        sum += factorial(n-1);
    return sum;
}

空间复杂度

正常的申请一个变量空间。无论申请多少个，都是O（1）

申请了一个长度为n的一维数组，那他的空间复杂度就是n。

申请了一个长度为n*N长度的数组，那他的空间复杂度就是n^2