大牛领导单独找我聊了两句：搞框架的同时别忘了算法

前言

程序=数据结构+算法，好的算法能让程序更高效的运行；在当今数据信息时代，数据分析和数据处理肯定是避免不了，而算法便成为了很多公司门槛级的要求，特别是大厂；

赶紧搞起来，说不定离进大厂就只差一步呢(算法)~~~

算法简介

算法是一组完成任务的指令，任何代码片段都可视为算法。如下：

image-20210324175721795

1. 算法五大特性

• 有穷性：一个算法必须在执行有限步之后结束，且每一步都可在有限时间内完成。通俗一点理解就是不能出现类似死循环这样，导致算法无法结束。
• 确定性：算法中每条指令必须有确切的含义，对于相同的输入只能得出相同的输出。
• 可行性：算法中描述的每一步操作都可以通过已经实现的基本运算执行有限次来实现。
• 输入：一个算法有零个或多个输入。就好比一个方法，可以不传递参数，也可以传递参数。零个输入时其实代表算法本身设有初始条件。
• 输出：一个算法有一个或多个输出，这些输出是与输入有着对应关系的量。没有输出的算法是毫无意义的。

一个好的算法还应该有如下特征：

• 正确性：能正确解决问题，结果正确；
• 可读性：算法实现步骤容易读懂；
• 健壮性：算法能处理异常情况；比如输入不合法时，算法能给出对应处理；
• 高效率、低存储：时间复杂度低，空间复杂度低；即运行快，占用内存少。

2. 衡量算法好坏的标准

度量一个算法好坏，可以从两个维度进行判断：

• 时间复杂度：事先预估执行完算法的时间开销数量级；

  由于数据量多少、硬件配置、程序语言等因素会直接影响到算法的执行时间，比如同样的算法，数据量少的肯定快，硬件配置高的肯定快，所以不能用算法执行完成后的具体时间来衡量一个算法的好坏。

  一个算法，可以预估其时间开销级别(不受外界其他条件影响)，通常使用大O表示法来表示，来个例子：

  image-20210325084348799

  上图方法，为了方便理解，假设每一步需要1ms，当传入的n=1000时，每一步耗时如下：

  ①只执行一次，所以消耗1ms；

  ②由于每次循环需要判断，需要则需要1001次；消耗1001ms；

  ③和④在循环体中，所以分别需要执行1000次，总共消耗2000ms；

  所以总耗时为：T(1000)=1+1001+2*1000； 具体时间和传入的n有关系，则总耗时为：

  T(n)=1+(n+1)+2n；

  这里T代表时间，通常说时间复杂度的时候都不带单位。为了更加简洁直观，会使用大O表示法，去掉常数部分和系数部分，如下：

  T(n)=1+(n+1)+2n=O(n)；

  因为当n足够大时，系数和常数对算法度量的影响不大；这里就不细说啦；

• 空间复杂度：事先预估执行完算法的内存开销数量级 ；

  空间复杂度和时间复杂度类似，同样可以用大O表示，只是这个表示的是算法所消耗的内存，比如int占用4个字节，上图中用到中间变量nResult，在不考虑其他容量的情况下，消耗了4个字节，用大O表示法，依然是去掉常数和系数，对于常量的的表示为O(1)；

对于时间复杂度和空间复杂度，对应的数量级别越小，算法越高效。常遇到到级别从好到差的顺序如下：

O(1)<O(log₂ n)<O(n)<O(nlog₂ n)<O(n²)<O(n³)<O(2ⁿ)<O(n!)<O(nⁿ)

3. 算法的稳定性

若待排序数据中有两个相等的元素A和B，在排序前A在B前面，如果使用某种排序算法后，A仍在B前面，则称这种排序算法稳定，否则就不稳定。但稳定性不能用来衡量一个算法的好坏，只能算是算法的一个性质，对于一些场景，根本就不在乎两个相等元素的顺序。

从排序开始

排序在实际开发中用的比较多，就先从这入手吧；排序分为内部排序和外部排序两种：

• 内部排序：在排序期间元素全部存在内存中进行排序；常见的插入排序、交换排序、选择排序都是内部排序。
• 外部排序：在排序期间元素无法全部存放在内存中，必须在排序过程中不断地在内、外存之间移动。

1. 先来说说直接插入排序

1.1 算法思想

插入排序就是每次将一个待排序的数据插入到一个前面已排好序的子序列中，初始认为第一个元素就是排好序的序列，依次比较，然后插入到合适位置，直到完成排序为止。

插入排序的关键如下：

• 将待排序数据分为三部分，已经排好序的数据、下一个需要插入的数据、待排序的数据；
• 每一次都从待排序数据中取出一个需要插入的数据，将其放在哨兵位置；
• 将哨兵位置的数据(其实就是要插入的数据)与已排好序的数据进行比较，如果符合条件就插入到对应位置，其他数据统一向后移位即可；

