LeetCodeHot100 双指针 283. 移动零 11. 盛最多水的容器 15. 三数之和 42. 接雨水

合集 - LeetCode Hot100(10)

1.LeetCodeHot100 哈希 1.两数之和 46.字母异位词分组 128.最长连续序列2024-03-07

2.LeetCodeHot100 双指针 283. 移动零 11. 盛最多水的容器 15. 三数之和 42. 接雨水2024-03-10

3.LeetCodeHot100 73. 矩阵置零 54. 螺旋矩阵 48. 旋转图像 240. 搜索二维矩阵 II2024-03-144.LeetCodeHot100 二分查找 35. 搜索插入位置 74. 搜索二维矩阵 34. 在排序数组中查找元素的第一个和最后一个位置 33. 搜索旋转排序数组 153. 寻找旋转排序数组中的最小值2024-03-225.LeetCodeHot100 堆 215. 数组中的第K个最大元素 347. 前 K 个高频元素2024-03-236.LeetCodeHot100 栈 155. 最小栈 394. 字符串解码2024-03-247.LeetCodeHot100 数组 53. 最大子数组和 56. 合并区间 238. 除自身以外数组的乘积 41. 缺失的第一个正数2024-03-268.LeetCodeHot100 链表 160. 相交链表 206. 反转链表 234. 回文链表 141. 环形链表 142. 环形链表 II 21. 合并两个有序链表 2. 两数相加 19. 删除链表的倒数第 N 个结点 24. 两两交换链表中的节点 25. K 个一组翻转链表 138. 随机链表的复制 148. 排序链表 23. 合并 K 个升序链表2024-03-279.LeetCodeHot100 动态规划 70. 爬楼梯 118. 杨辉三角 198. 打家劫舍 279. 完全平方数 322. 零钱兑换2024-03-2910.LeetCodeHot100 二叉树 94. 二叉树的中序遍历 104. 二叉树的最大深度 101. 对称二叉树 543. 二叉树的直径 102. 二叉树的层序遍历 108. 将有序数组转换为二叉搜索树 98. 验证二叉搜索树 230. 二叉搜索树中第K小的元素 199. 二叉树的右视图 114. 二叉树展开为链表2024-03-31

收起

283. 移动零
https://leetcode.cn/problems/move-zeroes/description/?envType=study-plan-v2&envId=top-100-liked

public void moveZeroes(int[] nums) {
        int r = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0){
                int temp = nums[r];
                nums[r] = nums[i];
                nums[i] = temp;
                r++;
            }
        }
    }

总结：一个指针去记录放非0的位置，一个指针去遍历
11. 盛最多水的容器
https://leetcode.cn/problems/container-with-most-water/description/?envType=study-plan-v2&envId=top-100-liked

public int maxArea(int[] height) {
        int i = 0 , j = height.length - 1;
        int maxRain = 0;
        while (i < j){
            maxRain = height[i] < height[j] ? 
                    Math.max(maxRain , getRain(height ,i++,j)) :
                    Math.max(maxRain , getRain(height,i,j--));
        }
        return maxRain;
    }
    public int getRain(int[] height, int i,int j){
        return (j - i) * Math.min(height[i],height[j]);
    }

总结：使用双指针，总体思想就是先让指针在左右边界，然后每次指针往里收缩，收缩哪个呢，收缩二者矮的那个，因为收缩矮的，下个面积可能变大，如果收缩高的，下个面积不变（收缩了之后高度一样）或变小（收缩之后高度变小）（ps：如果收缩之后高度变大了，由于有之前的短板的存在，所以木桶效应，还是面积会变小）
15. 三数之和
https://leetcode.cn/problems/3sum/description/?envType=study-plan-v2&envId=top-100-liked

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        List<List<Integer>> resList = new ArrayList<>();
        for (int k = 0; k < nums.length - 2; k++) {
            if (nums[k] > 0) break;
            if (k > 0 && nums[k] == nums[k-1]) continue;
            int i = k + 1 , j = nums.length - 1;
            while (i < j){
                int sum = nums[k] + nums[i] + nums[j];
                if (sum > 0){
                    do{
                        j--;
                    }while (i < j && nums[j] == nums[j+1]);
                }else if (sum < 0){
                    do {
                        i++;
                    }while (i < j && nums[i] == nums[i-1]);
                }else {
                    resList.add(new ArrayList<Integer>(Arrays.asList(nums[k],nums[i],nums[j])));
                    do{
                        j--;
                    }while (i < j && nums[j] == nums[j+1]);
                    do {
                        i++;
                    }while (i < j && nums[i] == nums[i-1]);
                }
            }
        }
        return resList;
    }

总结：关键点在于去重，这里使用的方法就是先排序了，排序之后通过指针可以很好解决去重（发现和上一个重复就再往中间移动）， 最后犹豫不决先排序，步步逼近双指针！
42. 接雨水
https://leetcode.cn/problems/trapping-rain-water/description/?envType=study-plan-v2&envId=top-100-liked

public int trap(int[] height) {
        int rain = 0;
        // 左右指针：分别指向左右两边界的列
        int left = 0;
        int right = height.length - 1;
        // 左指针的左边最大高度、右指针的右边最大高度
        int leftMax = height[left];
        int rightMax = height[right];
        // 最两边的列存不了水
        left++;
        right--;
        // 向中间靠拢
        while (left <= right){
            leftMax = Math.max(leftMax,height[left]);
            rightMax = Math.max(rightMax,height[right]);
            if (leftMax <= rightMax){
                // 左指针的leftMax比右指针的rightMax矮
                // 说明：左指针的右边至少有一个板子 > 左指针左边所有板子
                // 根据水桶效应，保证了左指针当前列的水量决定权在左边
                // 那么可以计算左指针当前列的水量：左边最大高度-当前列高度
                rain += leftMax - height[left];
                left++;
            }else {
                // 右边同理
                rain += rightMax - height[right];
                right--;
            }
        }
        return rain;
    }

总结：核心思想就是上面注释中说的那样，左最高和右最高，若从左往右遍历的话 会更新左最高，此时如果右最高比左最高大就说明这一列肯定有水，就加进去即可 这道题我会每天复习一遍