代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素、977.有序数组的平方

704. 二分查找

力扣题目链接(opens new window)

文章讲解：代码随想录

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4     

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2     
输出: -1        
解释: 2 不存在 nums 中因此返回 -1        

提示：

• 你可以假设 nums 中的所有元素是不重复的。

• n 将在 [1, 10000]之间。

• nums 的每个元素都将在 [-9999, 9999]之间。

个人思考：

看到题目之后其实没有第一时间想到二分查找的，就想着直接遍历就好了（遍历也行，但是二分法时间复杂度更优），看了这题名字是二分查找后尝试唤起之前学二分法的回忆，发现确实没思路就老实了。

看了题解和示例代码之后，注意到：

1.使用二分法的条件：有序、元素不重复（因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的）

2.有两种区间的写法：左闭右闭即[left, right]，左闭右开即[left, right)

3.涉及的边界条件需要特别注意：选用不同区间，相应的边界写法也不同

二分法第一种写法：target在[left, right]（重要）

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        // 定义target在左闭右闭的区间里，right取到nums.length-1
        int right = nums.length - 1;
        //当left==right，区间[left, right]依然有效
        while(left <= right){
            int middle = left + (right - left)/2;
            //这个地方一开始我写成int middle = (left + right)/2，但是left + right是有整数溢出风险的，不好，改成上面的规避溢出风险
            if(nums[middle] > target){
                // target 在左区间，所以[left, middle - 1]
                right = middle - 1;
            }else if(nums[middle] < target){
                // target 在右区间，所以[middle + 1, right]
                left = middle + 1;
            }else {// nums[middle] == target
                // 数组中找到目标值，直接返回下标
                return middle;
            }
        }
        return -1;
    }
}

• 时间复杂度：O(log n)

• 空间复杂度：O(1）

  二分法第二种写法：target在[left, right）

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        // 定义target在左闭右开的区间里，right取到nums.length
        int right = nums.length;
        // 因为left == right的时候，在[left, right)是无效的空间
        while(left < right){
            int middle = left + (right - left)/2;
            if(nums[middle] > target){
                // target 在左区间，在[left, middle)中
                right = middle;
            }else if(nums[middle] < target){
                // target 在右区间，在[middle + 1, right)中
                left = middle + 1;
            }else {// nums[middle] == target
                // 数组中找到目标值，直接返回下标
                return middle;
            }
        }
        return -1;
    }
}

• 时间复杂度：O(log n)

• 空间复杂度：O(1)

27. 移除元素

力扣题目链接(opens new window)

文章讲解：代码随想录

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

个人思考：

考虑引入一个int变量k在遍历过程中记录值等于val的元素个数，遇到不等于val的就用这个值去更新前面待更新的元素（index-k），后面发现不知道需要更新的位置怎么表示（现在又觉得其实和双指针法本质差不多，明天再试试）

看完示例代码：

1.快指针可以理解成在旧数组中找非目标元素，然后赋值给慢指针指向的新数组，虽然都指向一个数组

2.定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组

• 慢指针：指向更新 新数组下标的位置

3.还可以理解为，我们拿 right 的元素也就是右边的元素，去填补 left 元素也就是左边的元素的坑，坑就是 left 从左到右遍历过程中遇到的需要删除的数

4.双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。

class Solution {
  public int removeElement(int[] nums, int val) {
    //双指针法,一个指向要移动的元素，一个指向需要更新的位置
    int slowIndex = 0;
    for(int fastIndex = 0; fastIndex < nums.length; fastIndex++){
    if(nums[fastIndex] != val){
      nums[slowIndex] = nums[fastIndex];
      slowIndex++;
        }
    }
    return slowIndex;
  }
}

• 时间复杂度：O(n)

• 空间复杂度：O(1)

977.有序数组的平方

力扣题目链接(opens new window)

文章讲解：代码随想录

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

• 输入：nums = [-4,-1,0,3,10]

• 输出：[0,1,9,16,100]

• 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2：

• 输入：nums = [-7,-3,2,3,11]

• 输出：[4,9,9,49,121]

个人思考：

这题也是考虑先把每个数平方，再进行排序，而且我只会冒泡排序。

看完示例代码和题解：

1.上面的思路属于暴力排序，时间复杂度是 O(n + nlogn)

2.双指针法：数组按非递减顺序排列，平方后最大数必然从两端产生，可以引入双指针从两边往中间移动，进行大小比较

class Solution {
    public int[] sortedSquares(int[] nums) {
        //双指针，一个在左，一个在右，用于比较来得到较大平方
        int left = 0;
        int right = nums.length - 1;
        int[] result = new int[nums.length];
        //这里取到相等是因为处理到最后一个数（最小的），也可以进行下面比较，比较结果相等，填充到新数组里面
        while(left <= right){
            for(int i = nums.length - 1; i >= 0; i--){
                if(nums[left] * nums[left] > nums[right] *nums[right]){
                    result[i] = nums[left] * nums[left];
                    left++;
                }else if(nums[left] * nums[left] <= nums[right] *nums[right]){
                    result[i] = nums[right] *nums[right];
                    right--;
                }
            }
            
        }
        return result;
    }
}

时间复杂度：O(n)

今日收获：

对双指针法的一些应用场景有了了解，然后二分法的使用条件注意到了，必须是有序、无重复元素的数据集合。

今天花了大概4h完成整个题目和博客，之后的刷题中还需要多熟悉这些算法，多多练手。

今天是训练营第一天，有句话说开始是成功的一半，希望自己能坚持到最后一天！！！