算法学习Day1 | Chapter1数组

1.1 数组理论基础

链接：文章

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

2. 数组下标都是从0开始的。

3. 数组内存空间的地址是连续的，所以，在删除或者增添元素时，就难免要移动其他元素的地址。

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

5. C++中二维数组在地址空间上是连续的。

1.2 二分查找

链接：文章；视频；704. 二分查找

1. 左闭右闭

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

2. 左闭右开

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

1.3 移除元素

链接：文章；视频；27. 移除元素

1. 暴力法：两层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--; 
                size--;
            }
        }
        return size;
    }
};

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

• 空间复杂度：O(1)

2. 双指针法：快指针寻找目标元素，慢指针更新新数组下标的位置

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

• 时间复杂度：O(n)

• 空间复杂度：O(1)