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

飞奥

已于 2024-07-03 22:27:30 修改

阅读量605

点赞数 10

文章标签：算法

于 2024-07-03 15:20:54 首次发布

本文链接：https://blog.csdn.net/ale1216/article/details/140145837

版权

1、二分查找

讲解视频：

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

文章讲解：代码随想录

1.1 思路

因为题目前提是有序数组，数组中无重复元素，所以满足二分查找的前置条件，如果有重复元素通过二分查找返回的元素下标可能不唯一。

二分查找，利用中值来缩减目标范围（未考虑到左闭右闭、和左闭右开两种写法）

1.1.1 左闭右闭

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 - left) / 2);
            if(target < nums[middle])
            {
                right = middle - 1;
            }else if(target > nums[middle])
            {
                left = middle + 1;
            }else 
            {
                return middle;
            }
        }
        return -1;
    }
};

1.1.2 左闭右开

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

2、移除元素

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

文章讲解:代码随想录

2.1 思路:覆盖

最初想法事直接进行覆盖（并未考虑到时间复杂度和空间复杂度概念）

就是两层for循环，一个for循环遍历数组元素，第二个for循环更新数组

时间复杂度：O(n^2)
空间复杂度：O(1)

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
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;

    }
};

2.2 新学习思路：双指针

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

定义快慢指针

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

时间复杂度：O(n)
空间复杂度：O(1)

// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};