[二刷] 代码随想录算法训练营第一天[上]| 数组理论基础、704. 二分查找、27. 移除元素、34. 在排序数组中查找元素的第一个和最后一个位置、69. x 的平方根 、367. 有效的完全平方数

[KamaCoder] 数组理论基础

数组理论基础

需要注意一下数组的存储方式, 在 C++ 中二维数组是连续存储的, 但是在 Java 中二维数组就不一定是连续存储的了.

[LeetCode] 704. 二分查找

[KamaCoder] 704. 二分查找 文章解释

704. 二分查找

二分查找是对数组的一个基础操作, 要求元素是有序的, 递增或者递减都行, 同时元素需要不重复, 否则会导致搜索的结果不一致.

搜索过程中需要注意搜索的范围的定义:

        如果是 [左闭, 右闭] 的区间, 则当元素处于 middle 的左侧时候, right = middle - 1. 这里有两个原因, 第一个原因是 numbers[middle]  不等于 target, 因此 right 不能取 middle, 因为我们的区间右侧是闭合的, 因此遵从定义的话, 对于 right 我们应该排除掉那些已知不可能的元素, 第二个原因是 right 是需要收敛的, 否则当搜索一个不存在的元素时, 会导致死循环.

        如果是 [左闭, 右开) 的区间则简单很多, 因为 right 是不可选的, 因此当 numbers[middle] 不可选时, middle - 1 是可能可选的, 因而 right 不可以等于 middle - 1, 只能等于 middle.

[LeetCode] 27. 移除元素

[KamaCoder] 27. 移除元素 文章解释

27. 移除元素

双指针的典型应用, slowIndex 指向有效数组元素中, 最后一个元素的后一个位置, 而 fastIndex 则不停的往前走, 遇到有效的元素则赋值给 slowIndex 指向的位置.

[LeetCode] 35. 搜索插入位置

[KamaCoder] 35. 搜索插入位置 文章解释

当搜索不到的时候, 需要返回元素插入的位置, 因此要注意定义区间, 定义区间如果是 [left, right], 那么 left 最终会走到 right 的位置, 当结束的时候可能等于 right + 1, 因此要return right + 1, 定义区间如果是 [left, right) , 那么 left 是不会等于 right 的, 因此要 return right. 这里如果想不明白的话, 会觉得返回值总是写不清楚.

[LeetCode] 34. 在排序数组中查找元素的第一个和最后一个位置

[LeetCode] 34. 在排序数组中查找元素的第一个和最后一个位置 文章解释

34. 在排序数组中查找元素的第一个和最后一个位置

这一题的关键在与寻找左边界和右边界, 通过双指针寻找左右边界:

    寻找左边界: 只有当明确 target 位于 middle 的右侧时(number[middle] < target), 才让 left = middle + 1, 同时让 right 逼近 left. 这样才不会错过 middle 左侧的和 target 相同的元素. 同时如果 target 在列表中不存在的话, 最终 right 会穿透 left, 并且 left > right.

    寻找右边界: 只有当明确 target 位于 middle 左侧的时候(numbers[middle] > target), 才让 right = middle - 1, 同时让 left 逼近 right. 这样才不会错过 middle 右侧和 target 相同的元素. 同时如果 target 在列表中不存在的话, 最终 left 会穿透 right, 并且 left > right.

    这一题比我想想中的难一些, 同时双指针也不是单单只快慢指针. 这一点在另外一题"带退格键的字符串比较“里也体现出来了.

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums == null || nums.length == 0 
            || target < nums[0] || target > nums[nums.length - 1]) {
            return new int[]{-1, -1};
        }

        int leftBorder = -1;
        int rightBorder = -1;

        int left = 0;
        int right = nums.length - 1;
        int middle = 0;
        while (left <= right) {
            middle = left + ((right - left) >> 1);
            // 这里不能加等号, 因为 nums[middle] 等于 target 的时候, 
            // middle 左侧的元素可能也等于 target.
            if (nums[middle] < target) {
                left = middle + 1;
            } else {
                // 当 nums[middle] 等于 target 的时候, 
                // 继续尝试往左侧寻找其他等于 target 的位置
                right = middle - 1;
                if(nums[middle] == target) {
                    leftBorder = middle;
                }
            }
        }
        
        left = 0;
        right = nums.length - 1;
        while (left <= right) {
            middle = left + ((right - left) >> 1);
            // 这里不能加等号, 因为 nums[middle] 等于 target 的时候, 
            // middle 右侧的元素可能也等于 target.
            if (nums[middle] > target) {
                right = middle - 1;
            } else {
                // 当 nums[middle] 等于 target 的时候, 
                // 继续尝试往右侧寻找其他等于 target 的位置
                left = middle + 1;
                if (nums[middle] == target) {
                    rightBorder = middle;
                }
            }
        }
        return new int[]{leftBorder, rightBorder};
    }
}

[LeetCode] 69. x 的平方根 

69. x 的平方根 

class Solution {
    public int mySqrt(int x) {
        int left = 0;
        int right = x;
        int result = 0;
        while (left <= right) {
            int middle = left + ((right - left) >> 2);
            // 这里要过滤一下 middle 为 0 的情况, 否则 middle * middle 会溢出
            if(middle != 0 && middle > x / middle) {
                right = middle - 1;
            } else {
                result = middle;
                left = middle + 1;
            }
        }
        return result;
    }
}

 [LeetCode] 367. 有效的完全平方数

367. 有效的完全平方数 

class Solution {
    public boolean isPerfectSquare(int num) {
        int left = 0;
        int right = num;
        int result = 0;
        while (left <= right) {
            int middle = left + ((right - left) >> 2);
            if(middle != 0 && middle > num / middle) {
                right = middle - 1;
            } else {
                result = middle;
                left = middle + 1;
            }
        }
        return result * result == num;
    }
}