时间复杂度与空间复杂度

原创于 2022-04-22 19:24:00 发布 · 789 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

算法数据结构专栏收录该内容

13 篇文章

订阅专栏

时间复杂度

时间复杂度和空间复杂度是我们用来衡量算法好坏的一种评判标准，就像日常生活中学习考试一样，同样是考试，如果你取得高分，就说明你学的好或者说应是技巧好。而这里时间复杂度越低就说明算法也好，当然这个还要结合空间复杂度来讨论，也就是消耗的资源情况。

我们定义或者说是计算时间复杂度的方法如下(用大O渐进表示法):

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

eg:运行次数N=100，它的时间复杂度就是O(1)

2.运行次数函数中，只保留最高项

eg:运行次数F(N)=N^2+2*N+1000，它的时间复杂度就是O(N^2)

3.如果最高项存在且不等于1，则去除与这个项目相乘的常数

eg:运行次数F(N)=2*N，它的时间复杂度就是O(N)

这里还需要注意，既然是评判标准，那么就有好坏之分，时间复杂度中，我们有三种情况:最坏情况(运行到输入规模的最大运行次数)、平均情况(运行到输入规模的期望值运行次数)、最好情况(运行到输入规模的最小运行次数)

掌握了时间复杂度的计算方法，下面从几个例题中加以巩固该方法

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

F(N)=2*N+10，根据时间复杂度计算方法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);
}

F(N)=M+N，根据时间复杂度计算方法O(M+N)

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

F(N)=100，根据时间复杂度计算方法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;
     }
} 
}

这里需要计算一下，由于array.length到底是多少我们是不知道的，这里暂且将他设为N，所以这里的冒泡情况有多少种我们就不得而知了，但是我们能够知道最好的一种和最坏的一种情况。

先说最好的一种，假设数组里面的元素是从小到大排列的，那么内层for循环执行N-2次，外层for循环只执行一次就break跳出整个循环了，所以F(N)=N-2+1，根据时间复杂度计算方法O(N)。

最坏的情况就是数组里面的元素是按照从大到小的顺序排列的，则内层for循环要执行N-2次，外层for循环要执行N次，注意这里不是相加，而是相乘。所以F(N)=N*(N-2)，根据时间复杂度计算方法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(1)。

最坏的情况也就是输入的数据刚好是数组的边界，也就是最后一个数据或者第一个数据。我们在用二分查找法查找数据时，是这样设计的：第一次查找后剩下的数据是X/2，第二次查找后剩下的数据是X/4，第三次查找后剩下的数据是X/8......，直到剩下1个数据，哪个数据就是我们要查找的(这里不讨论找不到的情况)，所以X/2^N=1，N=logX次(log2为底X的对数，这里的X因为是未知数，所以可以直接换成未知数N)，所以时间复杂度O(logN)

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

这里用实际的数据来判断更为直观好理解一点，假设N等于5，第一次递归进来N=5,5不小于2，执行一次递归，第二次递归进去N=4；同样继续递归，第三次递归进去N=3；第四次递归进去N=2；第五次递归进去N=1，这时已经执行了5次运算。然后依次回归，回归动作也是5次，所以总共是10次运行。当N不是一个特定的数字时，F(N)=2*N，时间复杂度为O(N)

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

下面借助图来理解

上面虽然右半边下面没有执行的数据了，但是时间复杂度本就是一个粗略的评价标准，所以那一部分对整体的影响并不是很大。

时间复杂度

时间复杂度较空间复杂度更为重要，因为现在的计算机内存已经足够大了，所以一再强调占用空间的多少已经没有多大的意义，虽然不重要，但是作为了解，我们还是来看一下。

空间复杂度是对一个算法在运行中临时占用存储空间大小的度量，空间复杂度相等于变量的个数，其计算方法和时间复杂度一样。