【数据结构】算法的时间与空间复杂度

目录

1、时间复杂度

1.1 大O阶表示法

1.2 具体案例分析

案例1：基础函数

案例2：基础函数

案例3：基础函数

案例4：冒泡排序

案例5：二分法查找

案例6：阶乘递归

案例7：Fibo数列

 2.空间复杂度

具体案例分析

案例1：冒泡排序

案例2：Fibo数列

案例3：阶乘递归

---

1、时间复杂度

时间复杂度并不是指一个算法具体运行的时间是多久，而是指算法的执行次数。

一般用大O阶渐进法表示，看的是最坏情况。

1.1 大O阶表示法

(1)用1取代运行时间中的所有加法常数；

(2)修改后的运行次数，要求只保留最高阶；

(3)如果最高阶的系数不为，则要变为1。

1.2 具体案例分析

案例1：基础函数

// 计算func2的时间复杂度？
void func2(int N) {
int count = 0;
for (int k = 0; k < 2 * N ; k++) {
count++;
} in
t M = 10;
while ((M--) > 0) {
count++;
} S
ystem.out.println(count);
}

分析：基本执行了2N+10次，时间复杂度是O(N）。

案例2：基础函数

// 计算func3的时间复杂度？
void func3(int N, int M) {
int count = 0;
for (int k = 0; k < M; k++) {
count++;
} f
or (int k = 0; k < N ; k++) {
count++;
} S
ystem.out.println(count);
}

分析：基本执行了M+N次，无法比较M和N的大小，两个阶数相同，所以为O(M+N)；

案例3：基础函数

// 计算func4的时间复杂度？
void func4(int N) {
int count = 0;
for (int k = 0; k < 100; k++) {
count++;
} S
ystem.out.println(count);
}

分析：执行了100次循环，所以为O(1);

案例4：冒泡排序

/ 计算bubbleSort的时间复杂度？
void bubbleSort(int[] array) {
for (int i= 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;
        }
     }
}

分析：最坏情况下，就是这个顺序刚好是逆序，这个时候每次都要进行交换。我觉得这个用具体的数字带进去比较好理解：比如要排序的元素是54321，外层循环i从1开始加到5，执行5次，内层循环i=1第一次循环的时候，第一个元素要和后面4个元素一直交换执行4次;第二次循环，内层要从2个元素开始要与后面的3个元素交换3次...依次类推，要执行4+3+2+1+0次=10次。

类比：当有n个元素，外层循环要执行n次，内层循环要执行(n-1)+(n-2)+...+1+0次=（n*(n-1)) /2 次用大O阶来表示就是O(n^2) 。

案例5：二分法查找

/ 计算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;
}

分析：最坏情况下，每次都要排除掉一半的不合适的值，n/2/2/2/....1，要进行次。

案例6：阶乘递归

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

分析：递归算法的时间复杂度本质上是要看: 递归的次数 * 每次递归中的操作次数。也是用具体数字理解比较容易：求f(5)的阶乘递归，将递归的式子展开，也就是执行了5次。类推该算法的复杂度为O(N)。

案例7：Fibo数列

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

分析：使用公式推导我觉得比较容易理解，参考该博主的博客~

 2.空间复杂度

空间复杂度是指程序运行过程中额外占用的内存大小，也是用大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;
    }

分析：使用了常数个额外空间（boolean sorted = true;），所以空间复杂度为 O(1)。

案例2：Fibo数列

/
/ 计算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;
}

分析：new关键字动态开辟了N+1个空间，空间复杂度为 O(N）。

案例3：阶乘递归

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

分析：注意：递归每调用一次函数，都会在栈上开辟栈帧空间。递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)。

好啦~今天就学到这，下次继续~