代码随想录算法训练营第一天 | 数组理论基础、LeetCode704 二分查找、LeetCode27 移除元素

数组理论基础：

C++中数组是这样定义的：

template<typename T>
int n;
cin >> n;
T nums[n]; 

首先要确定数组长度和数组单个元素内容，再给数组元素赋值或者直接在定义时初始化。未初始化数组内会是给定内存内值。因此多时候包括一般变量在未初始化时都会是随机的数值。这个笔试题中也会很经常地遇到。

数组一般和for循环一起用得比较多，和for循环一起用时用变量i对应数组下标去访问数组元素。数组元素使用下标访问即可修改，对应的内存地址上的寻址方式也就是将数组名（可看作一个指针）加上对应下标*sizeof(T)得到对应元素的地址，再进而对该地址取址得到想要得到的数值。实际上该C++语言对应汇编代码也就是这么写的。不过今天刷题时候应该用不到这些，直接使用规定的定义和赋值方式就行了。

LeetCode704 二分查找

给定一个升序数组和一个目标值target，要求返回数组中值等于目标值元素的下标，如果不存在这样的值，返回-1.

左闭右闭写法：

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

其中left <= right中=号是经过考虑的。不考虑相当于没刷，因为算是在碰运气。笔试时这种现象就很明显了，平时刷题时偷懒与否很容易就能看出来。

说回这里，每次比较完后由于原先left < right，不加=在nums[mid]不等于target的时候，left = mid + 1 或者 right = mid - 1时可能left和right直接就相等了，这个时候直接就跳出循环了。所以要加上=，否则可能还要分别比较nums[left]和nums[right]的值和target是否相等，会增大工作量。

左闭右开区间：

其实看到这里我是蒙了一下的，之前一刷的时候纯凭感觉就写出了上面的写法。现在才知道时左闭右闭区间。那么再反思下左闭右开区间的写法。区别主要如下：

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

右开是一个要思考的点，为什么要右开呢？为什么不左开呢？注意数组下标是从0开始到num.size()-1的，于是把right初始定为nums.size()，就必需要右开才能说得通了。这里由于左闭右开，直接写left < right即可，也不需要再考虑是否等于的情况了，相比上面的解法思考量会少一点。同样right赋值的时候需要直接等于mid而不是mid - 1以维持右开的特性。

LeetCode 27 移除数组元素

暴力/双指针解法，要放到面试上去估计又超时了，写了二十多分钟。看来我真没白来这个训练营。编程能力不如小学生我这吃饭的能力还真是欠得很多。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int res = 0;
        for (int i = 0; i < nums.size() - res; i++) {
            int d = 0;
            while (i < nums.size() - res && nums[i] == val) {
                d++;
                i++;
            }
            res += d;
            for (int j = i; j < nums.size(); j++) {
                nums[j - d] = nums[j];
            }
            i -= d;
        }
        return nums.size() - res;
    }
};

最后还是过了。来稍微讲一下我这感觉十分冗余的思路吧。首先第一重循环是整体循环，后面发现要限制为nums.size() - res，限制在移除元素后长度。循环内一个元素d记录移除距离，同时i++，这样是为了处理多个值等于val的元素在一块儿。d在之后也会用到，除了res需要加上d之外，在实际循环时将前面距离d的元素统统换成后面直到数组末尾的元素，这样做是为了移位替换，变相就移除了数组元素。毕竟不像STL容器可以直接调成员函数。最后i还要-d回到最初位置对移过来的元素做处理。这些都是我一刷时候完全没有留意过的。难怪我面试总是手撕不出来。真是我的问题了。

稍微优化了一下上述代码如下：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int res = 0;
        for (int i = 0; i < nums.size() - res; i++) {
            int d = 0;
            while (i < nums.size() - res && nums[i + d] == val) {
                d++;
            }
            res += d;
            for (int j = i + d; j < nums.size(); j++) {
                nums[j - d] = nums[j];
            }
        }
        return nums.size() - res;
    }
};

去除了i加减的操作，保证了循环的一致性，也更简单，方便面试时候编写了。

其实感觉这种思路解法和双指针法其实也并没什么太大差别了。

双指针法：

晚上稍微改了下，增加了双指针写法。现在回头看能明白当时暴力解法是有多复杂了。不愧是暴力。但是时间不早该睡觉了，就先贴代码了。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left = 0, right = 0;
        while (left < nums.size() && right < nums.size()) {
            while (left < nums.size() && nums[left] != val) left++;
            right = left + 1;
            while (right < nums.size() && nums[right] == val) right++;
            if (left < nums.size() && right < nums.size()) {
                nums[left] = nums[right];
                nums[right] = val;
            }
        }
        return left;
    }
};

这里双指针法其实涉及的是一种属性两种取值的双指，比如left指针指向的是需要被移除的val值元素的下表，right指针指向的是正常的不需要被移除的元素的下标。不过这里的right指针不像二分法中的那样一开始就指向数组末尾下标，而是从left + 位置处开始，而在给right指针赋值时，left指针已经被赋为了值为val的一个元素的下标值。这样交换后重新开始，直到left指针停下并且right已经达到最边界即无元素可再被移动到前面去和val值元素交换的时候，我们就得到了left值作为移除该元素后的数组长度了。

LeetCode 35 搜索插入位置

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

稍微改动下，用左闭右开形式，把right赋为应该插入位置即可

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

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> res;
        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 if (nums[mid] == target) {
                int start = mid, end = mid;
                while (start - 1 >= 0 && nums[start-1] == target) {
                    start--;
                }
                while (end + 1 < nums.size() && nums[end+1] == target) {
                    end++;
                }
                res.push_back(start);
                res.push_back(end);
                break;
            }
        }
        if (res.empty()) {
            res.push_back(-1);
            res.push_back(-1);
        }
        return res;
    }
};

一开始没看出来，后面想到今天的二分查找才知道可以迁移。但要用左闭右闭形式，因为会有两个元素相等的情况。

刷到这里，才明白今天为什么必需要掌握左闭右闭形式和左闭右开形式了。一个是left和right可以重叠，另一个是不可以的。