时间复杂度
public void print(int n){
int a = 1; //执行1次
for(int i=0;i<n;++i){//执行n次
System.out.println(a+i);//执行n次
}
}
该算法的时间复杂度是O(2n+1) 大O会忽略常数、低阶和系数,最终记作O(n); 如果算法的执行时间和数据规模n无关,则是常量阶,记作O(1);
一般情况下,只要算法中不存在循环语句、递归语句,即使有成千上万行的代码,其时间复杂度也是Ο(1)
指数和阶乘是非多项式量级,其余都是多项式量级。我们把时间复杂度是非多项式量级的算法问题称为NP(Non-Deterministic-Polynomial,非确定多项式)问题。
//n是数组nums的长度
public int find(int[]nums,int n,int target){
for(int i=0;i<n;++i){
if(nums[i]==target){
return i;
}
}
return -1;
}
最好情况:上边最理想的情况就是第一个就是要找的,所以最好情况下时间复杂度是O(1)
最坏情况:最坏的情况,就是要找的数在最后一个,需要遍历n次,最坏情况下时间复杂度是O(n
平均时间复杂度:为了方便说明,我们假设数组中一定存在要找的数。而要找的数在0 - n-1这些位置出现的概率相同,都是 1/n ,所以考虑每种情况下总共要查找的次数,求出总数,然后再除以 可能的情况数,就是平均要查找的次数:
去除常量和系数就是:O(n) ;
public int[] twoSum(int[] nums, int target) {
//初始化一个数组存放结果
int[] re =new int[2];
for(int i=0;i<nums.length-1;++i){
int num1 = nums[i];
for(int j=i+1;j<nums.length;++j){
int nums2=nums[j];
//如果找到,就返回结果,避免多余循环
if((num1+nums2)==target){
re[0] = i;
re[1] = j;
return re;
}
}
}
return re;
}
最好情况:最好情况就是我们要找的两个数,刚好就是第一个和第二个数。所以外循环循环一次,内循环循环一次就完成了查找。时间复杂度是:O ( 1 ) ;
最坏情况:最坏情况就是,找遍到最后一个元素,才找到。
- 外层循环是从0循环到n-2
- 内层循环和外层循环的值有关,从外层当前的值,循环到n-1
总的比较次数就是每个外层循环时,内层循环的次数之和。比如外层i=0时,内层从1循环到n-1循环了n-1次,外层i=1时,内层从2循环到n-1循环了n-2次 …直到最后一次,内层只需要循环1次...
去掉常量、系数和低阶,时间复杂度就是: O() ;
平均情况 :
分析:我们最终的目的是要找到两个数,满足我们的条件。代码的外层循环显然是找第一个数,内层循环在找第二个数。根据假设,这对数存在并且唯一。(其他情况,比如有重复,复杂度会介于最好和平均之间,因为更容易找到,所以这里我们只分析唯一的情况)我们假设第一个要找的数 出现在下标 0 - n -2 的概率相等,都是 1/(n-2) , 所以外层循环的次数可能出现的情况如下:
当外层循环的次数是 1/(n-2) 时,内层需要循环n-1次,因为内层循环次数和外层的当前i有关。所以加权平均情况下的总的比较次数就是:
分子和分母的n-1 与n-2可以近似约掉,最后去掉系数和低阶 所以最终结果就是: O() ;
int i = 1;
while(i<n)
{
i = i * 2;
}
在while循环里面,每次都将 i 乘以 2,乘完之后,i 距离 n 就越来越近了。我们试着求解一下,假设循环x次之后,i 就大于 2 了,此时这个循环就退出了,也就是说 2 的 x 次方等于 n,那么 x = log2^n
也就是说当循环 log2^n 次以后,这个代码就结束了。因此这个代码的时间复杂度为:O(logn)
计算时间复杂度
例1
//计算Func1的时间复杂度
void Func1(int N)
{
int count = 0;
for (int i = 0; i < 2 * N; i++)
{
for (int j = 0; j < 2 * N; j++)
{
count++;
}
}
for (int k = 0; k < 2 * N; k++)
{
count++;
}
}
所以Func1函数的时间复杂度为:T(N) = 4 * + 2 * N ;大O的渐进表示法,只保留最高阶项(即4 * ),去除最高项的系数后(即)。所以,用大O的渐进表示法表示Func1函数的时间复杂度为:O() 。
例2
//计算Func2的时间复杂度
void Func2(int N)
{
int count = 0;
for (int k = 0; k < 100; k++)
{
++count;
}
printf("%d\n", count);
}
Func2函数的时间复杂度为T(N) = 100 ;根据大O的渐进表示法,所有的常数都用常数1来表示,所以,用大O的渐进表示法表示Func2函数的时间复杂度为:O(1) ;
例3
//计算二分查找函数的时间复杂度
int BinarySearch(int* a, int N, int x)
{
assert(a);
int begin = 0;
int end = N - 1;
while (begin < end)
{
int mid = begin + ((end - begin) >> 1);
if (x > a[mid])
begin = mid + 1;
else if (x < a[mid])
end = mid - 1;
else
return mid;
}
return -1;
}
计算二分查找函数的时间复杂度,我们需要对代码进行分析:我们用二分查找法查找数据时,查找一次后可以筛去一半的数据,经过一次次的筛选,最后会使得待查数据只剩一个,那么我们查找的次数就是while循环执行的次数。
因为数据个数为N,一次查找筛去一半的数据,即还剩N/2个数据,经过一次次的筛选,数据最后剩下1个,那么查找的次数可以理解为N除以若干个2,最后得1,那么while循环执行的次数就是N除以2的次数,我们只需计算N除以了多少次2最终等于1即可。
我们假设N除以了x个2,最终等于1,那么
最后,两边同时取2的对数,得while循环执行的次数,即x = logN 。所以,用大O的渐进表示法表示二分查找函数的时间复杂度为:O(logN)
表示时间和空间复杂度时,log表示以2为底的对数。
例4
//计算斐波那契函数的时间复杂度
int Fibonacci1(int N)
{
if (N == 0||N == 1)
return 1;
else
return Fibonacci1(N - 1) + Fibonacci1(N - 2);
}
使用递归法求斐波那契数,当我们要求某一个斐波那契数时,需要知道他的前两个斐波那契数,然后相加得出。那么当我们要知道第N个斐波那契数时,递归的次数如下图:
因为右下角的递归函数会提前结束,所以图中三角形必定有一块是没有数据的,但是当N趋于无穷时,那缺省的一小块便可以忽略不计,这时总共调用斐波那契函数的次数为:
等比数列的求和,最后得出结果为: - 1 。
保留最高阶项后,用大O的渐进表示法表示斐波那契函数的时间复杂度为:O() 。
注:递归算法的时间复杂度 = 递归的次数 * 每次递归函数中的次数。
//注意:斐波那契数列自顶向下递归的时间复杂度是2的n次方/(1.618的n次方);空间复杂度是O(n) ; 自底向上保留子问题的值求解时间复杂性是O(n),空间复杂度也是O(n);
空间复杂度
O(1)
一个算法的空间复杂度(Space Complexity)S(n)定义为该算法所耗费的存储空间,它也是问题规模n的函数。渐近空间复杂度也常常简称为空间复杂度。空间复杂度算的是变量的个数。
如果算法执行所需要的临时空间不随着某个变量n的大小而变化,即此算法空间复杂度为一个常量,可表示为 O(1)
int i = 1;
int j = 2;
++i;
j++;
int m = i + j;
//代码中的 i、j、m 所分配的空间都不随着处理数据量变化,因此它的空间复杂度S(n) = O(1)
O(n)
int[] m = new int[n]
for(i=1; i<=n; ++i)
{
j = i;
j++;
}
第一行new了一个数组出来,这个数据占用的大小为n,这段代码的2-6行,虽然有循环,但没有再分配新的空间,因此,这段代码的空间复杂度主要看第一行即可,即 S(n) = O(n)
例1
//计算冒泡排序函数的空间复杂度
void BubbleSort(int* a, int N)
{
assert(a);
for (int i = 0; i < N; i++)
{
int exchange = 0;
for (int j = 0; j < N - 1 - i; j++)
{
if (a[j]>a[j + 1])
{
int tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
冒泡排序函数中使用了常数个额外空间(即常数个变量),所以用大O的渐进表示法表示冒泡排序函数的空间复杂度为O(1) 。
例2
//计算阶乘递归函数的空间复杂度
long long Factorial(size_t N)
{
return N < 2 ? N : Factorial(N - 1)*N;
}
阶乘递归函数会依次调用Factorial(N),Factorial(N-1),…,Factorial(2),Factorial(1),开辟了N个空间,所以空间复杂度为O(N) 。
注:递归算法的空间复杂度通常是递归的深度(即递归多少层)。
例3
斐波那契数列的空间复杂性为O(n);