数据结构-线性表(数组)-线性枚举中最值算法 1464.数组中两元素的最大乘积 && 628.三个数的最大乘积

线性枚举，往往就是对数组进行操作的，而且是进行遍历操作。所以最坏时间复杂度一般都是O(n)

数据结构：数组
算法：线性枚举
目标：求最大值

1. 数组中两元素的最大乘积
   原始算法
   思路就是求解数组nums中最大值和次大值

class Solution 
{
public:
    int maxProduct(vector<int>& nums) 
    {
        int len = nums.size();
        int max = (nums[0]-1)*(nums[1]-1);
        int temp;
        for(int i = 0;i < len; ++i)
        {
            for(int j = i+1;j<len;++j)
            {
                temp = (nums[i]-1)*(nums[j]-1);
                if(temp>max)
                {
                    max = temp;
                }
            }
        }
        return max;
    }
};

使用STL库

class Solution 
{
public:
    int maxProduct(vector<int>& nums) 
    {
        int len = nums.size();
        sort(nums.begin(),nums.end());
        return (nums[len-1]-1)*(nums[len-2]-1);

    }
};

看了英雄哥的求数组nums中最大值和次大值

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int len = nums.size();
        int max = 0;
        int nextmax = 0;
        for(int i = 0;i<len;++i){
            if(nums[i]>max){
                nextmax = max;
                max = nums[i];
            }
            else if(nums[i]>nextmax){
                nextmax = nums[i];
            }
        }
        return (max-1) * (nextmax-1);
    }
};

2. 三个数的最大乘积

进行升序排序后：分为全为正数或全为负数；有正数有负数；

全为正数或全为负数:
全是正数：最大的三个正数相乘 （len-1,len-2,len-3）
全是负数：最大的三个负数相乘 （len-1,len-2,len-3）

有正数有负数时：负数>=1个
如果有一个正数->两个最小的负数和正数相乘 （len-1,len-2,len-3）
如果有两个正数->两个最小的负数和最大的正数相乘 （0，1，len-1）
如果有三个正数及以上->三个正数相乘与两个最小的负数和最大的正数相乘比较
MAX{(len-1,len-2,len-3),(0，1，len-1)}

综上：MAX{ (len-1,len-2,len-3),(0，1，len-1) }就是最大的

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int len = nums.size();
        sort(nums.begin(),nums.end());
        if(nums[0]>0){
            return nums[len-1]*nums[len-2]*nums[len-3];
        }else if(nums[len-1]<0){
            return nums[len-1]*nums[len-2]*nums[len-3];
        }else{
            if(nums[len-1]*nums[len-2]*nums[len-3] > nums[len-1]*nums[0]*nums[1])
            {
                return nums[len-1]*nums[len-2]*nums[len-3];
            }
            else
            {
                return nums[len-1]*nums[0]*nums[1];
            }
        }
    }
};