数组学习笔记

数组特点：下标从0开始、元素地址连续（c++）

一、二分查找

        给定一个有n个元素的有序数组nums和一个目标值target，写一个函数查找数组中是否存在目标值target，若存在返回对应下标，否则返回-1。

        难点：一、while循环的判断条件

                   二、更改left和right具体更改的值

        1）明确区间，左闭右闭 [left,right) or 左闭右开 [left,right] or 左开右闭（少见）(left,right] ,区间不同，对left和right的处理不同。

        1、左闭右闭 [left,right]

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() -1;    //[left,right]right下标要有定义
        int mid;
        while (left <= right)          //left 可以等于 right
        {
            mid = left + (right - left)/2; //计算中间值
            if (nums[mid] > target)
            {//说明target属于[left,mid]
                right = mid - 1;    //因为 mid 下标的值 >target
            }
            else if (nums[mid] < target)
            {//说明target属于[mid,right]
                left = mid + 1;    //因为 mid 下标的值 <target
            }
            else    //查找成功
            {
                return mid;
            }

        }
        return -1;    //查找失败
    }
};

        2、左闭右开 [left,right]

       

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() -1;    //[left,right)right下标不需要有定义
        int mid;
        while (left < right)          //left 不可以等于 right
        {
            mid = left + (right - left)/2; //计算中间值
            if (nums[mid] > target)
            {//说明target属于[left,mid]
                right = mid ;    
            }
            else if (nums[mid] < target)
            {//说明target属于[mid,right]
                left = mid + 1;    //因为 mid 下标的值 <target
            }
            else    //查找成功
            {
                return mid;
            }

        }
        return -1;    //查找失败
    }
};

       

二、移除元素

        数组的元素在地址中是连续的，静态的，所以数组中的删除实际上指的是覆盖。

        这个问题有三个解法。

        1)暴力解法

        写两个for循环，每次遇到需要移除的元素进行一次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--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

        2)双指针解法

        原理：两个指针，一个是原先数组指针-fast，一个是新的数组指针-slow，当出现需要删除的元素时，slow指针不变，fast指针++。否则另nums[slow] = nums[fast]。这样就形成了覆盖。

                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;
    }
};

                2、不考虑排序

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

三、有序数组的平方

        给一个顺序数组，要求，对数组元素进行平方后也返回一个顺序数组。

        这里采取双指针解法，原理是，对于一个包含负数的顺序数字，其平方的最大值只会出现在数组的两端。所以创建一个新的数组，检索所给数组的两端，大于的一端平方后放入新数组的尾端。然后++或者--。所以这里需要三个指针，左端（++）、右端（--）和新数组的尾端（--）。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int left = 0;
        int right = nums.size()-1;
        int new_index = nums.size()-1;
        vector<int> result(nums.size(), 0);
        while(left<=right)
        {
            if(nums[left]*nums[left] > nums[right]*nums[right])
            {
                result[new_index--] = nums[left]*nums[left];
                left++;
            }
            else
            {
                result[new_index--] = nums[right]*nums[right];
                right--;
            }

        }
        return result;
    }
};

四、长度最小的子数组

        给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

        这里采取双指针策略，当指针内的子数组>=s时，计算其数组长度，并逐步增加i来缩小子数组长度。否则j++，扩张子数组长度。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sublength = 0;      //当前子序列长度
        int sum = 0;            //当前子序列的和
        int i = 0;
        for(int j=0;j<nums.size();j++)
        {
            sum += nums[j];

            while(sum >= target)
            {
                sublength = j-i+1;
                result = result < sublength ? result : sublength;
                sum -= nums[i++];
            }
        }

        return result == INT32_MAX? 0 : result;
    }
};

五、螺旋矩阵II

        给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

        易错点：边界处理，即每条边处理方式不一样

        规则固定，左闭右开，不处理最后一个节点，把最后一个节点留个下个边处理（作为下个边的起始位置）

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int startx = 0;
        int starty = 0;
        int loop = n/2;
        int mid = n/2;
        int count = 1;
        int offset = 1;
        int i,j;
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组

        while(loop --)
        {
            i = startx;
            j = starty;

            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;

            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;

        }
     if (n % 2) {
            res[mid][mid] = count;
        }
        return res;

    }
};