时间复杂度和空间复杂度是我们用来衡量算法好坏的一种评判标准,就像日常生活中学习考试一样,同样是考试,如果你取得高分,就说明你学的好或者说应是技巧好。而这里时间复杂度越低就说明算法也好,当然这个还要结合空间复杂度来讨论,也就是消耗的资源情况。
我们定义或者说是计算时间复杂度的方法如下(用大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)
这里还需要注意,既然是评判标准,那么就有好坏之分,时间复杂度中,我们有三种情况:最坏情况(运行到输入规模的最大运行次数)、平均情况(运行到输入规模的期望值运行次数)、最好情况(运行到输入规模的最小运行次数)
掌握了时间复杂度的计算方法,下面从几个例题中加以巩固该方法
1.
//计算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)
2.
//计算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)
3.
// 计算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)
4.
//计算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)。
平均的情况我们不去讨论,没什么意义。
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;
}
同样这里最好的一种就是执行1次,这个要看输入的数据而定,不能就说时间复杂度等于O(1)。
最坏的情况也就是输入的数据刚好是数组的边界,也就是最后一个数据或者第一个数据。我们在用二分查找法查找数据时,是这样设计的:第一次查找后剩下的数据是X/2,第二次查找后剩下的数据是X/4,第三次查找后剩下的数据是X/8......,直到剩下1个数据,哪个数据就是我们要查找的(这里不讨论找不到的情况),所以X/2^N=1,N=logX次(log2为底X的对数,这里的X因为是未知数,所以可以直接换成未知数N),所以时间复杂度O(logN)
6.
//计算阶乘递归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)
7.
//计算斐波那契递归fibonacci的时间复杂度
int fibonacci(int N){
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}
下面借助图来理解
上面虽然右半边下面没有执行的数据了,但是时间复杂度本就是一个粗略的评价标准,所以那一部分对整体的影响并不是很大。
时间复杂度
时间复杂度较空间复杂度更为重要,因为现在的计算机内存已经足够大了,所以一再强调占用空间的多少已经没有多大的意义,虽然不重要,但是作为了解,我们还是来看一下。
空间复杂度是对一个算法在运行中临时占用存储空间大小的度量,空间复杂度相等于变量的个数,其计算方法和时间复杂度一样。