时间复杂度和空间复杂度

  1.算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般 是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。 时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

2.时间复杂度

简单点来说就是，算法中的基本操作的执行次数，为算法 的时间复杂度。

如果用下面这个题来说，我们的时间复杂度就是计算count的值

void Func2(int N)
{
 int count = 0;
 for (int k = 0; k < 2 * N ; ++ k)
 {
 ++count;
 }
 int M = 10;
 while (M--)
 {
 ++count;
 }
 printf("%d\n", count);
}

举个例子，计算他的复杂度，O(N+10)，进一步写的话就是O（N）；

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);
}

再计算一下 O(M+N); 如果M远大于N，则可以写出O(M);N远大于M，写成O(N);

void Func4(int N)
{
 int count = 0;
 for (int k = 0; k < 100; ++ k)
 {
 ++count;
 }
 printf("%d\n", count);
}

这个k是常数，那就是O(1);

我们值得一提的是一个叫做卡瑞尔公式的，这个公式让我们计算时间复杂度的时候要通过最坏的结果进行计算，举个例子，就是二分查找，如果再坏的话，就是在最后两个数之间找到，这样来计算它的时间复杂度。

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 ......9 8 7 6 5  4 3 2 1这样进行升序排列，我们第一次的循环是 n-1 第二次是n-2......最后一次是1 好了高中的等差数列=

n*（n-1）/2，这样的话，时间复杂度就是O(n^2);

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；所以我们的时间复杂度就是log2  n(log以二为底n的对数)；

long long Fac(size_t N)
{
 if(0 == N)
 return 1;
 
 return Fac(N-1)*N;
}

这个是函数递归，每次函数调用，复杂度都是O(1),那么调用多少次都是O(1)。

long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

我们可以由图看出来，也是一个等差数列，所以我们计算一下就是O(2^n)

3.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中 临时占用存储空间大小的量度 。

函数运行时所需要的栈空间 ( 存储参数、局部变量、一些寄存器信息等 ) 在编译期间已经确定好了,因 此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

lai

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;
 }
}

让我们来计算一下这个的空间复杂度， 常数个额外空间，所以O(1);

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个额外空间，能重复使用，所以，别的枝杈再用的时候，也是之前的空间，因为函数递归，遍历结束后就会往返这个，空间就会被回收利用。O(n);

long long Fac(size_t N)
{
 if(N == 0)
 return 1;
 
 return Fac(N-1)*N;
}

这个函数递归就区别刚才的时间复杂度，空间一直递归下去，一直需要创建，所以是O(n);

欢迎大佬指出错误，谢谢观看