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

一、数组基础

数组是存放在连续内存空间上的相同类型数据的集合。

数组可以方便的通过下标索引的方式获取到下标对应的数据。

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的

正是因为数组在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

数组的元素是不能删的，只能覆盖。

 二维数组在内存的空间地址是连续的么？

c++中二维数组是连续分布的。

java中二维数组的每一行头结点的地址是没有规则的，更谈不上连续。

代码随想录

二、力扣704. 二分查找

二分查找算法也称折半搜索算法、对数搜素算法，是一种在有序数组中查找某一特定元素的搜索算法。 有序数组（整体有序[1,2,3,4,5]，局部有序[4,5,1,2,3]）

题目链接：

. - 力扣（LeetCode）

文档讲解：

代码随想录

视频讲解：手把手带你撕出正确的二分法 | 二分查找法 | 二分搜索法 | LeetCode：704. 二分查找_哔哩哔哩_bilibili

给定一个 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]之间。

思路：

两指针left和right，left指向数组下标[0]，right指向数组最后一个元素

为防止溢出 mid = left + (right - left)，mid = ( left + right ) // 2

思考到底是  还是 ，到底是right = middle呢，还是要right = middle - 1？

写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

mid = ( left + right ) // 2
if nums[mid] > target { //中间值大于目标值时，在左半边，改变right
            right = mid - 1
       } elif nums[mid] < target { //中间值小于目标值时，在右半边，改变left
            left = mid + 1
       } else nums[mid] == target { //中间值等于目标值时，即找到该元素
            return mid
       }
}
return -1 //循环结束仍未找到目标值，返回-1

左闭右闭[left, right]

• while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
• if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

  class Solution:
      def search(self, nums: List[int], target: int) -> int:
          left = 0
          right = len(nums) - 1
          while( left <= right ) :
              mid =  left + (right - left) // 2
              if nums[mid] > target:
                  right = mid - 1
              elif nums[mid] < target:
                  left = mid + 1
              else:
                  return mid
          return -1
          

左闭右开[left, right)

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

  class Solution:
      def search(self, nums: List[int], target: int) -> int:
          left = 0
          right = len(nums) 
          while( left < right ) :
              mid =  left + (right - left) // 2
              if nums[mid] > target:
                  right = mid
              elif nums[mid] < target:
                  left = mid + 1
              else:
                  return mid
          return -1
          

• 三、力扣27. 移除元素

题目链接：. - 力扣（LeetCode）

文章讲解：代码随想录

视频讲解：数组中移除元素并不容易！ | LeetCode：27. 移除元素_哔哩哔哩_bilibili 

给你一个数组 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:
    def removeElement(self, nums: List[int], val: int) -> int:
        i = 0
        l = len(nums)
        while i < l:
            if nums[i] == val:
                for j in range(i+1, l):
                    nums[j - 1] = nums[j]
                l -= 1
                i -= 1
            i += 1
        return l

快慢指针

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        # 快慢指针
        fast = 0  # 快指针
        slow = 0  # 慢指针
        size = len(nums)
        while fast < size:  # 不加等于是因为，a = size 时，nums[a] 会越界
            # slow 用来收集不等于 val 的值，如果 fast 对应值不等于 val，则把它与 slow 替换
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow

总结

数组基础

数组在内存空间的地址是连续的，不能增删，只能覆盖。

二分查找

二分法使用条件：有序数组、查找某一特定元素

左闭右闭区间和左闭右开区间都实现了二分查找算法来解决查找目标值的问题，但采用了不同的区间定义方式，要注意区间的定义就是不变量，在循环中坚持根据查找区间的定义来做边界处理，就是循环不变量规则。

移除元素
暴力法虽然效率低下，但是能锻炼代码思维能力。

双指针法简单且高效。