力扣每日一练之数组下篇Day3

🍕前面的话🥞

大家好！本篇文章将介绍2周搞定数据结构的题，来自力扣的35,两个数组的交集和121.买卖股票的最佳时机，本文将以这两道题作为背景，介绍经典的数组排序以及线性查找，展示语言为java（博主学习语言为java)。今天呢，是博主开始刷力扣的第三天，如果有想要开始准备自己的算法面试的同学，可以跟着我的脚步一起，共同进步。大家都是并肩作战的伙伴，一起努力奋力前行，路漫漫其修远兮，吾将上下而求索，相信我们一定都可以拿到自己期望的offer，冲冲冲！

👩‍💻博客主页：京与旧铺的博客主页

✨欢迎关注🖱点赞🎀收藏⭐留言✒

🔮本文由京与旧铺原创，csdn首发！

😘系列专栏：java学习

💻首发时间：🎞2022年5月1日🎠

🎨你做三四月的事，八九月就会有答案，一起加油吧

🔏参考在线编程网站：🎧力扣

🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦

🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲

🏓导航小助手📻

图片

🏸LeetCode350 两个数组的交集

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

 > 示例 1：
 >
 > 输入：nums1 = [1,2,2,1], nums2 = [2,2]
 > 输出：[2,2]
 > 示例 2:
 >
 > 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
 > 输出：[4,9]
 ​
 ​

👝解题思路

方法一：哈希表

由于同一个数字在两个数组中都可能出现多次，因此需要用哈希表存储每个数字出现的次数。对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。

首先遍历第一个数组，并在哈希表中记录第一个数组中的每个数字以及对应出现的次数，然后遍历第二个数组，对于第二个数组中的每个数字，如果在哈希表中存在这个数字，则将该数字添加到答案，并减少哈希表中该数字出现的次数。

为了降低空间复杂度，首先遍历较短的数组并在哈希表中记录每个数字以及对应出现的次数，然后遍历较长的数组得到交集。

 class Solution {
     public int[] intersect(int[] nums1, int[] nums2) {
         if (nums1.length > nums2.length) {
             return intersect(nums2, nums1);
         }
         Map<Integer, Integer> map = new HashMap<Integer, Integer>();
         for (int num : nums1) {
             int count = map.getOrDefault(num, 0) + 1;
             map.put(num, count);
         }
         int[] intersection = new int[nums1.length];
         int index = 0;
         for (int num : nums2) {
             int count = map.getOrDefault(num, 0);
             if (count > 0) {
                 intersection[index++] = num;
                 count--;
                 if (count > 0) {
                     map.put(num, count);
                 } else {
                     map.remove(num);
                 }
             }
         }
         return Arrays.copyOfRange(intersection, 0, index);
     }
 }
 ​

方法二：排序加双指针

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。

首先对两个数组进行排序，然后使用两个指针遍历两个数组。

初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。

博主采用的是方法二，下面我们来看怎么写代码，第一步，对两个数组进行重新排序。之后定义出来数组的长度，以及数组的最小值和角标初始化。完成这些基本操作后，我们就用循环开始计算了，首先用while循环，定义出角标的长度。

然后采用if else语句，在不同的情况下，增加角标大小，向后遍历，最后返回重合的角标

 class Solution {
     public int[] intersect(int[] nums1, int[] nums2) {
         Arrays.sort(nums1);
         Arrays.sort(nums2);
         int length1 = nums1.length, length2 = nums2.length;
         int[] intersection = new int[Math.min(length1, length2)];
         int index1 = 0, index2 = 0, index = 0;
         while (index1 < length1 && index2 < length2) {
             if (nums1[index1] < nums2[index2]) {
                 index1++;
             } else if (nums1[index1] > nums2[index2]) {
                 index2++;
             } else {
                 intersection[index] = nums1[index1];
                 index1++;
                 index2++;
                 index++;
             }
         }
         return Arrays.copyOfRange(intersection, 0, index);
     }
 }
 ​
 ​

