Day1 数组part01

Day1 数组part01

一、数组理论基础

1、一维数组

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

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

• 我们在删除或者增添元素的时候，要移动其他元素的地址。

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

2、二维数组

以C++为例，在C++中二维数组是连续分布的。

二、二分查找

704. 二分查找 - 力扣（LeetCode）

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

由于题目强调是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件。

使用二分法时，主要是有while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1，这几个点不好把握。

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

1、暴力法

直接通过循环来查找，当找到target的时候，return索引即可；若没找到，则return -1；

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

2、二分查找——左闭右闭。

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，**也就是[left, right] **，left和right是左边界和右边界的索引。

• 此时对应的循环条件应为 while (left <= right)，终止条件为 left == right + 1，即 [right + 1, right]，此时区间为空，故循环终止，程序返回 -1 即可；
• 此时由于右边界是闭合的，所以right = nums.size() - 1；
• 当nums[middle] > target，此时target在left~middle之间，由于是左闭右闭，所以更新right为right = middle -1，因为middle已经搜索过了，所以我们只需在middle左侧的闭区间内进行搜索；
• 当 target > nums[mdiddle] 时（即 target 在右区间时），此时target在middle~right之间，更新left为left = middle + 1对应的搜索区间为 [middle + 1, right]，解释同上；

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;

        while(left <= right){
            int middle = (left + right) / 2;
            if(nums[middle] > target){
                right = middle -1;
            }
            else if(nums[middle] < target){
                left = middle + 1;
            }
            else return middle;
        }
        return -1;
    }
};

3、二分查找——左闭右开

第二种写法，我们定义 target 是在一个在左闭右开的区间里，**也就是[left, right） **，left和right是左边界和右边界的索引。

• 此时对应的循环条件为while (left < right)，因为left=right在这个区间里面是不成立的，当left == right，即循环终止；
• 由于右边界是开的，所以right = nums.size()；
• 当nums[middle] > target，此时target在left~middle之间，由于是左闭右开，所以更新right为right = middle ，虽然middle已经搜索过了，但是右边是开区间，所以不需要-1；
• 当 target > nums[mdiddle] 时（即 target 在右区间时），此时target在middle~right之间，更新left为left = middle + 1对应的搜索区间为 [middle + 1, right]，因为左边界是闭区间，所以在middle已经搜索过的情况下，需要从middle的下一个开始搜索。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();

        while(left < right){
            int middle = (left + right) / 2;
            if(nums[middle] > target){
                right = middle;
            }
            else if(nums[middle] < target){
                left = middle + 1;
            }
            else return middle;
        }
        return -1;
    }
};

三、移除元素

27. 移除元素 - 力扣（LeetCode）

给你一个数组nums和一个值val，你需要 原地 移除所有数值等于val的元素，并返回移除后数组的新长度。不要使用额外的数组空间。你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

1、暴力法

通过双循环来解决

• 第一个循环遍历数组，当该索引下的值等于val时，进入第二个循环；
  • 从该索引的后一个值开始遍历，逐一向前覆盖；

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int length = nums.size();
        for(int i = 0; i < length; i++){
            if(nums[i] == val){
                for(int j = i + 1; j < length; j++){
                    nums[j - 1] = nums[j];
                }
                i--;// 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                length--;
            }
        }
        return length;
    }
};

• 关于i–
  

2、双指针法

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

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

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;

        // fast 指针遇到等于 val 的元素跳过
        // 等待 slow 指针将这些元素覆盖
        // 即达到删去 val 的目的
        for(int fast = 0; fast < nums.size(); fast++){
            if(nums[fast] != val){
                // 先覆盖，再对 slow 自增，保证 nums[0...slow-1] 中不包含 val
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
};

四、总结

要看了视频讲解之后才能自己动手写，希望接下来能慢慢进步，争取做到不看讲解自己也能有些思路。