1.2 算法实现与解析

算法代码如下(升序)：

image-20210325135045509

执行结果如下：

image-20210325134622616

解析排序步骤过程，如下：

image-20210325214501972

步骤说明：

图中绿线框部分代表是已经排好序的列表，箭头指的元素是下一个要插入的元素，黄线框部分为剩下的无序元素。黄方块为每次移动的数据，绿方块表示最后有序列表腾出的位置。

• 将原始数据array复制到新数组中arrayb中，这步的主要目的是后续不需要声明额外临时变量，也为了后续核心代码实现逻辑简单易懂，减少过多的判断；

• 第1步将第一个元素作为有序列表(第一元素为2)，下一个要插入的元素为5，将5放入哨兵位置，即索引为0的位置；然后依次遍历有序列表中的元素，与哨兵位的值5比较，这里只有2和5比较，2小于5，所以不需要改变位置；

• 第2步有序列表中的元素有2和5,下一个要插入的元素为6，将6放入哨兵位置，即索引为0的位置；然后依次遍历有序列表中的元素(2和5)，与哨兵位的值6比较，都小于6，所以不需要改变位置；

• 第3步有序列表中的元素有2、5、6,下一个要插入的元素为1，将1放入哨兵位置，即索引为0的位置；然后依次遍历有序列表中的元素(2、5、6)，与哨兵位的值1比较；

  第3-1步，由于是倒序遍历，先用有序列表中的6与1进行比较，6大于1，所以6往后移一位；

  第3-2步，继续遍历，用有序列表中的5与1进行比较，5大于1，所以5往后移一位；

  第3-3步，继续遍历，用有序列表中的2与1进行比较，2大于1，所以2往后移一位；

  第3-4步，遍历完有序列表中的元素，要插入的元素和哨兵位的元素相等，终止遍历；然后将哨兵位的元素(当前哨兵位为1)赋值给腾出的空间(腾出的索引位为1)；

• 第4步有序列表中的元素有1、2、5、6,下一个要插入的元素为9，将9放入哨兵位置，即索引为0的位置；然后依次遍历有序列表中的元素(1、2、5、6)，都小于哨兵位的值9，所以不用插入，位置不变；

• 第5步有序列表中的元素有1、2、5、6、9,下一个要插入的元素为3，将3放入哨兵位置，即索引为0的位置；然后依次遍历有序列表中的元素(1、2、5、6、9)，与哨兵位的值3比较；

  第5-1步，由于是倒序遍历，先用有序列表中的9与3进行比较，9大于3，所以9往后移一位；

  第5-2步，继续遍历，用有序列表中的6与3进行比较，6大于3，所以6往后移一位；

  第5-3步，继续遍历，用有序列表中的5与3进行比较，5大于3，所以5往后移一位；

  第5-4步，继续遍历，用有序列表中的2与3进行比较，2小于3，终止遍历；然后将哨兵位的元素(当前哨兵位为3)赋值给腾出的空间(腾出的索引位为3)；

第5步完成之后，已完成黄线框中无序元素的排序，排序也就完成啦；最终的结果就是1、2 、3 、5 、6 、9。

这样对比着图看详细说明，是不是好理解了很多。

如果有小伙伴不太理解上面的代码，可以使用定义临时变量作为哨兵的方式，步骤和上面基本一样，只是哨兵不一样，如下：

image-20210325235648402

1.3 算法分析

主要从时间复杂度、空间复杂度、是否稳定来进行分析：

时间复杂度

分析时间复杂度时，会从最好、平均、最坏三种情况进行分析；

最好时间复杂度：传入的数据是有序的(和最终的结果一致)，所以每次遍历，一次就能找到位置，所以插入排序的最好时间复杂度为O(n)，和传入的元素个数有关；

最坏时间复杂度：传入的数据完全和要的结果相反，所以每次都需要进行两次循环进行找到合适位置插入，所以最坏时间复杂度为O(n²)；

平均时间复杂度也就是：O(n²)；

空间复杂度

在算法核心部分只采用了固定的几个中间变量(i,j,arrayb[0])，所以算法过程中消耗的内存是一个常量，则空间复杂度为O(1)；

稳定性

由于在算法过程中采用的是小于符号进行比较，遇见相等的数据时就终止判断，所以不会影响原有的数据顺序，则直接插入排序是稳定的。

综上所述，插入排序的时间复杂度为O(n²)，空间复杂度为O(1)，是稳定算法；

总结

第一篇复习了一下关于算法相关知识，然后以简单的直接插入排序收尾，后面会依次总结其他算法，还是图解加说明的方式，让每一个算法学起来更简单。

感谢小伙伴的：点赞、收藏和评论，下期继续~~~

一个被程序搞丑的帅小伙，关注"Code综艺圈"，跟我一起学~~~