时间复杂度与空间复杂度

1.什么是数据结构?

       数据结构是计算机存储、组织数据的一种方式，指相互之间存在一种或多种特定关系的数据元素。

2.什么是算法呢？

       算法就是定义良好的计算过程，他取一个或一组的输入，并产生出一个或一组的输出。简单的说算法就是一系列的计算步骤，用来将输入转化为输出。

3.算法重要吗？

        在找工作或者刚毕业参加校招的同学来说，算法是很重要的一环。此外，我认为学习算法可以提高自身代码水平，提高代码效率，也能更好阅读优质的代码，进行学习。所以，我觉得学习算法是很有必要的。

        那么如何一个算法的好坏呢？那么就回归到了主题时间复杂提与空间复杂度。

4.算法效率

        衡量一个算法的好坏可以从空间复杂度与时间复杂度两个维度进行衡量。

        时间复杂度是衡量一个算法的速度，而空间复杂度是衡量一个算法开辟的额外空间。

5.时间复杂度

        我们在估算一个代码的时间复杂度的时候，通常都是进行大概的估计而不是精确的估计。比如一个函数:

        F(N)=N^2+2*N+1

只计算N^2，后面的2*N+1都进行了省略。因为当N足够大的时候，后面的数值可以忽略不计了。这里使用的就是大O渐进表示法。

        5.1大O渐进表示法

推到大O阶的方法：

1.所有的常数项都用1表示。

2.选取最高阶的项，去除其他项

3.最高阶存在且不是1，常数与最高阶相乘，则忽略常数。

        用大O渐进表示法表达出来的F(N)=O(N^2)。

N	F(N)精确值	F(N)估算值
100	10201	10000
1000	1002001	1000000

        通过表格可以看出忽略那些低阶项，保留最高项，可以更加简洁，同时结果也没有什么差距。

        有些算法的时间复杂度存在最好的，存在最差的，也存在中间值。

void Fain(int N)
{
    int i = 0;
    int j = 1;
    for(i=0;i<=N;i++)
    {
        if(i==j)
        break;

    }
    return;
}

        这段代码中最好的情况：第一次运行就找到了数值结束了循环。

        最坏的情况：是运行最大上限找到数字

        平均情况：就是运行一半结束循环。

        我们在计算时间复杂度的时候都是选择最坏的情况进行计算 所以以上代码的时间复杂度为O(N)。

      5.2  时间复杂度的实例

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

        这段代码中循环次数为2N+10根据大O渐进表示法为O(N)

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所以时间复杂度为O（N^2）。

 6.空间复杂度

        6.1概念

        空间复杂度指的是算法临时开辟的额外存储空间（函数运算时额外开辟的空间）。

        空间复杂度算的不是占用了多少bytes，而是变量的个数。空间复杂度计算规则基本跟实践复杂度类似它的计算和大O渐进表达式一样。

        6.2实例        

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];
     }    
 returen fibArray;
}

开辟了一块额外的空间，空间复杂度为O（N） 。