ARTS是什么? Algorithm：每周至少做一个LeetCode的算法题 Review：阅读并点评至少一篇英文技术文章 Tip：学习至少一个技术技巧,总结和归纳日常工作中遇到的知识点 Share：分享一篇有观点和思考的技术文章

Algorithm

完成leetcode算法第496题。

使用index数组存储nums2对应值的下标，使得双层for循环的第二层执行尽可能少的循环，虽然减少了循环，但是双层循环还是不理想，下面是官方给出的更好的实现思路：
栈（单调栈）
根据题意，数组 nums1 视为询问。我们可以：

  1. 先对 nums2 中的每一个元素，求出它的右边第一个更大的元素；
  2. 将上一步的对应关系放入哈希表（HashMap）中；
  3. 再遍历数组 nums1，根据哈希表找出答案
  1. import java.util.Arrays;
  3. /**
  4.  * 给你两个 没有重复元素 的数组nums1 和nums2，其中nums1是nums2的子集。
  5.  *
  6.  * 请你找出 nums1中每个元素在nums2中的下一个比其大的值。
  7.  *
  8.  * nums1中数字x的下一个更大元素是指x在nums2中对应位置的右边的第一个比x大的元素。如果不存在，对应位置输出 -1 。
  9.  *
  10.  * 
  11.  *
  12.  * 示例 1:
  13.  *
  14.  * 输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
  15.  * 输出: [-1,3,-1]
  16.  * 解释:
  17.  *     对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
  18.  *     对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
  19.  *     对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。
  20.  * 示例 2:
  21.  *
  22.  * 输入: nums1 = [2,4], nums2 = [1,2,3,4].
  23.  * 输出: [3,-1]
  24.  * 解释:
  25.  *    对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
  26.  *     对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。
  27.  * 
  28.  *
  29.  * 提示：
  30.  *
  31.  * 1 <= nums1.length <= nums2.length <= 1000
  32.  * 0 <= nums1[i], nums2[i] <= 104
  33.  * nums1和nums2中所有整数 互不相同
  34.  * nums1 中的所有整数同样出现在 nums2 中
  35.  *
  36.  * @author ohYoung
  37.  * @date 2021/10/12 22:30
  38.  */
  39. public class NextGreaterElement496 {
  41.     public static void main(String[] args) {
  42.         NextGreaterElement496 example = new NextGreaterElement496();
  43.         int[] nums1 = new int[]{ 4, 1, 2 };
  44.         int[] nums2 = new int[]{ 1,3,4,2 };
  45.         System.out.println(Arrays.toString(example.nextGreaterElement(nums1, nums2)));
  46.         nums1 = new int[]{ 2, 4 };
  47.         nums2 = new int[]{ 1,2,3,4 };
  48.         System.out.println(Arrays.toString(example.nextGreaterElement(nums1, nums2)));
  51.     }
  53.     public int[] nextGreaterElement(int[] nums1, int[] nums2) {
  54.         int[] res = new int[nums1.length];
  55.         Arrays.fill(res, -1);
  56.         int max = Arrays.stream(nums2).max().getAsInt();
  57.         int[] index = new int[max + 1];
  58.         for (int i = 0; i < nums2.length; i++) {
  59.             index[nums2[i]] = i;
  60.         }
  61.         for (int i = 0; i < nums1.length; i++) {
  62.             for (int j = index[nums1[i]]; j < nums2.length; j++) {
  63.                 if (nums2[j] > nums1[i]) {
  64.                     res[i] = nums2[j];
  65.                     break;
  66.                 }
  67.             }
  68.         }
  69.         return res;
  70.     }
  72. }

Review

How much faster is Java 17?
本文通过在同一台机器上使用不同jdk版本和不同垃圾回收器的组合的方式测试各个jdk版本垃圾回收效率。

Tip

  1. MySQL加锁的原则
    • 原则1：加锁的基本单位时next-key lock（前开后闭区间）
    • 原则2：查找过程中访问到的对象才会加锁
    • 优化1：索引上的等值查询给唯一索引加锁的时候，next-key退化成行锁
    • 优化2：索引上的等值查询向右遍历时且最后一个值不满足等值条件时，next-key lock退化成间隙锁
    • bug：唯一索引上的范围查询会访问到不满足条件的第一个值为止（个人在MySQL8.0.26版本验证时已修复）
  2. update操作可以拆成两步：1、删除符合条件的记录 2、插入更新后的记录（这个思想有助于理清加锁的细节）

    Share

    如何做一个有质量的技术分享
    最近需要做一个部门内的分享，正好看到耗子叔的这篇文章。照着做下来，感觉思路确实清晰许多。

    Finish

    预计完成时间：2021.10.04 ~ 2021.10.10
    实际完成时间：2021.10.12
    延期原因：国庆假期，处理其他事情