01-算法打卡-数组-二分查找-leetcode(704)-第一天

1 数组基础理论

        数组是存放在连续内存空间上的相同数据结构的集合。数组可以通过下标索引快速获取数据，因为数组的存储空间是连续的所以在删除、更新数据的时候需要移动其他元素的地址。
        下图是一个数组的案例图形：【内存连续、索引小标从0开始可以依次获得数据】

 删除113位置的数据，删除前和删除后对照

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

2、二分查找

704. 二分查找 - 力扣（LeetCode）704. 二分查找 - 给定一个 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 提示： 1. 你可以假设 nums 中的所有元素是不重复的。 2. n 将在 [1, 10000]之间。 3. nums 的每个元素都将在 [-9999, 9999]之间。https://leetcode.cn/problems/binary-search/description/

2.1 题目

给定一个 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

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

2.2 解题思路 

        首先强调了是有序数组，其次是元素不重复，因为一旦元素允许重复使用二分查找法返回的元素下标可能不是唯一的；这些都是使用二分查找的前提条件。
        可以采用暴力的方式，逐个遍历对比跟目标值是否相等。也可以采用二分查找的方式，会有三个索引下标 left  middle right，每次拿middle对应的值跟target比较，如果大于target则right移动到middle位置，如果小于target则left移动到middler，如果相等则直接返回下标即可。注意在二分查找的实现中，对应target定义是在一个怎么的区间中比如[left,right)、[left,right], 左闭右开，左闭右闭，这两种定义方式，直接影响了代码逻辑的编写方式。
        [left,right)：这种方式left=right是没有意义的<具体可以3.2代码方式>
        [left,right]：这种方式left=right是有意义的<具体可以3.3代码方式>

3 代码实现

        3.1 暴力方式

        使用遍历，从前往后依次查找到目标元素并返回对应的下标。算法的时间复杂度O(n)，虽然实现比较简单，但是时间复杂度很高。时间复杂度O(n)  空间复杂度O(1)

class Solution {
    public int search(int[] nums, int target) {
        for (int i=0;i<nums.length; i++) {
            if (nums[i]==target) {
                return i;
            }
        }
        return -1;
    }
}

    3.2 二分查找([left,right))

在这种方式后right是值是有意义的，所在在向前移动的时候，应该是middle，其次初次right应该是数组的长度(最大的索引下标是length-1)。时间复杂度O(log n)  空间复杂度O(1)
 

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

    }
}

  3.3 二分查找 [left,right]

在这种方式后right是值是有意义的，所在在向前移动的时候，应该是middle-1，其次初次right应该是数组的长度-1(最大的索引下标是length-1)。时间复杂度O(log n)  空间复杂度O(1)

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

    }
}