数组二分查找&移除元素

最新推荐文章于 2024-08-10 07:14:43 发布

暁_

最新推荐文章于 2024-08-10 07:14:43 发布

阅读量1k

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/m0_59425585/article/details/134360849

版权

数组

下标从0开始
内存空间地址连续

二分查找

题目：Leetcode704

使用二分法的前提条件：有序数组 & 无重复元素

思路：使用二分法查找，需要注意区间的定义，也就是不变量。遵循循环不变量原则，也就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作。

解法一：左闭右闭

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int middle = 0;
        //左闭右闭
        while(left <= right){ //left=right有意义，使用<=
            middle = left + (right - left)/2;//防止溢出
            if(nums[middle] > target){ //nums[middle]一定不等于target，排除出下一次寻找的区间范围
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            }
            else if(nums[middle] < target){ //nums[middle]一定不等于target，排除出下一次寻找的区间范围
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            }
            else{ //nums[middle]=target，直接返回下标
                return middle;
            }
        }
        return -1;
    }
};

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

解法二：左闭右开

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();
        int middle = 0;
        //左闭右开
        while(left < right){ //left=right无意义，使用<
            middle = left + (right - left)/2;
            if(nums[middle] > target){ //target在左区间
                right = middle;//左闭右开，right取不到middle，下次区间也不会作比较，所以可以作为边界
            }
            else if(nums[middle] < target){ //target在右区间
                left = middle + 1;
            }
            else{
                return middle;
            }
        }
        return -1;
    }
};

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

移除元素

题目：Leetcode27

思路：数组元素在内存地址中连续，不能直接删除，只能覆盖。

解法一：暴力解法

两遍for循环，寻找要移除的元素，将后面元素移位覆盖

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--;//移除后数组大小减小，最终值为新数组大小
            }
        }
        return size;
    }
};

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

解法二：双指针法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //双指针
        int slow = 0;//慢指针指向更新 新数组下标的位置
        //快指针寻找新数组的元素
        for(int fast = 0; fast < nums.size(); fast++) {
            if(nums[fast] != val) {  //如果快指针指向的元素不是要删除的元素
                nums[slow++] = nums[fast]; //依次进行覆盖
            }
        }
        return slow;
    }
};