本文链接：https://blog.csdn.net/qq_52533790/article/details/121725460

数据结构篇（一）：

这里不多废话直接进入正题.

算法（Algorithm）：

一堆有限的指令集，就是一堆指令放在一起，去做一件事情，有时候会接收输入，有时候也不会接收输入，但是不管有没有输入，算法至少要产生一种输出，否则算法写出来就等于无效了，并且每一条指令必须有充分的目标，不可以有歧义，且要在计算机的计算范围以内。

正如我们所知道的，算法有分好的算法和坏的算法，那么我们如何区分他们呢？

答：空间复杂度S(n)—执行时占用存储单元的长度。

时间复杂度T(n)—根据算法写成的程序在执行时耗费时间的长度。但是因为不同机子对同一代码执行的时间总是存在差异，所以我们一般不算代码的执行时间，而是算执行次数。

当空间复杂度过大时，程序容易非正常中断，如下：

void prin_t(int N)
{
    if(N)
    {
        print(N-1);
        print("%d\n",N);
    }
    return;
}

以上代码，在输入N为10000时，print的数据为10000时占据了一个空间，print的数据为9999的时候又占据了一个空间，以此类推，此代码占据的空间将会越来越大，而如果只如下代码：

void prin_t(int N)
{
    int i = N;
	if(i ;i>0;i--)
    {
        print("%d",i);
    }
}

如果输入10000时，因为函数只运用了一个变量i和for循环，所以不管程序怎么跑，占用的空间依旧是i的空间，所以占据空间不会很大。

当然时间复杂度也不可过大：

代码1：

double f(int n,double a[],double x)
{
    int i;
    double p = a[0];
    for(i = 1;i<=n;i++)
    {
        p+=(a[i]*pow(x,i));
        return p;
    }
}

代码二：

double f(int n, double a[], double x)
{
    int i;
    double p = a[n];
    for(i = n;i>0;i--)
        p = a[i-1]+x*p;
    return p;
}

乍一看是不是代码一和二没什么区别？

注意，代码一中，pow(x,i)的操作让函数进行了n次乘法再加上与前面的系数相乘，则乘法的总次数为（n+1）n/2次，但是代码二的操作，每次for循环中只乘一次，所以乘法次数只有n次。二者的时间复杂度由此就大大体现出来，尤其时n很大的时候n²远远大于n本身。

一般在分析算法效率的时候，我们经常关注下面两种复杂度：

最坏情况复杂度和平均复杂度。

在算复杂度时我们有必要一步一步的去算算法的执行了多少次吗？

答案是没必要，我们考虑的只是随着N（数据规模的增大），算法复杂度增长的性子会如何。

就以上面代码一和代码二做例子：

代码一以n²做为增长的基数，代码二以n为增长的基数，当n很大时，n²远大于n的增长速率，所以第一个代码运行的时间一定会比第二个算法大超级多。

以下列出学习网课中的一张图片：
在这里插入图片描述

上图是不同函数的增长变化，当我们的函数复杂度增长速率为2的n次方时，我们最好能将它降级，比如到nlogn的增长速率。

设两个算法的复杂度为T1(n) = O(f1(n)),T2(n) = O(f2(n)),则：

T1(n)+T2(n) = max(O(f1(n)),O(f2(n)))

T1(n)×T2(n) = O(f1(n)×f2(n))

两个算法拼接在一起，则复杂度上界是二者间最大的那个，当两个算法嵌套起来的时候，两个复杂度上限相乘。

应用实例；

求给定N个整数的序列，求函数最大的子列和

算法一：

int MaxSubseqSum1(int A[],int N)
{
    int ThisSum,MaxSum = 0;
    int i,j,k;
    for(i = 0;i<N;i++)
    {
        for( j=i;j<N;j++)
        {
            ThisSum = 0;
            for(k = i;k <= j; k++)
            {
                ThisSum+=A[k];
                if(ThisSum>MaxSum)
                    ThisSum = MaxSum;
            }
        }
    }
    return MaxSum;
}

由上我们可知，算法1的复杂度增长为n³—三层嵌套的for循环。

算法二：

int MaxSubseqSum2(int A[],int N)
{
    int ThisSum,MaxSum = 0;
    int i,j;
    for(i = 0;i<N;i++)
    {
        ThisSum = 0;
        for( j=i;j<N;j++)
        {
            ThisSum+=A[k];
            if(ThisSum>MaxSum)
                ThisSum = MaxSum;
        }
    }
    return MaxSum;
}