算法初步

一. 复杂度

1. 基本定义

1. 时间复杂度

• 表示基本操作次数(汇编指令条数)

2. 空间复杂度

• 占用内存字节数

3. 使用大O记号
4. 区别

• 空间可以再利用

5. 时空互换

• 在长度为n的数组里面查找一个数字是否出现过
• 遍历的话需要操作n次。时间复杂度O(n),空间复杂度O(1)
• Hash表用巨大的数组来存储数据。使得时间复杂度O(1),空间复杂度O(n)或者更大

2. 复杂度的计算

1. O(1)

• 基本运算,+,-,*,/,%,寻址 无论执行多少次都是O(1)

2. O(logn)

• 二分查找,分治相关

3. O(n的½次方)

• 枚举约数,如求100的约数,从1~100依次除以100，其实只需要执行到50就可以

4. O(n)

• 线性查找

5. O(n²)

• 冒泡排序，选择排序

6. O(n³)
7. O(nlogn)

• 归并排序

8. O(2的n次方)
9. O(n!)

• 枚举全排列

10. 总结

• 优秀:O(1) < O(logn) < O(n的½次方) < O(n) < O(nlogn)
• 可能可以优化:O(n²) < O(n³) < O(2的n次方) < O(n!)

3. 均摊分析

1. 多个操作，一起算时间复杂度

• mutipop的队列，可以一次性出队k个元素.每个元素只出入队列一次
• 动态数组尾部插入操作(c++的 vector实现方法),一旦元素超过容量限制，则扩大一倍，再复制

长度k           长度为k的数组
长度k + 长度k   当存满以后申请一个长度为2k的数组，将之前的内容copy过来，再释放之前的内存空间

开空间的复杂度为O(1)
copy数据的复杂度为O(k)

如果n为16，则
当1,2,4,8,16的时候会执行copy操作
对应会执行1,2,4,8,16次插入操作
累计:2的O次方+2的1次方法+2²+2³+...+2的logn次方 = 2*2的logn次方法 - 1 ≈ 2n
所以插入的时间复杂度为O(2n) = O(n)
均摊每一次的插入操作的时间复杂度为O(1)

4. 最大子数组和

给定数组a[1...n],求最大子数组和，即找出1<=i<=j<=n,使a[i]+a[i+1]+...+a[j]最大

1. 暴力枚举O(n³)

int maxSubArray(int* nums,int numsSize){
    int ans = -1;
    for(int i = 0; i < numsSize; i++){
      for(int j = i; j < numsSize; j++){
        int sum = 0;
        for(int k = i; k <= j; k++){
          sum += nums[k];
        }
        if (sum > ans){
          ans = sum;
        }
      }
    }
    return ans;
}

2. 优化枚举O(n²)

int maxSubArray(int* nums,int numsSize){
    int ans = -1;
    for(int i = 0; i < numsSize; i++){
      int sum = 0;
      for(int j = i; j < numsSize; j++){
        sum += nums[j];
        if (sum > ans){
          ans = sum;
        }
      }
    }
    return ans;
}

3. 贪心法O(n)

int maxSubArray(int* nums,int numsSize){
    int ans = -1;
    int sum = 0;
    for(int i = 0; i < numsSize; i++){
      sum += nums[i];
    if (sum > ans){
        ans = sum;
      }
      if (sum < 0){
        sum = 0;
      }
    }
    return ans;
}