🎳121 买卖股票的最佳时间

给定一个数组 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。

方法一：暴力解法

思路：枚举所有发生一次交易的股价差。

 public class Solution {
 public int maxProfit(int[] prices) {
     int len = prices.length;
     if (len < 2) {
         return 0;
     }
 ​
     // 有可能不发生交易，因此结果集的初始值设置为 0
     int res = 0;
 ​
     // 枚举所有发生一次交易的股价差
     for (int i = 0; i < len - 1; i++) {
         for (int j = i + 1; j < len; j++) {
             res = Math.max(res, prices[j] - prices[i]);
         }
     }
     return res;
 }
 }
 ​

方法二：动态规划

思路：题目只问最大利润，没有问这几天具体哪一天买、哪一天卖，因此可以考虑使用 动态规划 的方法来解决。

买卖股票有约束，根据题目意思，有以下两个约束条件：

条件 1：你不能在买入股票前卖出股票； 条件 2：最多只允许完成一笔交易。 因此 当天是否持股 是一个很重要的因素，而当前是否持股和昨天是否持股有关系，为此我们需要把 是否持股 设计到状态数组中。

状态定义：

dpi：下标为 i 这一天结束的时候，手上持股状态为 j 时，我们持有的现金数。换种说法：dpi 表示天数 [0, i] 区间里，下标 i 这一天状态为 j 的时候能够获得的最大利润。其中：

j = 0，表示当前不持股； j = 1，表示当前持股。 注意：下标为 i 的这一天的计算结果包含了区间 [0, i] 所有的信息，因此最后输出 dplen - 1。

说明：

使用「现金数」这个说法主要是为了体现 买入股票手上的现金数减少，卖出股票手上的现金数增加 这个事实； 「现金数」等价于题目中说的「利润」，即先买入这只股票，后买入这只股票的差价； 因此在刚开始的时候，我们的手上肯定是有一定现金数能够买入这只股票，即刚开始的时候现金数肯定不为 00，但是写代码的时候可以设置为 0。极端情况下（股价数组为 [5, 4, 3, 2, 1]），此时不发生交易是最好的（这一点是补充说明，限于我的表达，希望不要给大家造成迷惑）。 推导状态转移方程：

dpi：规定了今天不持股，有以下两种情况：

昨天不持股，今天什么都不做； 昨天持股，今天卖出股票（现金数增加）， dpi：规定了今天持股，有以下两种情况：

昨天持股，今天什么都不做（现金数与昨天一样）； 昨天不持股，今天买入股票（注意：只允许交易一次，因此手上的现金数就是当天的股价的相反数）。 状态转移方程请见 参考代码 2。

知识点：

多阶段决策问题：动态规划常常用于求解多阶段决策问题； 无后效性：每一天是否持股设计成状态变量的一维。状态设置具体，推导状态转移方程方便。

 public class Solution {
 public int maxProfit(int[] prices) {
     int len = prices.length;
     // 特殊判断
     if (len < 2) {
         return 0;
     }
     int[][] dp = new int[len][2];
 ​
     // dp[i][0] 下标为 i 这天结束的时候，不持股，手上拥有的现金数
     // dp[i][1] 下标为 i 这天结束的时候，持股，手上拥有的现金数
 ​
     // 初始化：不持股显然为 0，持股就需要减去第 1 天（下标为 0）的股价
     dp[0][0] = 0;
     dp[0][1] = -prices[0];
 ​
     // 从第 2 天开始遍历
     for (int i = 1; i < len; i++) {
         dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
         dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
     }
     return dp[len - 1][0];
 }
 }

🌌总结

通过这两道题，我们学习了哈希表和双指针，复习了数组和循环的知识，那么呢，期待一下下一篇文章吧，和我一起进步，每天努力多一些，迈出更大的一步

觉得文章写的不错的亲亲，点赞评论关注走一波，爱你们哦🛴