代码随想录跟练日记|Day1 数组part01

算法小白训练营日记，笔记为自用，若有错误感谢指出

--今日任务--：数组理论基础，704. 二分查找，35. 搜索插入位置，34. 在排序数组中查找元素的第一个和最后一个位置，27. 移除元素

一、数组理论基础

数组下标都是从0开始

数组内存空间的地址是连续的

C++中vector的底层实现是array，严格讲vector是容器，不是数组

数组元素不能删，只能覆盖

二维数组aij，i是行，j是列

不同编程语言内存管理不同，在C++中二维数组在地址空间上是连续的

二、二分法

704.二分查找

题目链接：704. 二分查找 - 力扣（LeetCode）

时间复杂度：O(log n)

空间复杂度：O(1)

前提：数组为有序数组，数组中无重复元素

边界问题需要注意：

两种写法，分为左闭右闭和左闭右开

左闭右闭

left=0，right = nums.size()-1，target存在区间为[left,right]，right值可以取到，left=right时有意义。

循环条件为while(left<=right)，当if(nums[mid]>target)时，right取mid-1。

代码如下：

//704左闭右闭
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            }
            else if (nums[mid] > target) {
                right = mid - 1;
            }
            else {
                return mid;
            }
        }
        return -1;
    }
};

左闭右开

left=0，right = nums.size()，target存在区间为[left,right)，right值取不到,left无法等于right

循环条件为while(left<right)，当if(nums[mid]>target)时，right取mid。

代码如下：

//704左闭右开
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size();
        while (left < right) {
            int mid = (left + right) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            }
            else if (nums[mid] > target) {
                right = mid;
            }
            else {
                return mid;
            }
        }
        return -1;
    }
};

35.搜索插入位置

题目链接：35. 搜索插入位置 - 力扣（LeetCode）

思路一致，运用二分法查找元素位置左闭右闭方法代码如下：

//35.搜索插入位置
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            }
            else if (nums[mid] > target) {
                right = mid - 1;
            }
            else {
                return mid;
            }
        }
        return left;
    }
};

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

题目链接：34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

力扣中等难度题型，对我来说稍微有点难，先看了解法再自己写了一遍代码，做到了能够理解的程度，等二刷时再巩固。

解题思路：运用两个二分法分别求两侧边界

查找元素分为三种情况：1.查找的元素在所给数组左右两边区间外。2.查找元素在数组区间内但不在数组中。3.查找元素在数组中。

对于情况一，若查找元素大于区间，则当nums[mid]<=target时left=mid+1;rightBorder=left;右边界无法更新，rightBorder只能取初始值-2，左边同理。

对于情况二，查找元素在区间内但不在数组中，此时leftBorder与rightBorder值相邻，相减等于1。

对于情况三，查找元素在数组内，leftBorder指向元素的第一个的前一位置，rightBorder指向元素的最后一个的后一位置，返回结果{leftBorder+1,rightBorder-1}即可。

代码如下：

//34.在排序数组中查找元素的第一个和最后一个位置
class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftBorder = getLeftBorder(nums, target);
        int rightBorder = getRightBorder(nums, target);
        //情况一
        if (rightBorder == -2 || leftBorder == -2) {
            return { -1,-1 };
        }
        //情况三
        if (rightBorder - leftBorder > 1) {
            return { leftBorder + 1,rightBorder - 1 };
        }
        //情况二
        return { -1,-1 };
    }

private:
    int getRightBorder(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        int rightBorder = -2;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > target) {
                right = mid - 1;
            }
            else {
                left = mid + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }

    int getLeftBorder(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        int leftBorder = -2;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
                leftBorder = right;
            }
        }
        return leftBorder;
    }
};

三、双指针法

27.移除元素

题目链接：27. 移除元素 - 力扣（LeetCode）

暴力解法

两层for循环，若nums[i]=val，则用后面的数覆盖。时间复杂度：O(n^2)，空间复杂度：O(1)。

代码如下：

//27.移除元素(暴力解法)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

遇到的问题：

j=i;nums[j]=nums[++j];导致最后一位无法被覆盖从而报错。另j=i+1;nums[j-1]=nums[j];解决。

双指针法

设置快慢指针，快指针用于遍历数组，若快指针所指向的值不为val，则用慢指针保存此数，更新下标，慢指针下标即为更新后数组元素个数。只遍历一次数组，时间复杂度为O(n)，空间复杂度为O(1)。代码如下：

//27.移除元素(双指针法)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int fast = 0, slow = 0;
        while (fast < nums.size()) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }
};

总结

今日任务完成✅昨晚做了一些外加今天上午共三小时，解决四道题并整理笔记。

四月份有自己刷过题，但是刚开始没两天又没坚持住，做过二分法的题昨天重做的时候又忘得差不多了，还需要反复学习巩固。数组的题还可以，后面的知识对我来说几乎都是新的，只会一些理论没有实际做过算法题，加了训练营强迫自己学习，希望能坚持吧，加油！