数组问题的总结

一.数组的知识前顾

        数组是在内存里面连续排序的一块内存，内容是相同数据类型的集合，并且下标从0开始，连续递增。因此，在对数组元素进行删除，修改的时候，需要移动部分的其他元素的地址。

        在C++中，vector的实现是array，但vector是容器，而不是数组。

二.二分查找法

该题为leetcode的704题

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4     

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2     
输出: -1        
解释: 2 不存在 nums 中因此返回 -1        

提示：

• 你可以假设 nums 中的所有元素是不重复的。
• n 将在 [1, 10000]之间。
• nums 的每个元素都将在 [-9999, 9999]之间。

解法（我的思路）：

首先我们需要知道vector的长度，vector有个封装好的函数，size()。既然是排好序的数组，那么需要先和中间的进行对比，然后在改变middle的值，一步一步地进行比大小，从而获得middle的值，即下标元素，否则返回-1。先从中间判断，target比nums[middle]大，说明left-middle的值都不符合target的值，则需要把left的下标进行移动，注意left=middle+1,如果不加一，会超时。具体如下：

int right=nums.size();

     int left=0;

     int midle=0;

     while(left<right) {

         midle=left+((right-left) /2);

         if(target>nums[midle]){left=midle+1;}

         else if(target<nums[midle]){right=midle;}

               else {return midle;}}return -1；

     }

三.删除元素法

代表leetcode的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。

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

class Solution {

public:

    int removeElement(vector<int>& nums, int val) {

        auto it =nums.begin();

        auto it1=nums.end();

        int len =nums.size();

        for(int i=0;i<len;i++){

            if(nums[i]== val){

                for(int j=i+1;j<len;j++){

                    nums[j-1]=nums[j];               }

                i--;

               len--;

            }

        }return len;}

};

思路：使用双向指针，一定要注意，数组的话，下标就可以代表引用，双向指针只需要搞两个数组下标就可以了。我之前使用容器进行操作，使用尾部nums.back(); nums.pop_back();，一个进行赋值，一个进行删去尾部的值，但是实际上并不需要这样，对于这个题目，只需要把数组长度缩短就可以修改了整个数组的值。

四.有序数组的平方

此题为leetcode的977题目

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

• 输入：nums = [-4,-1,0,3,10]
• 输出：[0,1,9,16,100]
• 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2：

• 输入：nums = [-7,-3,2,3,11]
• 输出：[4,9,9,49,121]

该题需要需要注意时间复杂度

• 请你设计时间复杂度为 O(n) 的算法解决本问题

以下是我使用暴力破解的方法进行编码，但是能过大部分的测试案列，而小部分的时间超时了。注意用到了两个循环，所有不太行。

class Solution {

public:

    vector<int> sortedSquares(vector<int>& nums) {

       

        auto len =nums.size();

        for(int i=0;i<len;i++){

            nums[i]=nums[i]*nums[i];

             if(i>0 && nums[i-1]>nums[i]) {

                 for(int j=0;j<=i;j++){

                      if(nums[j]<nums[i]) {

                          int t=0;

                          t=nums[j];

                          nums[j]=nums[i];

                          nums[i]=t;  

                      }  

                 }

             }

        }

    return nums;

    }

};

最简单的暴力破解法：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

而如果使用双向指针的方法，先新建一个数组，把头和尾都进行平方比较，哪个大，就放哪个进去新数组，新数组的下标变量用nums[k--]=nums[i]*nums[i]就可以做了。以下是符合时间复杂度的解法。

class Solution {

public:

    vector<int> sortedSquares(vector<int>& nums) {

        int len =nums.size()-1;

        vector<int> result(nums.size(), 0);

        for(int i = 0, j = nums.size() - 1;i<=j;){

            if(nums[j]*nums[j]>nums[i]*nums[i]){

                result[len--]=nums[j]*nums[j];

                j--;

            }

            else {

                result[len--]=nums[i]*nums[i];

                i++;

            }

        }

    return result;

    }

};