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

leetcode 704.二分查找

704、二分查找
这道题主要考察二分查找的算法，第一次刷自己根据理解写了一段代码，超时了，当时完全没考虑区间的开闭，并且还在考虑数组个数奇偶的问题。

    int search(vector<int>& nums, int target) {
        int num_size = nums.size();
        int start = 0;
        int end = num_size-1;
        int center;
        while (end > start)
        {
            //cout << flag++ << endl;
            center = ceil(start + (end - start) / 2);
            if (nums[end] == target)
            {
                return end;
            }
            else if (nums[start] == target)
            {
                return start;
            }
            else if (nums[center] < target )
            {
                 start = center;
            }
            else if (nums[center] > target)
            {
                end = center;
            }
            else if (nums[center] == target )
            {
                return center;
            }
        }
        return -1;
    }

手把手带你撕出正确的二分法 | 二分查找法 | 二分搜索法 | LeetCode：704. 二分查找
后面学习了Carl老师的课程后，才明白二分法要考虑的因素很多，使用条件也比较严格，需要数组有序数组，且数组中无重复元素，并且写代码要考虑左闭右闭以及左闭右开的情况来写。

1、左闭右闭

   int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1; //数组从0开始，最后一位坐标是数组元素个数-1
        int middle = 0;
        while (left <= right)
        {
            middle = (left + right) / 2;//可能发生溢出
            if (nums[middle] > target)
            {
                right = middle - 1;
                //因为nums[middle] > target做过比较了，当前这个nums[middle]一定不是target
            }
            else if (nums[middle] < target)
            {
                left = middle + 1;//同上
            }
            else
                return middle;
        }
        return -1;//找不到就返回-1
    }

2、左闭右开

    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; // target 在左区间，在[left, middle)中
            } 
            else if (nums[middle] < target) 
            {
                left = middle + 1; 
            } 
            else 
            { 
                return middle; 
            }
        }
        return -1;//找不到就返回-1
    }

当int middle = (left + right) / 2;这样写可能发生溢出，引用别的同学的解释（假设100溢出。（60+50）/2就溢出了，因为先计算的60+50,。但是50+（60-50）/2就可以，先算60-50.），所以最好写成 left+(right-left) / 2；或者 left + ((right - left) >> 1);

leetcode 27. 移除元素

27. 移除元素
这道题我也先自己写了一下，然后遇到两个排列在一起的要删除的数据就会出错，原因是后一个数据覆盖前一个数据导致第一个要删除的数据被相同数据覆盖。

    int removeElement(vector<int>& nums, int val) 
      {
        int sz = nums.size();
        for (int i = 0; i < nums.size(); i++)
        {
            if (nums[i] == val)
            {
                for (int j = i; j < nums.size() - 1; j++)
                {
                    nums[j] = nums[j + 1];
                }
                nums[sz - 1] = 0;
            }
        }
        return 0;
    }

数组中移除元素并不容易！ | LeetCode：27. 移除元素

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。
学完才明白我没考虑下标 i 以后的数值都向前移动了一位，所以i也向前移动一位
正确的解法如下：

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;

    }
};

时间复杂度高，为O(n^2)

2、双指针法

    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.size(); fast++)
        {
            if (val != nums[fast])
            {
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }

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

定义快慢指针

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

时间复杂度低 O(n)。注意这些实现方法并没有改变元素的相对位置。