代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素。

代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素。

二分法介绍

注意事项：

• while(left < right) 取不取等号

• if(nums[mid] > target)

  right = mid-1; 中是否-1

关于这两个问题，主要看右边界是否能被取到

• 左闭右闭
  • 那么left = right时，[left,right]就是合法的，即第一个问题应该取等号；
  • 而当经过判断后，已经知道mid下标不符，所以下一个搜索区间应为[left,mid-1],即需要-1
• 左闭右开
  • left = right时，[left,right]就是不合法的，比如[1,1)就要跳出循环了，即不能取等号
  • 当经过判断知道mid位置不符合条件，下一个搜索区间为[left,mid)，即不需要-1
• 总结：两种方法其实都差不多，主要要注意保持代码的一致性，不要反复横跳

左闭右闭写法

    public int search(int[] nums, int target) {  //二分搜索之左闭右闭
        int right = nums.length - 1;         //1
        int left = 0;
        while (left <= right) {				//2
            int mid = (right + left) / 2;	
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] > target)	
                right = mid - 1;			//3
            else
                left = mid + 1;
        }
        return -1;
    }

左闭右开写法

public int search(int[] nums, int target) {  //二分搜索之左闭右开
    int right = nums.length;				//1
    int left = 0;
    while (left < right) {					//2
        int mid = (right + left) / 2;
        if (nums[mid] == target)
            return mid;
        else if (nums[mid] > target)
            right = mid;					//3
        else
            left = mid + 1;
    }
    return -1;
}

最后，我们可以清晰比较出，两种写法的主要区别就是三个位置的一致性，只要注意代码逻辑保持一致即可，一般情况下两种解法均可解题

相关题型练习

p704 二分法

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

• 个人解题思路：看到有序查找，直接套用上述的二分法即可，一次过

p35搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

• 个人解题思路：看到排好序查找，想到使用二分法，但与上一题有所区别，它要返回被插入的位置，所以最后我们还要再做一个判断

  class Solution {
      public int searchInsert(int[] nums, int target) {
          int right = nums.length - 1;
          int left = 0;
          int mid = 0;
          while (left <= right) {
              mid = (left + right) / 2;
              if (nums[mid] == target) {
                  return mid;
              } else if (nums[mid] < target) {
                  left = mid + 1;
              } else {
                  right = mid - 1;
              }
          }
          if (nums[mid] < target)            //比较一下最后查找的数与目标数
              return mid + 1;				  //若目标数更小则插入下一个位置，否则插入当前位置
          else return mid;
      }
  }
  

• 查看题解：最后的判断其实可以移除，直接返回left就行，最终如果找不到的话，left必然会移动到比target大的第一个数

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

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

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

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

• 个人解题思路
  • 看到排好序的数组查找问题，考虑二分
  • 题目要求查找目标值的开始位置与结束位置，考虑将问题转化为查找最左边的目标数和最右边的目标数
  • 使用两次二分法即可，用min和max记录最左和最右目标值位置

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int right = nums.length - 1;
        int left = 0;
        int mid = 0;
        int min = -1;
        int max = -1;
        while (left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] == target) {
                min = mid;
                right = mid - 1;		//找到目标值，将区间左缩
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        right = nums.length - 1;
        left = 0;
        while (left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] == target) {
                max = mid;
                left = mid + 1;			//找到目标值，将区间右缩
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return new int[]{min, max};//若找不到目标值，min = max = -1;
    }
}

• 题解升华：为了保证左闭右闭的一致性，做了一定的修改
  • 取消min和max，先找目标值的最左位置，然后用一个变量存储起来
  • 然后left取目标值最左位置，right还是数组最右位置，继续进行二分操作

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int right = nums.length - 1;
        int left = 0;
        int mid = 0;
        while (left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] >= target)
                right = mid - 1;        //将区间左缩,保证right一直指向>=目标值的数，
                // 通过改变mid使right找到小于目标值的最大值，若此值的下一个值不是目标值，则表示找不到
            else
                left = mid + 1;
        }
        if (nums.length == 0 || right >= nums.length - 1 || nums[right + 1] != target) return new int[]{-1, -1};
        int L = right + 1;
        left = right;                   //以查找到的最左目标值为左区间
        right = nums.length - 1;
        while (left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] <= target)
                left = mid + 1;            //找到目标值，将区间右缩,保证right一直指向<=目标值的数，
                // 通过改变mid使left找到大于目标值的最小值
            else right = mid - 1;
        }
        return new int[]{L, left - 1};
    }
}

p27 移除元素

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

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

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

• 个人思路：

  • 目前只能想到暴力法或者先排序再查找移除的办法

  class Solution {
      static int length = 0;
  
      public int removeElement(int[] nums, int val) {
          length = nums.length;
          for (int i = 0; i < length; ) {
              if (nums[i] == val) {
                  remove(nums, i);
              } else i++;
          }
          System.out.print(length + "，nums = [");
          for (int i = 0; i < length; i++) {
              System.out.print(nums[i]);
              if (i != length - 1) {
                  System.out.print("，");
              }
          }
          System.out.print("]");
          return length;
      }
  
      public void remove(int[] nums, int index) {
          for (int i = index; i < length - 1; i++) {
              nums[i] = nums[i + 1];
          }
          length--;
      }
  }
  

  快慢指针法：一次遍历复制覆盖的过程

  • 快指针：新数组的元素，将非目标值的元素替换给慢指针的位置
  • 慢指针：指向更新 新数组下标的位置，当快指针非目标值就可以更新
  • 代码：

  class Solution {
      public int removeElement(int[] nums, int val) {
          int slow = 0;
          for (int fast = 0; fast < nums.length; fast++) {
              if (nums[fast] != val) {
                  nums[slow] = nums[fast];
                  slow++;
              }
          }
          System.out.print(slow + "，nums = [");
          for (int i = 0; i < slow; i++) {
              System.out.print(nums[i]);
              if (i != slow - 1) {
                  System.out.print("，");
              }
          }
          System.out.print("]");
          return slow;
      }
  }
  

  • 过程：
    • 刚开始快指针若未遇到目标值，则慢指针就是原地复制
    • 当快指针遇到目标值时，快指针继续前进，慢指针不变
    • 此后当快指针再次遇到非目标值的时候，就给已经落后的慢指针赋值
  • 说明：slow的增长过程其实就是数有多少个非目标值的数字，即slow就是最终返回值