代码随想录算法训练营第一天|704.二分查找、27.移除元素、35.搜索插入位置、34.在排序数组中查找元素的第一个和最后一个位置

今日学习的文章和视频链接

704文章链接: link
704视频讲解链接: link
27文章链接: link
27视频讲解链接: link
35文章链接: link
34文章链接: link

704.二分查找

看到题目第一想法

这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素,这是二分法使用的必要条件，因此考虑使用二分法。

实现过程中遇到的困难

边界条件与区间定义

1.第一种写法，定义区间[left,right]

//伪代码
left = 0   
right = num.size-1
while( left <= right )｛//取= 因为左=右时闭区间合理[1,1]
//middle=(left+right)/2  //两个int相加容易越界 
mid=left+(right-left)/2
if(nums[mid]>target)//target在mid左边 更新区间上届
//因为是mid>target 而且定义区间左闭右闭 所以要-1 区间应去除不符合要求的mid
right=mid-1；
else if (nums[mid]<target)
		left=mid+1;
	else return mid;}
Return -1 	

2.第二种写法[left,right)

//伪代码
【1，1）	不合法 既包含1又不包含1
left = 0   
right = num.size //开区间这里也要改
while( left <right )｛//不取= 因为左=右区间不合理[1,1）
//middle=(left+right)/2  //两个int相加容易越界 
mid=left+(right-left)/2
if(nums[mid]>target)//target在mid左边 更新区间上届
right=mid；//因为是mid>target 而且定义区间左闭右开
else if (nums[mid]<target)
		left=mid+1;  //依旧+1因为左闭 mid不符合区间的要求，mid一定不在要求范围内
	else return mid;}
Return -1 	

修改过后自己的代码

class Solution {
    public int search(int[] nums, int target) {
   //[left,right]
   int left=0;
   int right=nums.length-1;
   int middle;
   while(left<=right){
       middle=left+(right-left)/2;
       if(nums[middle]>target)
            right=middle-1;
       else if (nums[middle]<target)
        	left=middle+1;
       else
       return middle;}
       return -1;
     }   
}

27.移除元素

给你一个数组 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。你不需要考虑数组中超出新长度后面的元素。

看到题目第一想法

采用双指针法，基本原理就是一个指针寻找需要替代的位置，另一个指针寻找用以替代的数值。

实现过程中遇到的困难

相向指针方法及报错

class Solution {
    public int removeElement(int[] nums, int val) {
        int left=0;
        int right=nums.length-1;
        //要注意>=0以及先后顺序
        while((nums[right]==val)&&(right>=left)) right--;
        while (right>=left){
        if (nums[left]!=val) 
        left++;
        if(nums[left]==val){      //要用elseif 否则 上面++完会继续判断 if
             nums[left]=nums[right];
             left++;
             right--;
         }  
        while((nums[right]==val)&&(right>=left)) right--;}
    return left;}}
  

发现要权衡好短路逻辑与的边界条件right>=0以及它和nums[right]==val的主次关系；if… elseif…的写法。

修改后的方法

//快慢指针
class Solution {
    public int removeElement(int[] nums, int val) {
        int fast=0;
        int slow=0;
        for (fast=0;fast<nums.length;fast++)
            if(nums[fast]!=val){
            nums[slow]=nums[fast];
            slow++;}        
      return slow;}}

//相向指针
  class Solution {
    public int removeElement(int[] nums, int val) {
        int left=0;
        int right=nums.length-1;
         while((right>=0)&&(nums[right]==val)) right--;
        while (right>=left){
             if(nums[left]!=val) {
             left++;}//left++仍可优化
             else if (nums[left]==val){
             nums[left]=nums[right];
             left++;
             right--;}
        
         while((right>=0)&&(nums[right]==val)) right--;}
    return left;}}

//优化相向指针
class Solution {
    public int removeElement(int[] nums, int val) {
        int left=0;
        int right=nums.length-1;
         while((right>=0)&&(nums[right]==val)) right--;
        while (right>=left){
         if(nums[left]==val){
             nums[left]=nums[right];
            right--;
         }   left++;
         while((right>=0)&&(nums[right]==val)) right--;}
    return left;}}

