时间复杂度&空间复杂度

一  ：时间复杂度：实际上就是函数，这个函数计算基本操作执行的次数。
          ps:这里的函数指的就是数学里面的函数，而不是C语言里面的函数。
思考：可能会有人问，时间复杂度，那为什么不算程序运行的时间呢？原因是：程序运行的时间，跟环境有关，机器的性能等。同一个程序在不同机器下运行时间不同。
1. 算法分析分类：
（1 ）最坏情况：任意输入规模的最大运行时间（上界）
（2）平均情况：任意输入规模的期望运行时间
（3）最好情况：任意输入规模的最小运行时间（下界）
2. 例如：在一个长度为N的线性表中找一个数X
  最好情况：1次
  最坏情况：N次
  平均情况：N/2次
3.  时间复杂度的分析方法：
 （1）时间复杂度考虑算法的最坏情况，也就是算法最坏情况下执行的次数
 （2）忽略掉常数
 （3） 关注增长最快的表达式（忽略掉系数）
 （4）时间复杂度就是函数中基本操作所执行的次数
 （5）递归算法的时间复杂度为：递归的总次数*每次递归中基本操作所执行的次数
4.  O渐进的表示法：最坏情况的渐进表示。也就是把算时间复杂度的那个函数用渐进表示法表示
     例如：1000*N*N+2*N+1000 用O渐进表示为O(N^2)
5. 常见的时间复杂度有以下7种



二  ：空间复杂度：并不是计算整个程序在整个运行过程中所占总空间数，而是看占用空间最多的那次占用了多少空间。（也就是递归最深的那次所开辟的空间的个数）
    1.  举个例子：现在有一个栈stack，现在向里面Push数据Push(1),Push(2),Pop(),Push(3)总共向里面Push了三次数据，但是         栈的深度为2，所需栈的大小也就为2.这与上面 讲的是一样的，她堆栈最深的那一次所开辟的空间就是它所耗费空间的个数。
     2.ps:时间复杂度是算累积的次数，而空间不是看累积的
      空间复杂度S(n)也用渐进法O()表示
      若算法执行所需的空间相对于输入数据量n而言是一个常数，则空间复杂度为O（1）
      递归算法空间复杂度：递归深度N*每次递归所要的空间数，如果每次递归所要的空间是常数，则递归的空间复杂度为O(N).
三    例题：求二分算法的时间复杂度和空间复杂度
非递归：template <class T>
T Binary_Search(T*array, int number, const T& x)
{
assert(number >= 0);
int left = 0;
int right = number - 1;
while (left <= right)
{
int mid = (left&right) + ((left^right) >> 1);
if (array[mid] == x)
{
return mid;
}
else if (array[mid] < x)
{
left = mid + 1;
}
else
{
right = mi
4000
d - 1;
}
}
return -1;
}

循环的基本次数为log 2 N，所以时间复杂度是O(log 2 N);

由于空间是常数级别的，因此空间复杂度是O(1);


 递归：int Binary_Search(int* array, int left, int right, int x)
{

assert(left);
assert(right);
while (left <= right)
{
int mid = left + (right - left) / 2;
if (array[mid] == x)
{
return mid;
}
else if (array[mid] < x)
{
Binary_Search(array,mid+1, right,x);
}
else
{
Binary_Search(array,left, mid - 1, x);
}
}
return -1;
}递归的次数和递归的深度都是log 2 n,
时间复杂度：O(log 2 n)

空间复杂度：O(log 2 n)


四   例题：斐波那契数列的时间，空间复杂度
1.递归：int Fib(int n)
{
if (n < 2)
{
return n ;
}
return Fib(n - 1) + Fib(n - 2);

}时间复杂度：O(2^n)

空间复杂度：O(1)

2.非递归：
int Fib(int n)
{

int f1 = 0;
int f2 = 1;
int f;
if (n <= 1)
{
return n;
}
for (int i = 2; i <= n; i++)
{
f = f1 + f2;
f1 = f2;
f2 = f;
}
return f;

}时间复杂度：基本操作次数n-1, O(n)
空间复杂度：O(1)
3.int* Fib(int n)
{
int *array = new int[n + 1];
array[0] = 0;
array[1] = 1;
for (int i = 2; i <= n; i++)
{
array[i] = array[i - 1] + array[i - 2];
}
return array;

}
int main()
{

int * array = Fib(5);
printf("%d", array[5]);
system("pause");
return 0;
}时间复杂度：O(n)
空间复杂度：O(n)  注意new[] 的空间是一次性开出来的因此为O(n)
4.  递归改进版int Fib(int zero, int first, int n)
{
if (n < 2)
{
return n;
}
else if (n == 2)
{
return zero + first;
}
else
{
return Fib(first, zero + first, n - 1);
}
}
int main()
{

printf("%d", Fib(0,1,5));
system("pause");
return 0;
}
时间复杂度：O(n)
空间复杂度 ：O(n)
5.
void test(int N)
{
for (int i = 0; i < N; i++)//N^2
{
for (int j = 0; j < N; j++)
{
//...
}
}
for (int k = 0; k < 2 * N; k++)//2N
{
//...
}
int count = 10;
while (count--)//10
{
//...
}
}//F(N)=N^2+2N+10=O(N^2)

void test()
{
int count = 1000;
while (count--)//10
{
//...
}
}
//F(N)=1000=O(1)