C++刷题第一天 数组理论基础，LeetCode704、27

数组理论基础

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

数组可以方便的呢通过下标索引的方式获取到下标下对应的数据。

如图：

 需要注意两点：

• 数组下标都是从0开始的
• 数组内存空间的地址是连续的

因为数组的内存空间的地址是连续的，所以我们在删除或者增加元素的时候，就有可能要移动其他元素的地址。

例如删除下标为3的元素，需要对下标为3的元素后面的所有元素都要做移动操作，如图所示：

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

vector与array的区别与联系：http://t.csdn.cn/620ss

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

在c++中，二维数组在内存空间的地址是连续的，测试代码如下：

void test_arr() {
    int array[2][3] = {
		{0, 1, 2},
		{3, 4, 5}
    };
    cout << &array[0][0] << " " << &array[0][1] << " " << &array[0][2] << endl;
    cout << &array[1][0] << " " << &array[1][1] << " " << &array[1][2] << endl;
}

int main() {
    test_arr();
}

结果：

0x7ffee4065820 0x7ffee4065824 0x7ffee4065828
0x7ffee406582c 0x7ffee4065830 0x7ffee4065834

地址为16进制，int型是4个字节，所以每个元素地址差4.

 所以可以看出C++中，二维数组的地址空间是连续的

leetcode 704 二分查找

这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件，当大家看到题目描述满足如上条件的时候，可要想一想是不是可以用二分法了。

二分查找最重要的就是边界划分的问题，这道题中的数组是包含两端的数组的，相当于左闭右闭的情况，即为[left,right]。左闭右开是[left,right)，通常只会有这两种情况。

左闭右闭的情况

先把代码铺上：

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

解题思路：

二分法就是比较目标值与数组中间值的大小，如果midle>target，则target肯定在左半边，如果midle<target，则target肯定在右半边，相等的话则返回midle下标。很简单的思想，重要的是边界划分。

因为数组是[left,right]，所以num[left] = num[right]是有意义的，所以应该是while(left<=right)，左右两边都包含，并且left和right都已经和target比较过，所以左加右减，这两个数都会包含在新的查找区间内。

左闭右开的情况

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 midle = left + (right-left)/2;
            if (nums[midle] < target){
                left = midle+1;   // target 在右区间，在[middle + 1, right)中
            }
            else if (nums[midle] > target){
                right = midle;    //第三处不同， target 在左区间，在[left, middle)中
            }
            else return midle;
        }
        return -1;
    }
};

因为不包含最右边的元素，所以数组中的有效元素是【left，right-1】，对应的左闭右开的数组就是[left,right)，所以right=nums.size()；right=midle同样

27 移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

思路：

• 数组在内存空间中的地址是连续的，所以不能单独删除中间的某个元素，只能覆盖
• 只需要将不等于val的值移动到数组前面，并且返回不等val值的元素个数N即可，不用管num[N]之后的元素是什么

方法一：暴力解题法

双重遍历，找到一个等于val的元素，就把后面所有的元素前移一位，覆盖掉等于val的元素，这样的时间复杂度为O(n^2)，而且不会占用其他另外的空间，这道题目暴力解法在leetcode上是可以过的。

// 时间复杂度：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开始；快指针用来遍历数组，每次循环+1；

当本次循环中快指针对应的元素不等于val，则将num[fast]赋值给num[slow]，然后slow+1；如果本次循环中快指针对应的元素等于val，则不进行任何操作，继续下一循环；

循环结束，返回slow，slow值就是新数组的长度，老数组中所有不等于val的元素都移动到了数组的前slow个元素中，slow之后的元素不管

代码：

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

错误思路：

我曾想过类似双指针的方法，但是不太一样。

先用一个指针便利数组，找到等于val的元素，就将数组最后一位赋值给当前元素，并且right-1，但是right是有可能等于val的，如果要在筛选一遍right！=val，就会又变的比较复杂，如果有朋友有类似想法，可以探讨一下。