算法刷题day01|数组：704.二分查找、27.移除元素

数组理论知识

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

2.数组下标都是从0开始的，数组内存空间的地址是连续的。

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

4.C++中，要注意vector 和 array的区别，vector的底层实现是array，严格来讲vector是容器，不是数组。

704.二分查找

左闭右闭法

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int low  = 0;
        int high = nums.size() - 1;
         当left==right，区间[left, right]依然有效，所以用 <=
        while (low <= high){
            int mid = (low + high) / 2;
            if (nums[mid] == target){
                return mid;
            }else if (nums[mid] < target){
                low = mid + 1;
            }else{
                high = mid - 1;
            }
        }
        return -1;
    }
};

左闭右开法

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { //因为left == right的时候，在[left, right)是无效的空间，使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

区别

左闭右闭：存在left == right情况，即：while(left <=right)

左闭右闭：不能取右端，即：while(left < right)，而且当nums[mid] > target时，更新right = mid

27.移除元素

暴力解法

两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。当时没有想到这种解法。

// 时间复杂度：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;

    }
};

双指针法（首尾指针法）

总体思路：将非目标元素全部移到数组最前面，首指针指向0，尾指针指向nums.size()-1，若首指针元素不为目标元素，首指针+1；否则，判断尾指针元素是否为目标元素，若是，则尾指针-1，否则首尾元素交换。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int low  = 0;
        int high = nums.size() - 1;
        //用于交换首尾指针的元素
        int temp;
        int k = 0;
        while (low <= high){
            if (nums[low] != val){
                low++;
            }else {
                if (nums[high] == val){
                    high--;
                }else{
                    temp = nums[low];
                    nums[low] = nums[high];
                    nums[high] = low;
                    high--;
                }
            }
        }
        return low;
    }
};

双指针法（快慢指针法）

原理：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置
• 若碰到目标元素，慢指针不动，快指针向后移，若后面元素不为目标元素，则前移

 

// 时间复杂度：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;
    }
};