算法基础一

一、评估算法优劣的指标

1.时间复杂度（流程决定）

2.空间复杂度（流程决定）

3.常数项时间（实现细节决定）

二、什么是时间复杂度，时间复杂度怎么计算

常数时间的操作，确定算法操作过程中总操作数量与样本数量之间的表达式关系，只看表达式的最高阶项部分。

三、什么是常数时间的操作

如果一个操作时间不以样本数量为变化，每次执行时间都是固定时间，称为常数时间操作。

举例常数项操作

1.算术运算（+、-、*、/、%等）

2.位与运算（>>、>>>、<<、|、&、^）

3.赋值，运算，自增，自减操作

4.数组寻址操作

操作时间固定的就是常数时间操作，反之，就是非常数时间操作

四、如何确定算法流程的总操作数量与样本数量之间的表达式关系

1.想象算法流程所处的数据状况，按照最差的情况来

2.把整个流程拆分成一个个基本动作，保证每个动作都是常数操作时间

3.如果数据量为N，看基本动作的数量与N什么关系

五、如何确定算法流程的时间复杂度

当完成了表达式的建立，只要把最高阶项留下即可。低阶项都去掉，高阶项的系数也去掉。记为O(忽略掉系数的高阶项)

六、通过三个具体的例子，来实践一把时间复杂度的估算

1.选择排序

过程：

arr[0～N-1]范围上，找到最小值所在的位置，然后把最小值交换到0位置。

arr[1～N-1]范围上，找到最小值所在的位置，然后把最小值交换到1位置。

arr[2～N-1]范围上，找到最小值所在的位置，然后把最小值交换到2位置。

…

arr[N-1～N-1]范围上，找到最小值位置，然后把最小值交换到N-1位置。

估算：

很明显，如果arr长度为N，每一步常数操作的数量，如等差数列一般，所以，总的常数操作数量 = a*(N^2) + b*N + c (a、b、c都是常数)

所以选择排序的时间复杂度为O(N^2)。

2.冒泡排序

过程：

在arr[0～N-1]范围上：

arr[0]和arr[1]，谁大谁来到1位置；arr[1]和arr[2]，谁大谁来到2位置…arr[N-2]和arr[N-1]，谁大谁来到N-1位置

在arr[0～N-2]范围上，重复上面的过程，但最后一步是arr[N-3]和arr[N-2]，谁大谁来到N-2位置;

在arr[0～N-3]范围上，重复上面的过程，但最后一步是arr[N-4]和arr[N-3]，谁大谁来到N-3位置

…

最后在arr[0～1]范围上，重复上面的过程，但最后一步是arr[0]和arr[1]，谁大谁来到1位置

估算：

很明显，如果arr长度为N，每一步常数操作的数量，依然如等差数列一般，所以，总的常数操作数量 = a*(N^2) + b*N + c (a、b、c都是常数)

所以冒泡排序的时间复杂度为O(N^2)。

3.插入排序

过程：

想让arr[0~0]上有序，这个范围只有一个数，当然是有序的。

想让arr[0~1]上有序，所以从arr[1]开始往前看，如果arr[1]<arr[0]，就交换。否则什么也不做。

…

想让arr[0~i]上有序，所以从arr[i]开始往前看，arr[i]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。

最后一步，想让arr[0~N-1]上有序， arr[N-1]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。

估算时发现这个算法流程的复杂程度，会因为数据状况的不同而不同。

如果某个算法流程的复杂程度会根据数据状况的不同而不同，那么你必须要按照最差情况来估计。

很明显，在最差情况下，如果arr长度为N，插入排序的每一步常数操作的数量，还是如等差数列一般

所以，总的常数操作数量 = a*(N^2) + b*N + c (a、b、c都是常数)

所以插入排序排序的时间复杂度为O(N^2）

七、总结

1.算法的过程，和具体的语言是无关的。

2.想分析一个算法流程的时间复杂度的前提，是对该流程非常熟悉

3.一定要确保在拆分算法流程时，拆分出来的所有行为都是常数时间的操作。这意味着你写算法时，对自己的用过的每一个系统api，都非常的熟悉。否则会影响你对时间复杂度的估算。

八、时间复杂度的意义

当我们要处理的样本量很大很大时，我们会发现低阶项是什么不是最重要的；每一项的系数是什么，不是最重要的。真正重要的就是最高阶项是什么。

这就是时间复杂度的意义，它是衡量算法流程的复杂程度的一种指标，该指标只与数据量有关，与过程之外的优化无关。

九、额外空间复杂度

你要实现一个算法流程，在实现算法流程的过程中，你需要开辟一些空间来支持你的算法流程。

作为输入参数的空间，不算额外空间。

作为输出结果的空间，也不算额外空间。

因为这些都是必要的、和现实目标有关的。所以都不算。

但除此之外，你的流程如果还需要开辟空间才能让你的流程继续下去。这部分空间就是额外空间。

如果你的流程只需要开辟有限几个变量，额外空间复杂度就是O(1)。

十、算法流程的常数项

我们会发现，时间复杂度这个指标，是忽略低阶项和所有常数系数的。

难道同样时间复杂度的流程，在实际运行时候就一样的好吗？

当然不是。

时间复杂度只是一个很重要的指标而已。如果两个时间复杂度一样的算法，你还要去在时间上拼优劣，就进入到拼常数时间的阶段，简称拼常数项。

十一、算法流程的常数项的比拼方式

放弃理论分析，生成随机数据直接测。

为什么不去理论分析？

不是不能纯分析，而是没必要。因为不同常数时间的操作，虽然都是固定时间，但还是有快慢之分的。比如，位运算的常数时间原小于算术运算的常数时间，这两个运算的常数时间又远小于数组寻址的时间。所以如果纯理论分析，往往会需要非常多的分析过程。都已经到了具体细节的程度，莫不如交给实验数据好了。

十二、常见的时间复杂度

排名从好到差：

O(1)  

O(logN)  

O(N)  

O(N*logN)  

O(N^2)   O(N^3)   …   O(N^K)

O(2^N)   O(3^N)   …   O(K^N)

O(N!)

十三、对数器

1.你想要测的方法a

2.实现复杂度不好但是容易实现的方法b

3.实现一个随机样本产生器

4.把方法a和方法b跑相同的随机样本，看看得到的结果是否一样

5.如果有一个随机样本使得比对结果不一致，打印样本进行人工干预，改对方法a和方法b

6.当样本数量很多时比对测试依然正确，可以确定方法a已经正确。

十四、认识二分法

1.在一个有序数组中，找某个数是否存在

2. 在一个有序数组中，找>=某个数最左侧的位置

3. 在一个有序数组中，找<=某个数最右侧的位置

4.局部最小值问题

int binarySearch(int[] nums, int target){
  if(nums == null || nums.length == 0){ //数组为空
    return -1;
  }
  int l = 0, r = nums.length - 1; //设置左右边界
  while(l <= r){ 
    int mid = l + (r-l) / 2; // 等同于mid=(l+r)/2,这种写法是为了防止数组越界,也可以写为(l+r) >>> 1
    if(nums[mid] == target){ //最终target=mid,输出mid
        return mid; 
    }else if(nums[mid] < target) { //目标值在(mid,r]之间
        l = mid + 1; 
    }else {  //目标值在[l,mid)之间
        r = mid - 1; 
    }
  }
  // 最后判断: l>r 即数组不存在
  return -1;
}