面试经典算法150题系列-数组/字符串操作之买卖股票最佳时机

买卖股票最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

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

示例 2：

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

实现思路：

从左到右遍历数组，同时维护一个最小买入价格 min_price 和计算到目前为止的最大利润 max_profit。

以下是 O(n) 算法的步骤：

1. 初始化 min_price 为第一个元素，即第一天的股票价格。
2. 初始化 max_profit 为 0。
3. 从第二天开始遍历数组 prices：
   • 对于每个价格 prices[i]，计算如果今天卖出的利润：profit = prices[i] - min_price。
   • 如果 profit 大于 max_profit，则更新 max_profit。
   • 如果 prices[i] 小于 min_price，则更新 min_price。
4. 返回 max_profit。

实现代码：

public int maxProfit(int[] prices) {
    // 如果数组为空或者只有一个价格点，无法进行交易，因此返回0
    if (prices == null || prices.length <= 1) {
        return 0;
    }
    
    // 初始化买入价格为数组的第一个价格点
    int minPrice = prices[0];
    // 初始化最大利润为0
    int maxProfit = 0;
    
    // 从数组的第二天价格开始遍历（索引1）
    for (int i = 1; i < prices.length; i++) {
        // 计算如果在今天卖出能够得到的利润
        int profit = prices[i] - minPrice;
        
        // 如果今天卖出的利润大于之前记录的最大利润，则更新最大利润
        if (profit > maxProfit) {
            maxProfit = profit;
        }
        
        // 如果今天的价格比之前的最小买入价格还要低，更新最小买入价格
        if (prices[i] < minPrice) {
            minPrice = prices[i];
        }
    }
    
    // 返回计算出的最大利润
    return maxProfit;
}

上述代码可以进行简短的优化，保持代码的简洁，我们可以使用Math.max和Math.min两个库函数代替if语句。

实现代码二：

    public int maxProfit(int[] prices) {
        // 初始化结果变量 res 为 0，这将用来累积计算得到的最大利润。
        int res = 0; 
        // 初始化买入价格 minBuy 为数组的第一个元素，即假设第一天买入。
        int minBuy = prices[0];
        
        // 从数组的第二个元素开始遍历（索引从1开始），因为我们已经用第一个元素初始化了 minBuy。
        for(int i = 1; i < prices.length; i++){
            // 计算当前价格与最小买入价格的差值，即如果今天卖出能得到的利润。
            // 使用 Math.max 函数更新 res，使其始终保持最大的利润值。
            res = Math.max(res, prices[i] - minBuy);
            
            // 更新 minBuy，使其始终保持迄今为止遇到的最小价格。
            // 如果当前价格更低，说明这是一个更好的买入点。
            minBuy = Math.min(minBuy, prices[i]);
        }
        
        // 遍历完成后，返回累计的最大利润。
        return res;
    }

知识补充（不了解上述两个函数有兴趣的人可以看看）：

1.Math.max

Math.max 是 Java 中的一个静态方法，属于 java.lang.Math 类。这个方法用于返回两个给定数值中的最大值。如果其中一个数值是浮点数，另一个是整数，那么整数将被转换为浮点数然后再进行比较。

以下是 Math.max 方法的一些关键点：

1. 静态方法：由于 Math.max 是静态的，你可以直接使用 Math.max 来调用它，而不需要创建 Math 类的实例。

2. 重载：Math.max 有多个重载版本。最常见的两个是：

   • public static int max(int a, int b)：返回 a 和 b 中的较大整数值。
   • public static double max(double a, double b)：返回 a 和 b 中的较大双精度浮点数值。

3. 数值类型：如果你使用 Math.max 比较不同类型的数值，比如整数和浮点数，整数将被隐式转换为浮点数。

4. NaN 处理：如果传入 NaN（Not a Number），Math.max 将根据其重载版本返回另一个数值（对于 int 版本，返回另一个参数，因为整数不能表示 NaN），或者返回 NaN（对于 double 版本）。

5. 使用示例：

   int maxInt = Math.max(5, 10); // 返回 10 
   double maxDouble = Math.max(3.14, 2.71); // 返回 3.14

在股票交易利润最大化问题中，Math.max 被用来更新到目前为止计算出的最大利润。每次循环中，我们使用 Math.max(res, prices[i] - minBuy) 来确定是保持当前的最大利润 res 还是更新为当前价格与最小买入价格差值的新利润。这确保了 res 始终保存了遍历过程中的最大利润值。

2.Math.min

以下是 Math.min 方法的一些关键点：

1. 静态方法：由于 Math.min 是静态的，你可以直接使用 Math.min 来调用它，而不需要创建 Math 类的实例。

2. 重载版本：

   • public static int min(int a, int b)：返回 a 和 b 中的较小整数值。
   • public static long min(long a, long b)：返回 a 和 b 中的较小长整数值。
   • public static float min(float a, float b)：返回 a 和 b 中的较小单精度浮点数值。
   • public static double min(double a, double b)：返回 a 和 b 中的较小双精度浮点数值。

3. 数值类型：Math.min 可以处理整数、长整数、单精度浮点数和双精度浮点数。如果你比较不同类型的数值，较小的数值将根据需要进行转换。

4. NaN 处理：如果传入 NaN（Not a Number），Math.min 的行为取决于其重载版本：

   • 对于整数值比较，如果任一参数是 NaN，结果将为另一个参数的值，因为整数不能表示 NaN。
   • 对于浮点值比较，如果任一参数是 NaN，结果将是 NaN。

5. 使用示例：

   int minInt = Math.min(5, 10); // 返回 5 
   double minDouble = Math.min(3.14, 2.71); // 返回 2.71

   在之前提到的股票交易利润最大化问题中，Math.min 被用来在循环中更新到目前为止遇到的最小股票价格。这样，我们可以确保在任何给定的日子卖出股票时，都能计算出以之前最低价格买入的最大利润。这是通过在循环体内使用 minBuy = Math.min(minBuy, prices[i]); 来实现的，其中 minBuy 变量始终保持着迄今为止的最小买入价格。