35.搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。
如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0

看到题目第一想法

有序且无重复元素考虑二分法。边界条件有四种：

• 目标值在数组所有元素之前
• 目标值等于数组中某一个元素
• 目标值插入数组中的位置
• 目标值在数组所有元素之后
  

二分法搜索插入位置

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left=0;
        int right= nums.length-1;
        if (target<nums[0]){
            return 0;
        }//1
        if  (target>nums[right]){
            return (right+1);
        }  //2
        while (left<=right){
           int mid= left+(right-left)/2;
            if (nums[mid]==target){
            return mid;
            }else if(nums[mid]>target){
                right = mid-1;
            }else if(nums[mid]<target){
                left = mid+1;
            }
        }
        return left;}//3
        //1,2,3可合并为return right+1
}

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

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：你可以设计并实现时间复杂度为 $O(\log n)$ 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

看到题目第一想法

递增序列，但是可能会有重复元素，当时考虑用不了二分法，就用了双指针分别确定左右边界，最终确定答案。

寻找target在数组里的左右边界，有如下三种情况：

情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}

初版代码

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        int low = -1;
        int high = -1;
        while(left<=right){
            if(nums[left]!=target){
                left++;
            }else{
                low=left;
                break;}
            }
      while((low!= -1)&&(low<=right) ){
            if(nums[right]!=target){
                right--;
            }else{
                high=right;
                break;}           
        }    
        int[] m = new int[]{ low , high };
    return m;}
}

二分法代码1

// 1、首先，在 nums 数组中二分查找 target；
// 2、如果二分查找失败，则 binarySearch 返回 -1，表明 nums 中没有 target。此时，searchRange 直接返回 {-1, -1}；
// 3、如果二分查找成功，则 binarySearch 返回 nums 中值为 target 的一个下标。然后，通过左右滑动指针，来找到符合题意的区间

class Solution {
	public int[] searchRange(int[] nums, int target) {
		int index = binarySearch(nums, target); // 二分查找
		
		if (index == -1) { // nums 中不存在 target，直接返回 {-1, -1}
			return new int[] {-1, -1}; // 匿名数组 
		}
		// nums 中存在 targe，则左右滑动指针，来找到符合题意的区间
		int left = index;
		int right = index;
        // 向左滑动，找左边界
		while (left - 1 >= 0 && nums[left - 1] == nums[index]) { // 防止数组越界。逻辑短路，两个条件顺序不能换
			left--;
		}
        // 向左滑动，找右边界
		while (right + 1 < nums.length && nums[right + 1] == nums[index]) { // 防止数组越界。
			right++;
		}
		return new int[] {left, right};
    }
	
	/**
	 * 二分查找
	 * @param nums
	 * @param target
	 */
	public int binarySearch(int[] nums, int target) {
		int left = 0;
		int right = nums.length - 1; // 不变量：左闭右闭区间
		
		while (left <= right) { // 不变量：左闭右闭区间
			int mid = left + (right - left) / 2;
			if (nums[mid] == target) {
				return mid;
			} else if (nums[mid] < target) {
				left = mid + 1;
			} else {
				right = mid - 1; // 不变量：左闭右闭区间
			}
		}
		return -1; // 不存在
	}
}

二分法代码2

开始没看明白左右边界确定的条件，后来想明白：以右边界为例，计算出来的右边界是不包含target的右边界，左边界同理。因此leftBorder = right;rightBorder = left;

class Solution {
    int[] searchRange(int[] nums, int target) {
        int leftBorder = getLeftBorder(nums, target);
        int rightBorder = getRightBorder(nums, target);
        // 情况一
        if (leftBorder == -2 || rightBorder == -2) return new int[]{-1, -1};
        // 情况三
        if (rightBorder - leftBorder > 1) return new int[]{leftBorder + 1, rightBorder - 1};
        // 情况二
        return new int[]{-1, -1};
    }

    int getRightBorder(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                right = middle - 1;
            } else { // 寻找右边界，nums[middle] == target的时候更新left
                left = middle + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }

    int getLeftBorder(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
                right = middle - 1;
                leftBorder = right;
            } else {
                left = middle + 1;
            }
        }
        return leftBorder;
    }
}