算法主要学习的问题：

• 穷举：求N个数的全排列、八皇后问题
• 分而治之：二分查找、归并排序
• 贪心：最小生成树Prim，Kruskal
• 动态规划：背包、士兵路径

复杂度是算法的核心问题，主要分为时间和空间，使用大O记号（忽略系数）。

• 时间：指占用内存字节数
• 空间：指空间可以在利用
• 时空可以互换，通过Hush表

主要有以下几个常见取值：

• O（1）：基本运算，加减乘除，取模，寻址
• O（logn）：二分查找
• O（n1/2）：枚举约数
• O（n）：线性查找
• O（n2）：朴素最近点对
• O（n3）：Floyd最短路、普通矩阵乘法
• O（nlogn）：归并排序、快速排序期望复杂度
• O（2n）：枚举全部的子集
• O（n！）：枚举全排列

总结：

• 优秀：O(1)<O(logn)<O(n1/2)<O(n)<O(nlogn)
• 可优化：O(n2)<O(n3)<O(2n)<O(n!)

常用时间复杂度分析方法：

• 输入输出
• 数循环次数
• 均摊分析：指多个操作，一起计算时间复杂度，即平均计算

Leetcode例题：

121. 买卖股票的最佳时机：

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

暴力枚举法：时间复杂度O（n2）

class Solution:
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        max = 0
        for i in range(len(prices)):
            for j in range(i,len(prices)):
                if prices[j]-prices[i]>max:
                    max = prices[j]-prices[i]
        return max

优化版本：时间复杂度O（n），优化关键是对内层循环进行优化，从目前的prices向前看，同时将之前的最小值保存下来。

class Solution:
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        max = 0
        min = 99999999
        for i in range(len(prices)):
            if prices[i] < min:
                min = prices[i]
            if prices[i]-min>max:
                max = prices[i]-min
        return max

xxx.最大子数组和

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

暴力枚举法：O（n3）

class Solution:
    def findMax(self, nums):
        """
        :type nums: List[int]
        :rtype: float
        """
        for i in range(len(nums)):
            for j in range (i,len(nums)):
                for sum in range(i,j):
                    sum = sum + nums[sum]
                    if max < sum:
                        max = sum 
        return max

优化枚举：O（n2）,优化关键点是将最内层冗余循环去掉，加入sum=0表示如果内层循环nums[j]为负数，则清零重新计算。

class Solution:
    def findMax(self, nums):
        """
        :type nums: List[int]
        :rtype: float
        """
        for i in range(len(nums)):
            sum = 0
            for j in range (i,len(nums)):
                    sum = sum + nums[j]
                    if max < sum:
                        max = sum 
        return max

继续优化：O（n）,这次优化的点是我们发现如果sum<0,那么之前必定有负数，所以清零，后续不在计算之前的数。

class Solution:
    def findMax(self, nums):
        """
        :type nums: List[int]
        :rtype: float
        """
        sum = 0
        max = 0
        for i in range(len(nums)):
            if sum < 0:
                sum = 0
            sum  += nums[i]
            if max < sum:
               max = sum 
        return max

152. 乘积最大子序列

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

参考代码：O（n）先计算从左到右的相乘的最大值，再计算从右到左的最大值；再将两组最大值相比

class Solution:
    def maxProduct(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        inv_nums = nums[::-1]
        for i in range(1,len(nums)):
            nums[i] *= nums[i-1] or 1
            inv_nums[i] *= inv_nums[i-1] or 1
        return max(max(nums),max(inv_nums))

To be continue......