算法的基本概念

算法的基本概念

什么是算法（算法的定义）

程序=数据结构+算法

数据结构是要处理的信息

算法是处理信息的步骤

算法的五个特征

有穷性

有穷时间内能执行完，算法是用穷的，程序可以是无穷的。

确定性

相同的输入只会产生相同的输出

可行性

可以用已有的基本操作实现算法

输入

丢给算法处理的数据，输入可以是0个或者多个

输出

算法处理的结果，至少为1个

“好算法的特质”（算法设计的要求）

正确性

能正确解决问题，可分为以下三个层次：

• 算法对于几组输入数据能够得出满足要求的结果

• 算法对于精心选择的典型、苛刻而带有刁难性的输入数据能够得出满足要求的结果

• 算法对于一切的合法输入数据都能产生满足要求的结果

可读性

对算法的描述要让其他人看得懂

健壮性（鲁棒性）

对非法输入的抵抗能力,它强调即使输入了非法数据，算法也能加以识别！

高效率与低存储需求

• 算法执行省时、省内存

• 时间复杂度低、空间复杂度低

---

算法效率的度量（考研必考）

时间复杂度（时间开销与问题规模n之间的关系）

如何评估算法时间开销

让算法先运行，事后统计运行时间所存在的问题：

• 和机器的性能有关，如超级计算机vs单片机
• 和编程语言有关，越高的语言执行的效率越低
• 和编译程序产生的机器指令质量有关
• 有些算法是不能事后在统计的，如导弹的预测

算法时间复杂度

事先估计算法时间开销T(n)与问题规模n的关系（T表示“time”）

void loveyou(int n){ //n为问题规模
    int i=1;
    while(i<=n){
        i++;
        printf("I love you %d",n);
    }
    printf("I love you more than %d",n);
}
int main(){
    loveyou(3000);
}

语句频度：

2行 ————1次

3行 ————3001次（while判断语句）

4，5两行 ————3000次

7行 ————1次
$$T(3000)=1\ast 3001+2\ast 3000+1$$
时间开销与问题规模n的关系：
$$T(n)=3n+3$$

忽略表达式的某些部分

$$\begin{gathered} T_1(n)=3n+3\approx 3n \\ {T}_2(n)=n^2+3n+1000\approx n^2 \\ {T}_3(n)=n^3+n^2+9999\approx n^3 \end{gathered}$$

当n足够大时，可以只考虑阶数高的部分,甚至可以将前面的系数去掉，简化如下：
$$\begin{gathered} T_1(n)=O(n) \\ {T}_2(n)=O(n^2) \\ {T}_3(n)=O(n^3) \end{gathered}$$
大O表示法：大O表示“同阶”，同等数量级。即当n→∞时，二者之比为常熟
$$\begin{gathered} T(n)=O(f(n))⟺ \\ li{m}_{n\to +\infty }\frac{T(n)}{f(n)}=k \end{gathered}$$

• 加法规则：多项相加，只保留最高阶的项，且系数变为1

$$T(n)=T_1(n)+T_2(n)=O(f(n))+O(g(n))=O(max(f(n),g(n)))$$

• 乘法规则：多项相乘，都保留

$$T(n)=T_1(n)\ast T_2(n)=O(f(n))\ast O(g(n))=O(f(n)\ast g(n))$$

$$T_3(n)=n^3+n^2{\log }_{2}n=O(n^3)+O(n^{2}lo{g}_{2}n)$$

根据加法规则，只保留数量级大的，下面给出数量级比较：
$$O(1)<O({\log }_{2}n)<O(n)<O(n{\log }_{2}n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)$$

结论1：顺序执行的代码只会影响常数项，可以忽略。

结论2：只需挑循环中的一个基本操作分析它的执行次数与n的关系即可

结论3：如果有多层循环，只需要关注最深层循环了几次

三种时间复杂度

void loveYou(int flag[], int n){
    printf("I am Iron man");
    for(int i=0;i<n;i++){
        if(flag[i]==n){
            printf("I love you %d",n);
            break;//找到后立即跳出循环
        }
    }
}

计算上述代码的时间复杂度T(n)

最好情况：元素n在第一个位置 最好时间复杂度

最坏情况：元素n在最后一个位置 最坏时间复杂度

平均情况：假设元素n在任意一个位置的概率相同为1/n 平均时间复杂度

通常只关注最坏时间复杂度和平均时间复杂度

---

空间复杂度（空间开销（内存开销）与问题规模n之间的关系）

程序执行之前会先将程序代码装入内存中，同时将数据也装入内存中。

void test(int n){
    int flag[n][n];
    int other[n];
    int i;
}

上述代码的时间复杂度为：
$$S(n)=4\ast n^2+4\ast n+4=O(n^2)+O(n)+O(1)=O(n^2)$$
同时间复杂度的计算。

函数递归调用带来的内存开销

空间复杂度=递归调用的深度

void loveyou(int n){
    int a,b,c;
    if(n>1){
        loveyou(n-1);
    }
    printf("I love you%d\n",n)
}
int main(){
    loveyou(5);
}

每次递归调用时，内存中都会有a,b,c,n等变量，函数递归n次，则空间复杂度为S(n)=O(n)

void loveyou(int n){
    int flag[n];
    if(n>1){
        loveyou(n-1);
    }
    printf("I love you%d\n",n)
}
int main(){
    loveyou(5);
}

不同于上段代码，此代码在递归时每次都会给flag分配n个空间大小，共递归n次，则：
$$S(n)=\frac{n^2+n}{2}=O(n^2)$$