时间复杂度
·如何评价一个算法的优劣,更简洁,更快捷?
·首先肯定不是更简洁,例如用递归实现斐波那契数列:
long long Fib(int N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
用迭代实现斐波那契数列:
int main()
{
long lnog m,n,k;
m=n=k=1;
int N=0;
scanf("%d",&N);
if(N<3)
N=1;
else
{
for(int i=3;i<=N;i++)
{
n=m;
m=k;
k=m+n
}
}
return 0;
}
显然用递归实现更加简洁,但我们也知道用递归实现斐波那契数列运算会非常臃肿、慢,并且有可能栈溢出。
·实际上,评价一个算法的优劣主要看它的时间复杂度和空间复杂度,最主要是看时间复杂度。
·时间复杂度主要衡量一个算法的运行快慢,而空间复杂度主要衡量一个算法运行所需要的额外空间。
·时间复杂度是一个函数,,算法中的基本操作的执行次数,为算法的时间复杂度。
大O渐进表示法
·不同函数之间执行次数千差万别,我们不可能详细去计算每个算法的精确执行次数,那样效率太低了。这里采用大O渐进表示法来衡量算法的时间复杂度。
先看如下一个例子:
void func1(int n)
{
for(int i=0;i<n;i++)
printf(" ");
printf(" ");
}
void func2(int n)
{
for(int i=0;i<n;i++)
printf(" ");
for(int i=0;i<n;i++)
printf(" ");
}
·在func1函数中,其基本操作printf(" "),总共执行了n+1次,那么它的时间复杂度就是O(n+1)吗?
——当然不是,这里我们运用数学分析的极限思想,当n取任意大时,n+1和n任意接近,也就是n+1的极限为n,也就是说这里起主导作用的是n,所以该函数的时间复杂度为O(n)。
·再看func2,其执行次数为2n,所以它的时间复杂度就是O(2n)了吗?当然不是,先前我们说了大O渐进表示法是为了更简便地表示时间复杂度,如果连系数都要加上那也算不得简便。而且n和2n显然是同阶的,也就是说n的极限与2n的极限的比值为常数,所以2n=O(n)。
·那么继续分析下列函数:
void func3(int n)
{
for(int i=0;i<n*n;i++)
printf(" ");
for(int i=0;i<n;i++)
printf(" ");
}
·如上func3的执行次数为nn+n,所以它的时间复杂度为O(nn+n)咯!还是不对!前面我们说了,只取影响最大的一项,这里显然是n*n的影响较大,所以该函数的时间复杂度为O(n2)
·还需要注意的是,大O渐进表示法其实是一个保守的估计方式,如果一个算法会出现不同情况的时间复杂度,我们取最差情况下的时间复杂度。
`我们学习了大O渐进表示法,还需要多多练习,了解一些常见情况。先举例一些常见的时间复杂度。
时间复杂度判断
void Func1(int N)
{
int count = 0;
for (int k = 0; k < 2 * N ; ++ k)
{
++count;
}
int M = 10;
while (M--)
{
++count;
}
printf("%d\n", count);
}
·上述函数的基本操作的执行次数为N+10,所以时间复杂度为O(N)。
2.
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;
}
printf("%d\n", count);
}
·上述函数的执行次数为N+M。分为三种情况,当N和M接近时,时间复杂度为O(N+M);当N远大于M时,时间复杂度为O(N);当M远大于N时,时间复杂度为O(M)。
3.
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}
·上述函数的执行次数为100,执行次数为常数,则时间复杂度为O(1).
4.
const char * strchr ( const char * str, int character );
上述函数执行次数显然就是字符串str的长度N次,所以时间复杂度为O(N)。
5.
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i-1] > a[i])
{
Swap(&a[i-1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
·上述函数是一个经典的冒泡排序,最坏情况下执行次数为n-1+n-2+……+1,即n(n-1)/2,则时间复杂度为O(N2)
6.
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
// [begin, end]:begin和end是左闭右闭区间,因此有=号
while (begin <= end)
{
int mid = begin + ((end-begin)>>1);
if (a[mid] < x)
begin = mid+1;
else if (a[mid] > x)
end = mid-1;
else
return mid;
}
return -1;
}
·上述函数的是一个简单的二分查找,当有N个变量时候,最糟糕的情况函数要执行log2N,当对数的底数为2时,我们可以省略底数,时间复杂度简写为O(logN)
7.
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}
·一个简单的阶乘一次递归函数,时间复杂度为O(N);
8.
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
·我们的老熟人斐波那契数列,先看第N项数,分解成N-1和N-2,N-1又分为N-2和N-3,N-2分为N-3和N-4,那么第N项需要执行的次数约为2N-1,则第N-1项执行次数为2N-2,依此类推。总的执行次数为1(2N-1)/(2-1),即2N-1次,则时间复杂度为O(2N)。显然这是个效率非常低下的算法。
空间复杂度
·空间复杂度也是一个数学表达式,是对一个算法在运行过程中临时占用存储空间大小的量度 。
由于硬件技术的进步,现在的内存空间已经是足够大了,往往我们计算算法的效率时,也很少考虑空间复杂度,更多是考虑时间复杂度,而且空间复杂度的大O渐进表示法的估算也更加简单。
空间复杂度的判断
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i-1] > a[i])
{
Swap(&a[i-1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
·上述函数只申请了一个临时变量int exchange,所以空间复杂度为O(1).
2.
long long* Fibonacci(size_t n)
{
if(n==0)
return NULL;
long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n ; ++i)
{
fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
}
return fibArray;
}
`上述函数总共申请了n+1个long long大小的空间,所以空间复杂度为O(N)
3.
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
上述函数调用了N个fac函数,并且调用时前一个函数空间没有释放,所以时间复杂度为O(N)