时间复杂度和空间复杂度（区分递归与非递归版）

一.时间复杂度

1.非递归算法的时间复杂度

1.1常量阶

{
x++;
s=0;
}
 

 两语句的频度均为1，为常数阶，所以时间复杂度O(1)

特例：

for(i=0;i<10000;i++)
{
 x++;
 s=0;
}

 时间复杂度同样为O(1)

1.2线性阶

for(i=0;i<n;i++)
{
 x++;
 s=0;
}

时间复杂度为O(n)，称为线性阶 

特例：

x=0;
for(k=0;k<M;k++)
{
 x++;
}
for(k=0;k<N;k++)
{
 x++;
}

时间复杂度为O(M+N)

1.3平方阶

x=0;y=0;
for(k=1;k<=n;k++)
 x++;
for(i=1;i<=n;i++)
 for(j=1;j<=n;j++)
  y++;

时间复杂度为O()，称为平方阶 

特例：

x=0;
for(i=0;i<n;i++)
 for(j=0;j<m;j++)
  x++;

时间复杂度为 O(nm)

1.4立方阶

x=0;
for(i=1;i<=n;i++)
 for(j=1;j<=n;j++)
  for(k=1;k<=n;k++)
    x++;

时间复杂度为O(),称为立方阶

特例：

x=1;
for(i=1;i<=n;i++)
 for(j=1;j<=i;j++)
  for(k=1;k<=j;k++)
   x++;

 

所以时间复杂度为O( )

1.5对数阶

for(i=1;i<=n;i=i*2)
{
 x++;
 s=0;
}

设循环体中两条语句的频度为f(n),则n,f(n) 

所以时间复杂度为，称为对数阶

2.递归算法的时间复杂度

递归的时间复杂度=递归的次数 * 每次递归执行的次数

2.1计算阶乘递归的时间复杂度

long factorial(int N)
{
 return N<2 ? N :factorial(N-1)*N;
}

递归次数=N-1;每次递归执行的次数=1;时间复杂度为O(N)

2.2计算斐波那契递归的时间复杂度

fibonacci(N)
{
 return N<2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

 

递归的次数=2^0+2^1+2*2+……+2^(N-2)+2^(N-1) ；每次递归执行的次数=1；时间复杂度为O(N)

3.其他算法的时间复杂度

3.1计算二分查找的时间复杂度

binarySearch(array,value)
{
 begin=0;
 end=array.length-1;
 while(begin<=end)
 {
  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;
}

 

时间复杂度为O(logN)

3.2计算冒泡排序的时间复杂度

 bubblesort(array){
        for (end=array.length;end>0;end--){
            sorted=true;
            for (i=1;i<end;i++){
                if (array[i-1]>array[i]) {
                    swap(array, i - 1, i);
                    sorted = false;
                }
            }
            if (sorted==true){
                break;
            }
        }

F(N)     =（N-1）+（N-2）+...+2+1      =    （（N-1）+1）*（N1）/2       =       (-N)/2

时间复杂度为O() 

二.空间复杂度

1.计算非递归算法的空间复杂度

1.1

for（i=0;i<n/2;i++)
{
 t=a[i];
 a[i]=a[n-i-1];
 a[n-i-1]=t;
}

仅借助变量t,与问题规模n的大小无关，所以其空间复杂度为O(1) 

1.2

for(i=0;i<n;i++)
 b[i]=a[n-i-1];
for(i=0;i<n;i++)
 a[i]=b[i];

借助另一个大小为n的数组b，所以其空间复杂度为O(n) 

2.计算递归算法的空间复杂度

计算阶乘递归的空间复杂度

factorial(N)
{
 return N<2 ? N: factorial(N-1)*N;
}

空间复杂度为O(N)